anonymous//jaxon-upload/tests/TestUpload/UploadHandlerTest.php$0 - Code Metrics - jaxon-php/jaxon-mono - Measure and Improve Code Quality continuously with Scrutinizer

ad/UploadHandlerTest.php$0 A
last analyzed 2025-12-26 16:02 UTC

↳ Parent: UploadHandlerTest::testPsrAjaxUpload()
Complexity

Total Complexity
Size/Duplication

Total Lines	12
Duplicated Lines	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
dl	0
loc	12
rs	10
c	1
b	0
f	0
wmc	2
<?php

namespace Jaxon\Upload\Tests\TestUpload;

use Jaxon\Jaxon;
use Jaxon\Exception\RequestException;
use Jaxon\Exception\SetupException;
use Nyholm\Psr7\Factory\Psr17Factory;
use Nyholm\Psr7\UploadedFile;
use Nyholm\Psr7Server\ServerRequestCreator;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use PHPUnit\Framework\TestCase;

use function Jaxon\jaxon;
use function Jaxon\Upload\_register as _registerUpload;
use function copy;
use function filesize;
use function mkdir;

class UploadHandlerTest extends TestCase
{
    /**
     * @var string
     */
    protected $sNameWhite;

    /**
     * @var string
     */
    protected $sPathWhite;

    /**
     * @var int
     */
    protected $sSizeWhite;

    /**
     * @var string
     */
    protected $sNameBlue;

    /**
     * @var string
     */
    protected $sPathBlue;

    /**
     * @var int
     */
    protected $sSizeBlue;

    /**
     * @throws SetupException
     */
    public function setUp(): void
    {
        jaxon()->di()->getPluginManager()->registerPlugins();
        _registerUpload();

        jaxon()->setOption('core.response.send', false);
        jaxon()->setAppOption('upload.enabled', true);
        jaxon()->setAppOptions([
            'adapter' => 'local',
            'dir' => __DIR__ . '/../upload/dst',
            // 'options' => [],
        ], 'storage.stores.uploads');

        $tmpDir = __DIR__ . '/../upload/tmp';
        @mkdir($tmpDir);
        /** @scrutinizer ignore-unhandled */ @mkdir($tmpDir);

        $sSrcWhite = __DIR__ . '/../upload/src/white.png';
        $this->sNameWhite = 'white.png';
        $this->sPathWhite = "$tmpDir/{$this->sNameWhite}";
        $this->sSizeWhite = filesize($sSrcWhite);
        // Copy the file to the temp dir.
        @copy($sSrcWhite, $this->sPathWhite);
        /** @scrutinizer ignore-unhandled */ @copy($sSrcWhite, $this->sPathWhite);

        $sSrcBlue = __DIR__ . '/../upload/src/blue.png';
        $this->sNameBlue = 'blue.png';
        $this->sPathBlue = "$tmpDir/{$this->sNameBlue}";
        $this->sSizeBlue = filesize($sSrcBlue);
        // Copy the file to the temp dir.
        @copy($sSrcBlue, $this->sPathBlue);

        jaxon()->register(Jaxon::CALLABLE_CLASS, 'SampleUpload', __DIR__ . '/../src/sample.php');
        jaxon()->di()->getBootstrap()->onBoot();
    }

    /**
     * @throws SetupException
     */
    public function tearDown(): void
    {
        jaxon()->reset();
        parent::tearDown();
    }

