alexdodonov / mezon-gui

Mezon/Gui/Tests/FieldsAlgorithmsUnitTest.php

<?php
namespace Mezon\Gui\Tests;

use PHPUnit\Framework\TestCase;
use Mezon\Gui\FieldsAlgorithms;
use Mezon\Conf\Conf;
use Mezon\Fs\InMemory;
define('ID_FIELD_NAME', 'id');
define('TITLE_FIELD_NAME', 'title');
define('USER_ID_FIELD_NAME', 'user_id');
define('FIELDS_FIELD_NAME', 'fields');
define('DISABLED_FIELD_NAME', 'disabled');
define('STRING_TYPE_NAME', 'string');
define('INTEGER_TYPE_NAME', 'integer');
define('DATE_TYPE_NAME', 'date');
define('EXTERNAL_TYPE_NAME', 'external');

/**
 *
 * @psalm-suppress PropertyNotSetInConstructor
 */
class FieldsAlgorithmsUnitTest extends TestCase
{

    /**
     *
     * {@inheritdoc}
     * @see TestCase::setUp()
     */
    protected function setUp(): void
    {
        Conf::setConfigValue('fs/layer', 'mock');
        InMemory::clearFs();
    }

    /**
     * Post test processing
     */
    public function tearDown(): void
    {
        unset($_GET[FIELDS_FIELD_NAME]);
    }

    /**
     * Method creates testing data
     *
     * @return array Testing data
     */
    protected function getFields1(): array
    {
        return json_decode(file_get_contents(__DIR__ . '/conf/setup.json'), true);
    }

    /**
     * Method creates testing data
     *
     * @return array Testing data
     */
    protected function getFields2(): array
    {
        return [
            ID_FIELD_NAME => [
                'type' => INTEGER_TYPE_NAME,
                DISABLED_FIELD_NAME => 1
            ],
            TITLE_FIELD_NAME => [
                'type' => STRING_TYPE_NAME,
                'required' => 1
            ]
        ];
    }

    /**
     * Testing invalid construction
     */
    public function testConstructor(): void
    {
        // setup and test body
        $fieldsAlgorithms = new FieldsAlgorithms($this->getFields1(), 'entity');

        // assertions
        $this->assertEquals('entity', $fieldsAlgorithms->getEntityName(), 'EntityName was not set');
        $this->assertTrue($fieldsAlgorithms->hasCustomFields(), 'Data was not loaded');
    }

    /**
     * Testing hasCustomFields
     */
    public function testHasNotCustomFields(): void
    {
        // setup and test body
        $fieldsAlgorithms = new FieldsAlgorithms($this->getFields2(), 'entity');

        // assertions
        $_GET[FIELDS_FIELD_NAME] = TITLE_FIELD_NAME;
        $this->assertFalse($fieldsAlgorithms->hasCustomFields(), 'Custom fields are not in the model');
    }

    /**
     * Testing hasCustomFields
     */
    public function testHasCustomFields(): void
    {
        // setup and test body
        $fieldsAlgorithms = new FieldsAlgorithms($this->getFields1(), 'entity');

        // assertions
        $this->assertTrue($fieldsAlgorithms->hasCustomFields(), 'Custom fields are in the model');
    }

