Doctrine\Tests\DBAL\Types\BinaryTest

Complexity

Total Complexity

11

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	testReturnsName()	0	3	1
A	testReturnsBindingType()	0	3	1
A	setUp()	0	4	1
A	testReturnsSQLDeclaration()	0	4	1
A	getBinaryString()	0	3	1
A	testBinaryResourceConvertsToPHPValue()	0	6	1
A	testThrowsConversionExceptionOnInvalidDatabaseValue()	0	5	1
A	definitionProvider()	0	17	1
A	testBinaryNullConvertsToPHPValue()	0	3	1
A	getInvalidDatabaseValues()	0	11	1
A	testBinaryStringConvertsToPHPValue()	0	6	1

<?php

declare(strict_types=1);

namespace Doctrine\Tests\DBAL\Types;

use Doctrine\DBAL\ParameterType;
use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Types\BinaryType;
use Doctrine\DBAL\Types\ConversionException;
use Doctrine\DBAL\Types\Type;
use Doctrine\DBAL\Types\Types;
use Doctrine\Tests\DbalTestCase;
use PHPUnit\Framework\MockObject\MockObject;
use function array_map;
use function base64_encode;
use function fopen;
use function implode;
use function range;

class BinaryTest extends DbalTestCase
{
    /** @var AbstractPlatform|MockObject */
    protected $platform;

    /** @var BinaryType */
    protected $type;

    /**
     * {@inheritdoc}
     */
    protected function setUp() : void
    {
        $this->platform = $this->createMock(AbstractPlatform::class);
        $this->type     = Type::getType('binary');
    }

    public function testReturnsBindingType() : void
    {
        self::assertSame(ParameterType::BINARY, $this->type->getBindingType());
    }

    public function testReturnsName() : void
    {
        self::assertSame(Types::BINARY, $this->type->getName());
    }

    /**
     * @param mixed[][] $definition
     *
     * @dataProvider definitionProvider()
     */
    public function testReturnsSQLDeclaration(array $definition, string $expectedDeclaration) : void
    {
        $platform = $this->getMockForAbstractClass(AbstractPlatform::class);
        self::assertSame($expectedDeclaration, $this->type->getSQLDeclaration($definition, $platform));
    }

    /**
     * @return mixed[][]
     */
    public static function definitionProvider() : iterable
    {
        return [
            'fixed-unspecified-length' => [
                ['fixed' => true],
                'BINARY',
            ],
            'fixed-specified-length' => [
                [
                    'fixed' => true,
                    'length' => 20,
                ],
                'BINARY(20)',
            ],
            'variable-length' => [
                ['length' => 20],
                'VARBINARY(20)',
            ],
        ];
    }

    public function testBinaryNullConvertsToPHPValue() : void
    {
        self::assertNull($this->type->convertToPHPValue(null, $this->platform));

Are you sure the usage of $this->type->convertToPHPValue(null, $this->platform) targeting Doctrine\DBAL\Types\BinaryType::convertToPHPValue() seems to always return null.

    }

    public function testBinaryStringConvertsToPHPValue() : void
    {
        $databaseValue = $this->getBinaryString();
        $phpValue      = $this->type->convertToPHPValue($databaseValue, $this->platform);

        self::assertSame($databaseValue, $phpValue);
    }

    public function testBinaryResourceConvertsToPHPValue() : void
    {
        $databaseValue = fopen('data://text/plain;base64,' . base64_encode('binary string'), 'r');
        $phpValue      = $this->type->convertToPHPValue($databaseValue, $this->platform);

        self::assertSame('binary string', $phpValue);
    }

    /**
     * Creates a binary string containing all possible byte values.
     */
    private function getBinaryString() : string
    {
        return implode(array_map('chr', range(0, 255)));
    }

    /**
     * @param mixed $value
     *
     * @dataProvider getInvalidDatabaseValues
     */
    public function testThrowsConversionExceptionOnInvalidDatabaseValue($value) : void
    {
        $this->expectException(ConversionException::class);

        $this->type->convertToPHPValue($value, $this->platform);
    }

    /**
     * @return mixed[][]
     */
    public static function getInvalidDatabaseValues() : iterable
    {
        return [
            [false],
            [true],
            [0],
            [1],
            [-1],
            [0.0],
            [1.1],
            [-1.1],
        ];
    }
}