FM / Fakes

/home/techb158/immovalet.com/vendor/maatwebsite/excel/src/Fakes/

/home/techb158/immovalet.com/vendor/maatwebsite/excel/src/Fakes

Name	Size	Mode	Actions
ExcelFake.php	10274	0644	edit dl rm
fake_file	0	0644	edit dl rm

Edit: /home/techb158/immovalet.com/vendor/maatwebsite/excel/src/Fakes/ExcelFake.php (10274B)

<?php

namespace Maatwebsite\Excel\Fakes;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\PendingDispatch;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Queue;
use Maatwebsite\Excel\Exporter;
use Maatwebsite\Excel\Importer;
use Maatwebsite\Excel\Reader;
use PHPUnit\Framework\Assert;
use Symfony\Component\HttpFoundation\BinaryFileResponse;
use Symfony\Component\HttpFoundation\File\UploadedFile;

class ExcelFake implements Exporter, Importer
{
    /**
     * @var array
     */
    protected $downloads = [];

/**
     * @var array
     */
    protected $stored = [];

/**
     * @var array
     */
    protected $queued = [];

/**
     * @var array
     */
    protected $raws = [];

/**
     * @var array
     */
    protected $imported = [];

/**
     * @var bool
     */
    protected $matchByRegex = false;

/**
     * @var object|null
     */
    protected $job;

/**
     * {@inheritdoc}
     */
    public function download($export, string $fileName, string $writerType = null, array $headers = [])
    {
        $this->downloads[$fileName] = $export;

return new BinaryFileResponse(__DIR__ . '/fake_file');
    }

/**
     * {@inheritdoc}
     */
    public function store($export, string $filePath, string $disk = null, string $writerType = null, $diskOptions = [])
    {
        if ($export instanceof ShouldQueue) {
            return $this->queue($export, $filePath, $disk, $writerType);
        }

$this->stored[$disk ?? 'default'][$filePath] = $export;

return true;
    }

/**
     * {@inheritdoc}
     */
    public function queue($export, string $filePath, string $disk = null, string $writerType = null, $diskOptions = [])
    {
        Queue::fake();

$this->stored[$disk ?? 'default'][$filePath] = $export;
        $this->queued[$disk ?? 'default'][$filePath] = $export;

$this->job = new class
        {
            use Queueable;

public function handle()
            {
                //
            }
        };

Queue::push($this->job);

return new PendingDispatch($this->job);
    }

/**
     * @param object $export
     * @param string $writerType
     *
     * @return string
     */
    public function raw($export, string $writerType)
    {
        $this->raws[get_class($export)] = $export;

return 'RAW-CONTENTS';
    }

/**
     * @param object              $import
     * @param string|UploadedFile $file
     * @param string|null         $disk
     * @param string|null         $readerType
     *
     * @return Reader|PendingDispatch
     */
    public function import($import, $file, string $disk = null, string $readerType = null)
    {
        if ($import instanceof ShouldQueue) {
            return $this->queueImport($import, $file, $disk, $readerType);
        }

$filePath = ($file instanceof UploadedFile) ? $file->getClientOriginalName() : $file;

$this->imported[$disk ?? 'default'][$filePath] = $import;

return $this;
    }

/**
     * @param object              $import
     * @param string|UploadedFile $file
     * @param string|null         $disk
     * @param string|null         $readerType
     *
     * @return array
     */
    public function toArray($import, $file, string $disk = null, string $readerType = null): array
    {
        $filePath = ($file instanceof UploadedFile) ? $file->getFilename() : $file;

$this->imported[$disk ?? 'default'][$filePath] = $import;

return [];
    }

/**
     * @param object              $import
     * @param string|UploadedFile $file
     * @param string|null         $disk
     * @param string|null         $readerType
     *
     * @return Collection
     */
    public function toCollection($import, $file, string $disk = null, string $readerType = null): Collection
    {
        $filePath = ($file instanceof UploadedFile) ? $file->getFilename() : $file;

$this->imported[$disk ?? 'default'][$filePath] = $import;

return new Collection();
    }

/**
     * @param ShouldQueue         $import
     * @param string|UploadedFile $file
     * @param string|null         $disk
     * @param string              $readerType
     *
     * @return PendingDispatch
     */
    public function queueImport(ShouldQueue $import, $file, string $disk = null, string $readerType = null)
    {
        Queue::fake();

$filePath = ($file instanceof UploadedFile) ? $file->getFilename() : $file;

$this->queued[$disk ?? 'default'][$filePath]   = $import;
        $this->imported[$disk ?? 'default'][$filePath] = $import;

return new PendingDispatch(new class
        {
            use Queueable;

public function handle()
            {
                //
            }
        });
    }

/**
     * When asserting downloaded, stored, queued or imported, use regular expression
     * to look for a matching file path.
     *
     * @return void
     */
    public function matchByRegex()
    {
        $this->matchByRegex = true;
    }

/**
     * When asserting downloaded, stored, queued or imported, use regular string
     * comparison for matching file path.
     *
     * @return void
     */
    public function doNotMatchByRegex()
    {
        $this->matchByRegex = false;
    }

/**
     * @param string        $fileName
     * @param callable|null $callback
     */
    public function assertDownloaded(string $fileName, $callback = null)
    {
        $fileName = $this->assertArrayHasKey($fileName, $this->downloads, sprintf('%s is not downloaded', $fileName));