    /**
     * Testing getTypedValue
     */
    public function testGetTypedValue(): void
    {
        // setup and test body
        $fieldsAlgorithms = new FieldsAlgorithms($this->getFields1(), 'entity');

        // assertions int
        $this->assertEquals(
            1,
            $fieldsAlgorithms->getTypedValue(INTEGER_TYPE_NAME, '1'),
            'Type was not casted properly for integer');
        $this->assertTrue(
            is_int($fieldsAlgorithms->getTypedValue(INTEGER_TYPE_NAME, '1')),
            'Type was not casted properly for integer');

        // assertions string
        $this->assertEquals(
            '1',
            $fieldsAlgorithms->getTypedValue(STRING_TYPE_NAME, '1'),
            'Type was not casted properly for string');
        $this->assertTrue(
            is_string($fieldsAlgorithms->getTypedValue(STRING_TYPE_NAME, '1')),
            'Return type is not correct');
        $this->assertEquals(
            '&amp;',
            $fieldsAlgorithms->getTypedValue(STRING_TYPE_NAME, '&'),
            'Type was not casted properly for string');
        $this->assertEquals(
            '&quot;&quot;',
            $fieldsAlgorithms->getTypedValue(STRING_TYPE_NAME, '""'),
            'Default brunch for string is not working');

        // assertions date
        $this->assertEquals(
            '2019-01-01',
            $fieldsAlgorithms->getTypedValue(DATE_TYPE_NAME, '2019-01-01'),
            'Type was not casted properly for date');
        $this->assertEquals(
            '',
            $fieldsAlgorithms->getTypedValue(DATE_TYPE_NAME, '""'),
            'Default date for string is not working');

        // assertions file
        $this->assertContains('value', $fieldsAlgorithms->getTypedValue('file', [
            'value'
        ], false));
        $path = $fieldsAlgorithms->getTypedValue('file', [
            'name' => 'test.txt',
            'file' => '1234'
        ], true);
        $this->assertEquals(base64_decode('1234'), InMemory::fileGetContents($path));

        // assertions external
        $typedValue = $fieldsAlgorithms->getTypedValue(EXTERNAL_TYPE_NAME, [
            '1',
            '2'
        ]);
        $this->assertContains(1, $typedValue);
        $this->assertContains(2, $typedValue);
        $this->assertCount(2, $typedValue);

It seems like $typedValue can also be of type integer and string; however, parameter $haystack of PHPUnit\Framework\Assert::assertCount() does only seem to accept Countable|iterable, maybe add an additional type check?

        // assertion unexisting
        $this->expectException(\Exception::class);
        $fieldsAlgorithms->getTypedValue('unexisting', '1');
    }

    /**
     * Test validateFieldExistance method
     */
    public function testValidateFieldExistance(): void
    {
        // setup and test body
        $fieldsAlgorithms = new FieldsAlgorithms($this->getFields1(), 'entity');

        // test body and assertions
        $this->expectException(\Exception::class);
        $fieldsAlgorithms->validateFieldExistance('unexisting-field');

        $this->expectException(\Exception::class);
        $fieldsAlgorithms->validateFieldExistance('id');
    }

    /**
     * Test getSecureValue method
     */
    public function testGetSecureValue(): void
    {
        // setup and test body
        $fieldsAlgorithms = new FieldsAlgorithms($this->getFields1(), 'entity');

        // test body and assertions
        $id = $fieldsAlgorithms->getSecureValue('id', '1');

        // assertions
        $this->assertIsInt($id, 'Invalid secure processing for integer value');
        $this->assertEquals(1, $id, 'Data loss for integer value');
    }

    /**
     * Test getSecureValues method
     */
    public function testGetSecureValues(): void
    {
        // setup and test body
        $fieldsAlgorithms = new FieldsAlgorithms($this->getFields1(), 'entity');

        // test body and assertions
        $id = $fieldsAlgorithms->getSecureValues('id', [
            '1',
            '2&'
        ]);

        // assertions
        $this->assertIsInt($id[0], 'Invalid secure processing for integer values');
        $this->assertIsInt($id[1], 'Invalid secure processing for integer values');

        $this->assertEquals(1, $id[0], 'Data loss for integer values');
        $this->assertEquals(2, $id[1], 'Data loss for integer values');
    }

    /**
     * Test getValuesForPrefix method
     */
    public function testGetValuesForPrefix(): void
    {
        // setup and test body
        $fieldsAlgorithms = new FieldsAlgorithms($this->getFields1(), 'entity');
        $_POST['prefix-id'] = '1';
        $_POST['prefix-title'] = 'some string';

        // test body and assertions
        $result = $fieldsAlgorithms->getValuesForPrefix('prefix-');

        // assertions
        $this->assertIsInt($result['id'], 'Invalid secure processing for integer prefix');
        $this->assertIsString($result[TITLE_FIELD_NAME], 'Invalid secure processing for string prefix');

        $this->assertEquals(1, $result['id'], 'Data loss for integer preix');
        $this->assertEquals('some string', $result[TITLE_FIELD_NAME], 'Data loss for string preix');
    }