    /**
     * @throws RequestException
     */
    public function testAjaxUpload()
    {
        jaxon()->setAppOption('upload.default.storage', 'uploads');
        // Send a request to the registered class
        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
            return $c->g(ServerRequestCreator::class)
                ->fromGlobals()
                ->withParsedBody([
                    'jxncall' => json_encode([
                        'type' => 'class',
                        'name' => 'SampleUpload',
                        'method' => 'myMethod',
                        'args' => [],
                    ]),
                ])
                ->withUploadedFiles([
                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
                ])
                ->withMethod('POST');
        });

        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
        jaxon()->processRequest();

        // Uploaded files
        $aFiles = jaxon()->upload()->files();
        $this->assertCount(1, $aFiles);
        $this->assertCount(1, $aFiles['image']);
        $this->assertCount(1, /** @scrutinizer ignore-type */ $aFiles['image']);
        $xFile = $aFiles['image'][0];
        $this->assertEquals('white', $xFile->name());
        $this->assertEquals($this->sNameWhite, $xFile->filename());
        $this->assertEquals('png', $xFile->type());
        $this->assertEquals('png', $xFile->extension());
    }

    /**
     * @throws RequestException
     */
    public function testAjaxUploadMultipleFiles()
    {
        jaxon()->setAppOption('upload.default.storage', 'uploads');
        // Send a request to the registered class
        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
            return $c->g(ServerRequestCreator::class)
                ->fromGlobals()
                ->withParsedBody([
                    'jxncall' => json_encode([
                        'type' => 'class',
                        'name' => 'SampleUpload',
                        'method' => 'myMethod',
                        'args' => [],
                    ]),
                ])
                ->withUploadedFiles([
                    'image' => [
                        new UploadedFile($this->sPathWhite, $this->sSizeWhite,
                            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
                        new UploadedFile($this->sPathBlue, $this->sSizeBlue,
                            UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
                    ],
                ])
                ->withMethod('POST');
        });

        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
        jaxon()->processRequest();

        // Uploaded files
        $aFiles = jaxon()->upload()->files();
        $this->assertCount(1, $aFiles);
        $this->assertCount(2, $aFiles['image']);
        $this->assertCount(2, /** @scrutinizer ignore-type */ $aFiles['image']);
        $xFile = $aFiles['image'][0];
        $this->assertEquals('white', $xFile->name());
        $this->assertEquals($this->sNameWhite, $xFile->filename());
        $this->assertEquals('png', $xFile->type());
        $this->assertEquals('png', $xFile->extension());
        $xFile = $aFiles['image'][1];
        $this->assertEquals('blue', $xFile->name());
        $this->assertEquals($this->sNameBlue, $xFile->filename());
        $this->assertEquals('png', $xFile->type());
        $this->assertEquals('png', $xFile->extension());
    }

    /**
     * @throws RequestException
     */
    public function testAjaxUploadMultipleNames()
    {
        jaxon()->setAppOption('upload.default.storage', 'uploads');
        // Send a request to the registered class
        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
            return $c->g(ServerRequestCreator::class)
                ->fromGlobals()
                ->withParsedBody([
                    'jxncall' => json_encode([
                        'type' => 'class',
                        'name' => 'SampleUpload',
                        'method' => 'myMethod',
                        'args' => [],
                    ]),
                ])
                ->withUploadedFiles([
                    'white' => [
                        new UploadedFile($this->sPathWhite, $this->sSizeWhite,
                            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
                    ],
                    'blue' => [
                        new UploadedFile($this->sPathBlue, $this->sSizeBlue,
                            UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
                    ],
                ])
                ->withMethod('POST');
        });

        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
        jaxon()->processRequest();

        // Uploaded files
        $aFiles = jaxon()->upload()->files();
        $this->assertCount(2, $aFiles);
        $this->assertCount(1, $aFiles['white']);
        $this->assertCount(1, /** @scrutinizer ignore-type */ $aFiles['white']);
        $this->assertCount(1, $aFiles['blue']);
        $xFile = $aFiles['white'][0];
        $this->assertEquals('white', $xFile->name());
        $this->assertEquals($this->sNameWhite, $xFile->filename());
        $this->assertEquals('png', $xFile->type());
        $this->assertEquals('png', $xFile->extension());
        $xFile = $aFiles['blue'][0];
        $this->assertEquals('blue', $xFile->name());
        $this->assertEquals($this->sNameBlue, $xFile->filename());
        $this->assertEquals('png', $xFile->type());
        $this->assertEquals('png', $xFile->extension());
    }

    /**
     * @throws RequestException
     */
    public function testAjaxUploadNameSanitizer()
    {
        jaxon()->setAppOption('upload.default.storage', 'uploads');
        jaxon()->upload()->sanitizer(function($sFilename, $sVarName) {
            return $sVarName === 'image' ? 'img_' . $sFilename : $sFilename;
        });
        // Send a request to the registered class
        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
            return $c->g(ServerRequestCreator::class)
                ->fromGlobals()
                ->withParsedBody([
                    'jxncall' => json_encode([
                        'type' => 'class',
                        'name' => 'SampleUpload',
                        'method' => 'myMethod',
                        'args' => [],
                    ]),
                ])
                ->withUploadedFiles([
                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
                ])
                ->withMethod('POST');
        });

        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
        jaxon()->processRequest();

        // Uploaded files
        $aFiles = jaxon()->upload()->files();
        $this->assertCount(1, $aFiles);
        $this->assertCount(1, $aFiles['image']);
        $this->assertCount(1, /** @scrutinizer ignore-type */ $aFiles['image']);
        $xFile = $aFiles['image'][0];
        $this->assertEquals('img_white', $xFile->name());
        $this->assertEquals('png', $xFile->type());
        $this->assertEquals('png', $xFile->extension());
        $this->assertEquals($this->sNameWhite, $xFile->filename());
    }

    /**
     * @throws RequestException
     */
    public function testUploadFileTypeValidationOk()
    {
        jaxon()->setAppOption('upload.default.storage', 'uploads');
        jaxon()->setAppOption('upload.default.types', ['png']);
        // Send a request to the registered class
        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
            return $c->g(ServerRequestCreator::class)
                ->fromGlobals()
                ->withParsedBody([
                    'jxncall' => json_encode([
                        'type' => 'class',
                        'name' => 'SampleUpload',
                        'method' => 'myMethod',
                        'args' => [],
                    ]),
                ])
                ->withUploadedFiles([
                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
                ])
                ->withMethod('POST');
        });

        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
        jaxon()->processRequest();

        // Return the file name for the next test
        $aFiles = jaxon()->upload()->files();
        $this->assertCount(1, $aFiles);
        $this->assertCount(1, $aFiles['image']);
        $this->assertCount(1, /** @scrutinizer ignore-type */ $aFiles['image']);
        $xFile = $aFiles['image'][0];
        $this->assertEquals('white', $xFile->name());
        $this->assertEquals($this->sNameWhite, $xFile->filename());
    }

    /**
     * @throws RequestException
     */
    public function testUploadFileTypeValidationError()
    {
        jaxon()->setAppOption('upload.default.storage', 'uploads');
        jaxon()->setAppOption('upload.default.types', ['jpg']);
        // Send a request to the registered class
        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
            return $c->g(ServerRequestCreator::class)
                ->fromGlobals()
                ->withParsedBody([
                    'jxncall' => json_encode([
                        'type' => 'class',
                        'name' => 'SampleUpload',
                        'method' => 'myMethod',
                        'args' => [],
                    ]),
                ])
                ->withUploadedFiles([
                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
                ])
                ->withMethod('POST');
        });

        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
        $this->expectException(RequestException::class);
        jaxon()->processRequest();
    }

    /**
     * @throws RequestException
     */
    public function testUploadFileExtensionValidationOk()
    {
        jaxon()->setAppOption('upload.default.storage', 'uploads');
        jaxon()->setAppOption('upload.default.extensions', ['png']);
        // Send a request to the registered class
        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
            return $c->g(ServerRequestCreator::class)
                ->fromGlobals()
                ->withParsedBody([
                    'jxncall' => json_encode([
                        'type' => 'class',
                        'name' => 'SampleUpload',
                        'method' => 'myMethod',
                        'args' => [],
                    ]),
                ])
                ->withUploadedFiles([
                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
                ])
                ->withMethod('POST');
        });

        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
        jaxon()->processRequest();

        // Return the file name for the next test
        $aFiles = jaxon()->upload()->files();
        $this->assertCount(1, $aFiles);
        $this->assertCount(1, $aFiles['image']);
        $this->assertCount(1, /** @scrutinizer ignore-type */ $aFiles['image']);
        $xFile = $aFiles['image'][0];
        $this->assertEquals('white', $xFile->name());
        $this->assertEquals($this->sNameWhite, $xFile->filename());
    }

    /**
     * @throws RequestException
     */
    public function testUploadFileExtensionValidationError()
    {
        jaxon()->setAppOption('upload.default.storage', 'uploads');
        jaxon()->setAppOption('upload.default.extensions', ['jpg']);
        // Send a request to the registered class
        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
            return $c->g(ServerRequestCreator::class)
                ->fromGlobals()
                ->withParsedBody([
                    'jxncall' => json_encode([
                        'type' => 'class',
                        'name' => 'SampleUpload',
                        'method' => 'myMethod',
                        'args' => [],
                    ]),
                ])
                ->withUploadedFiles([
                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
                ])
                ->withMethod('POST');
        });

        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
        $this->expectException(RequestException::class);
        jaxon()->processRequest();
    }

    /**
     * @throws RequestException
     */
    public function testUploadFileMaxSizeValidationOk()
    {
        jaxon()->setAppOption('upload.default.storage', 'uploads');
        jaxon()->setAppOption('upload.default.max-size', 30000);
        // Send a request to the registered class
        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
            return $c->g(ServerRequestCreator::class)
                ->fromGlobals()
                ->withParsedBody([
                    'jxncall' => json_encode([
                        'type' => 'class',
                        'name' => 'SampleUpload',
                        'method' => 'myMethod',
                        'args' => [],
                    ]),
                ])
                ->withUploadedFiles([
                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
                ])
                ->withMethod('POST');
        });

        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
        jaxon()->processRequest();

        // Return the file name for the next test
        $aFiles = jaxon()->upload()->files();
        $this->assertCount(1, $aFiles);
        $this->assertCount(1, $aFiles['image']);
        $this->assertCount(1, /** @scrutinizer ignore-type */ $aFiles['image']);
        $xFile = $aFiles['image'][0];
        $this->assertEquals('white', $xFile->name());
        $this->assertEquals($this->sNameWhite, $xFile->filename());
    }

    /**
     * @throws RequestException
     */
    public function testUploadFileMaxSizeValidationError()
    {
        jaxon()->setAppOption('upload.default.storage', 'uploads');
        jaxon()->setAppOption('upload.default.max-size', 25000);
        // Send a request to the registered class
        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
            return $c->g(ServerRequestCreator::class)
                ->fromGlobals()
                ->withParsedBody([
                    'jxncall' => json_encode([
                        'type' => 'class',
                        'name' => 'SampleUpload',
                        'method' => 'myMethod',
                        'args' => [],
                    ]),
                ])
                ->withUploadedFiles([
                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
                ])
                ->withMethod('POST');
        });

        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
        $this->expectException(RequestException::class);
        jaxon()->processRequest();
    }

    /**
     * @throws RequestException
     */
    public function testUploadFileMinSizeValidationOk()
    {
        jaxon()->setAppOption('upload.default.storage', 'uploads');
        jaxon()->setAppOption('upload.default.min-size', 25000);
        // Send a request to the registered class
        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
            return $c->g(ServerRequestCreator::class)
                ->fromGlobals()
                ->withParsedBody([
                    'jxncall' => json_encode([
                        'type' => 'class',
                        'name' => 'SampleUpload',
                        'method' => 'myMethod',
                        'args' => [],
                    ]),
                ])
                ->withUploadedFiles([
                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
                ])
                ->withMethod('POST');
        });

        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
        jaxon()->processRequest();

        // Return the file name for the next test
        $aFiles = jaxon()->upload()->files();
        $this->assertCount(1, $aFiles);
        $this->assertCount(1, $aFiles['image']);
        $this->assertCount(1, /** @scrutinizer ignore-type */ $aFiles['image']);
        $xFile = $aFiles['image'][0];
        $this->assertEquals('white', $xFile->name());
        $this->assertEquals($this->sNameWhite, $xFile->filename());
    }

    /**
     * @throws RequestException
     */
    public function testUploadFileMinSizeValidationError()
    {
        jaxon()->setAppOption('upload.default.storage', 'uploads');
        jaxon()->setAppOption('upload.default.min-size', 30000);
        // Send a request to the registered class
        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
            return $c->g(ServerRequestCreator::class)
                ->fromGlobals()
                ->withParsedBody([
                    'jxncall' => json_encode([
                        'type' => 'class',
                        'name' => 'SampleUpload',
                        'method' => 'myMethod',
                        'args' => [],
                    ]),
                ])
                ->withUploadedFiles([
                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
                ])
                ->withMethod('POST');
        });

        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
        $this->expectException(RequestException::class);
        jaxon()->processRequest();
    }

    /**
     * @throws RequestException
     * @throws SetupException
     */
    public function testPsrAjaxUpload()
    {
        _registerUpload();
        jaxon()->setAppOption('upload.enabled', true);
        jaxon()->setAppOption('upload.default.storage', 'uploads');
        jaxon()->setAppOptions([
            'adapter' => 'local',
            'dir' => __DIR__ . '/../upload/dst',
            // 'options' => [],
        ], 'storage.uploads');

        // Send a request to the registered class
        $xRequest = jaxon()->di()->g(ServerRequestCreator::class)
            ->fromGlobals()
            ->withParsedBody([
                'jxncall' => json_encode([
                    'type' => 'class',
                    'name' => 'SampleUpload',
                    'method' => 'myMethod',
                    'args' => [],
                ]),
            ])
            ->withUploadedFiles([
                'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
                    UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
            ])
            ->withMethod('POST');

        $xPsrConfigMiddleware = jaxon()->psr()->config(__DIR__ . '/../config/psr.php');
        $xPsrAjaxMiddleware = jaxon()->psr()->ajax();
        // PSR request handler that does nothing, useful to call the config middleware.
        $xEmptyRequestHandler = new class implements RequestHandlerInterface
        {
            private $xPsr17Factory;

            public function __construct()
            {
                $this->xPsr17Factory = new Psr17Factory();
            }

            public function handle(ServerRequestInterface $request): ResponseInterface
            {
                return $this->xPsr17Factory->createResponse();
            }
        };
        // Call the config middleware
        $xPsrConfigMiddleware->process($xRequest, $xEmptyRequestHandler);
        // Call the ajax middleware
        $xPsrResponse = $xPsrAjaxMiddleware->process($xRequest, $xEmptyRequestHandler);

        // Both responses must have the same content and content type
        $xJaxonResponse = jaxon()->getResponse();
        $this->assertEquals($xPsrResponse->getBody()->__toString(), $xJaxonResponse->getOutput());
        $this->assertEquals($xPsrResponse->getHeader('content-type')[0], $xJaxonResponse->getContentType());

        // Uploaded files
        $aFiles = jaxon()->upload()->files();
        $this->assertCount(1, $aFiles);
        $this->assertCount(1, $aFiles['image']);
        $this->assertCount(1, /** @scrutinizer ignore-type */ $aFiles['image']);
        $xFile = $aFiles['image'][0];
        $this->assertEquals('white', $xFile->name());
        $this->assertEquals($this->sNameWhite, $xFile->filename());
        $this->assertEquals('png', $xFile->type());
        $this->assertEquals('png', $xFile->extension());
    }
}

jaxon-php / jaxon-mono

ad/UploadHandlerTest.php$0 A last analyzed 2025-12-26 16:02 UTC

Complexity

Size/Duplication

Importance

Duplication Side-by-Side

Filter issues like

ad/UploadHandlerTest.php$0 A
last analyzed 2025-12-26 16:02 UTC
