FileFieldTest::testWeWillDefaultToPHPMaxUploadSizingForValidation() - Code Metrics - Inspection of "Fix clobbering of the upload size validation" - silverstripe/silverstripe-framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — 4.8 (#10059)

unknown
created 2021-08-18 05:07 UTC
testWeWillDefaultToPHPMaxUploadSizingForValidation() A

↳ Parent: FileFieldTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	11
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	6
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	11
rs	10
<?php

namespace SilverStripe\Forms\Tests;

use ReflectionMethod;
use SilverStripe\Assets\File;
use SilverStripe\Assets\Upload_Validator;
use SilverStripe\Dev\FunctionalTest;
use SilverStripe\Control\Controller;
use SilverStripe\Forms\FileField;
use SilverStripe\Forms\FieldList;
use SilverStripe\Forms\Form;
use SilverStripe\Forms\RequiredFields;

class FileFieldTest extends FunctionalTest
{
    /**
     * Test a valid upload of a required file in a form. Error is set to 0, as the upload went well
     *
     * @skipUpgrade
     */
    public function testUploadRequiredFile()
    {
        $form = new Form(
            Controller::curr(),
            'Form',
            new FieldList(
                $fileField = new FileField('cv', 'Upload your CV')
            ),
            new FieldList()
        );
        $fileFieldValue = [
            'name' => 'aCV.txt',
            'type' => 'application/octet-stream',
            'tmp_name' => '/private/var/tmp/phpzTQbqP',
            'error' => 0,
            'size' => 3471
        ];
        $fileField->setValue($fileFieldValue);

        $this->assertTrue($form->validationResult()->isValid());
    }

    /**
     * Test that FileField::validate() is run on FileFields with both single and multi-file syntax
     * By default FileField::validate() will return true early if the $_FILES super-global does not contain the
     * corresponding FileField::name. This early return means the files was not fully run through FileField::validate()
     * So for this test we create an invalid file upload on purpose and test that false was returned which means that
     * the file was run through FileField::validate() function
     */
    public function testMultiFileSyntaxUploadIsValidated()
    {
        $names = [
            'single_file_syntax',
            'multi_file_syntax_a[]',
            'multi_file_syntax_b[0]',
            'multi_file_syntax_c[key]'
        ];
        foreach ($names as $name) {
            $form = new Form(
                Controller::curr(),
                'Form',
                new FieldList($fileField = new FileField($name, 'My desc')),
                new FieldList()
            );
            $fileData = $this->createInvalidUploadedFileData($name, "FileFieldTest.txt");
            // FileFields with multi_file_syntax[] files will appear in the $_FILES super-global
            // with the [] brackets trimmed e.g. $_FILES[multi_file_syntax]
            $_FILES = [preg_replace('#\[(.*?)\]#', '', $name) => $fileData];
            $fileField->setValue($fileData);
            $validator = $form->getValidator();
            $isValid = $fileField->validate($validator);
            $this->assertFalse($isValid, "$name was run through the validate() function");
        }
    }

    protected function createInvalidUploadedFileData($name, $tmpFileName): array
    {
        $tmpFilePath = TEMP_PATH . DIRECTORY_SEPARATOR . $tmpFileName;

        // multi_file_syntax
        if (strpos($name, '[') !== false) {
            $key = 0;
            if (preg_match('#\[(.+?)\]#', $name, $m)) {
                $key = $m[1];
            }
            return [
                'name' => [$key => $tmpFileName],
                'type' => [$key => 'text/plaintext'],
                'size' => [$key => 0],
                'tmp_name' => [$key => $tmpFilePath],
                'error' => [$key => UPLOAD_ERR_NO_FILE],
            ];
        }
        // single_file_syntax
        return [
            'name' => $tmpFileName,
            'type' => 'text/plaintext',
            'size' => 0,
            'tmp_name' => $tmpFilePath,
            'error' => UPLOAD_ERR_NO_FILE,
        ];
    }

    /**
     * @skipUpgrade
     */
    public function testGetAcceptFileTypes()
    {
        $field = new FileField('image', 'Image');
        $field->setAllowedExtensions('jpg', 'png');
        $field->setAllowedExtensions(/** @scrutinizer ignore-type */ 'jpg', 'png');

        $method = new ReflectionMethod($field, 'getAcceptFileTypes');
        $method->setAccessible(true);
        $allowed = $method->invoke($field);

        $expected = ['.jpg', '.png', 'image/jpeg', 'image/png'];
        foreach ($expected as $extensionOrMime) {
            $this->assertContains($extensionOrMime, $allowed);
        }
    }

    /**
     * Test different scenarii for a failed upload : an error occured, no files where provided
     * @skipUpgrade
     */
    public function testUploadMissingRequiredFile()
    {
        $form = new Form(
            Controller::curr(),
            'Form',
            new FieldList(
                $fileField = new FileField('cv', 'Upload your CV')
            ),
            new FieldList(),
            new RequiredFields('cv')
        );
        // All fields are filled but for some reason an error occured when uploading the file => fails
        $fileFieldValue = [
            'name' => 'aCV.txt',
            'type' => 'application/octet-stream',
            'tmp_name' => '/private/var/tmp/phpzTQbqP',
            'error' => 1,
            'size' => 3471
        ];
        $fileField->setValue($fileFieldValue);

        $this->assertFalse(
            $form->validationResult()->isValid(),
            'An error occured when uploading a file, but the validator returned true'
        );

        // We pass an empty set of parameters for the uploaded file => fails
        $fileFieldValue = [];
        $fileField->setValue($fileFieldValue);

        $this->assertFalse(
            $form->validationResult()->isValid(),
            'An empty array was passed as parameter for an uploaded file, but the validator returned true'
        );

        // We pass an null value for the uploaded file => fails
        $fileFieldValue = null;
        $fileField->setValue($fileFieldValue);

        $this->assertFalse(
            $form->validationResult()->isValid(),
            'A null value was passed as parameter for an uploaded file, but the validator returned true'
        );
    }
    
    /**
     * Test the file size validation will use the PHP max size setting if 
     * no config for the Upload_Validator::default_max_file_size has been defined
     */
    public function testWeWillDefaultToPHPMaxUploadSizingForValidation()
    {
        // These 3 lines are how SilverStripe works out the default max upload size as defined in Upload_Validator
        $phpMaxUpload = File::ini2bytes(ini_get('upload_max_filesize'));
        $phpMaxUpload = /** @scrutinizer ignore-deprecated */ File::ini2bytes(ini_get('upload_max_filesize'));
        $maxPost = File::ini2bytes(ini_get('post_max_size'));
        $maxPost = /** @scrutinizer ignore-deprecated */ File::ini2bytes(ini_get('post_max_size'));
        $defaultUploadSize = min($phpMaxUpload, $maxPost);

        $fileField = new FileField('DemoField');


        $this->assertEquals($defaultUploadSize, $fieldField->getValidator()->getAllowedMaxFileSize('jpg'));

        $this->assertEquals($defaultUploadSize, $fieldField->getValidator()->getAllowedMaxFileSize('png'));
    }

    /**
     * Test the file size validation will use the default_max_file_size validation config if defined
     */
    public function testWeUseConfigForSizingIfDefined()
    {
        $configMaxFileSizes = [
            'jpg' => $jpgSize = '2m',
            '*' => $defaultSize = '1m',
        ];

        Upload_Validator::config()->set('default_max_file_size', $configMaxFileSizes);

        $fileField = new FileField('DemoField');


        $this->assertEquals(File::ini2bytes($jpgSize), $fieldField->getValidator()->getAllowedMaxFileSize('jpg'));
        $this->assertEquals(/** @scrutinizer ignore-deprecated */ File::ini2bytes($jpgSize), $fieldField->getValidator()->getAllowedMaxFileSize('jpg'));
        
        // PNG is not explicitly defined in config, so would fall back to *
        $this->assertEquals(File::ini2bytes($defaultSize), $fieldField->getValidator()->getAllowedMaxFileSize('png'));
        $this->assertEquals(/** @scrutinizer ignore-deprecated */ File::ini2bytes($defaultSize), $fieldField->getValidator()->getAllowedMaxFileSize('png'));
    }
}

silverstripe / silverstripe-framework

Pull Request — 4.8 (#10059)

testWeWillDefaultToPHPMaxUploadSizingForValidation() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