    /**
     * Testing 'removeField' method
     */
    public function testRemoveField(): void
    {
        // setup
        $fieldsAlgorithms = new FieldsAlgorithms($this->getFields1(), 'entity');

        // test body
        $fieldsAlgorithms->removeField('extensions');

        // assertions
        $this->assertFalse($fieldsAlgorithms->hasCustomFields(), 'Field "extensions" was not removed');
    }

    /**
     * Testing 'fetchCustomField' method for unexisting field
     */
    public function testFetchCustomFieldUnexistingField(): void
    {
        // setup
        $fieldsAlgorithms = new FieldsAlgorithms($this->getFields1(), 'entity');
        $record = [];

        // test body
        $result = $fieldsAlgorithms->fetchCustomField($record, 'unexisting');

        // assertions
        $this->assertEquals(0, count($result), 'Something was returned, but should not');
    }

    /**
     * Testing 'fetchCustomField' method
     */
    public function testFetchCustomField(): void
    {
        // setup
        $fieldsAlgorithms = new FieldsAlgorithms($this->getFields1(), 'entity');
        $record = [];
        $_POST['entity' . '-balance'] = '11';

        // test body
        $result = $fieldsAlgorithms->fetchCustomField($record, 'extensions');

        // assertions
        $this->assertEquals(11, $result['balance'], 'Invalid field value');
    }

    /**
     * Testing 'fetchField' method
     */
    public function testFetchField(): void
    {
        // setup
        $fieldsAlgorithms = new FieldsAlgorithms($this->getFields1(), 'entity');
        $record = [];
        $_POST['entity' . '-id'] = '11';
        $_FILES['entity' . '-avatar'] = [
            'name' => 'test.dat',
            'file' => 'content'
        ];
        $_POST['entity' . '-balance'] = '33';

        // test body
        $fieldsAlgorithms->fetchField($record, 'id');
        $fieldsAlgorithms->fetchField($record, 'avatar');
        $fieldsAlgorithms->fetchField($record, 'extensions');

        // assertions
        $this->assertEquals(11, $record['id'], 'id was not fetched');
        $this->assertEquals(base64_decode('content'), InMemory::fileGetContents($record['avatar']));
        $this->assertEquals(33, $record['balance'], 'balance was not fetched');
    }

    /**
     * Testing 'getObject' method
     */
    public function testGetObject(): void
    {
        // setup
        $fieldsAlgorithms = new FieldsAlgorithms($this->getFields1(), 'entity');

        // test body
        $object = $fieldsAlgorithms->getObject('title');

        // assertions
        $this->assertInstanceOf(\Mezon\Gui\Field\InputText::class, $object);
    }

    /**
     * Testing 'getFieldsNames' method
     */
    public function testGetFieldsNames(): void
    {
        // setup
        $fieldsAlgorithms = new FieldsAlgorithms($this->getFields1(), 'entity');

        // test body
        $fields = $fieldsAlgorithms->getFieldsNames();

        // assertions
        $this->assertContains('id', $fields);
        $this->assertContains('title', $fields);
        $this->assertContains('user_id', $fields);
        $this->assertContains('label', $fields);
        $this->assertContains('description', $fields);
        $this->assertContains('created', $fields);
        $this->assertContains('avatar', $fields);
        $this->assertContains('parts', $fields);
        $this->assertContains('extensions', $fields);
    }

    /**
     * Testing field compilation
     */
    public function testGetCompiledField(): void
    {
        // setup
        $fieldsAlgorithms = new FieldsAlgorithms($this->getFields1(), 'entity');

        // test body
        $inputField = $fieldsAlgorithms->getCompiledField('title');
        $textareaField = $fieldsAlgorithms->getCompiledField('description');

        // assertions
        $this->assertStringContainsString('<input ', $inputField);
        $this->assertStringContainsString('<textarea ', $textareaField);
    }
}