UtilityTest::testQuoteArray()

Passed

Push — master ( 79fe9e...36c6ba )

by Adrien

created 2024-01-29 09:09 UTC

↳ Parent: UtilityTest

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	1
c	1
b	0
f	0
dl	0
loc	3
nc	1
nop	2

<?php

declare(strict_types=1);

namespace EcodevTests\Felix;

use Ecodev\Felix\Model\Model;
use Ecodev\Felix\Utility;
use EcodevTests\Felix\Blog\Model\User;
use EcodevTests\Felix\Traits\TestWithEntityManager;
use Exception;
use GraphQL\Doctrine\Definition\EntityID;
use PHPUnit\Framework\TestCase;
use stdClass;
use Throwable;

final class UtilityTest extends TestCase
{
    use TestWithEntityManager;

    public function testGetShortClassName(): void
    {
        self::assertSame('User', Utility::getShortClassName(new User()));
        self::assertSame('User', Utility::getShortClassName(User::class));
    }

    public function testEntityIdToModel(): void
    {
        $fakeEntity = new stdClass();
        $input = [
            3 => new stdClass(),
            4 => 1,
            'model' => new User(),
            'entity' => new class($fakeEntity) extends EntityID {
                public function __construct(private readonly object $fakeEntity)
                {
                }

                public function getEntity(): object
                {
                    return $this->fakeEntity;
                }
            },
        ];

        $actual = Utility::entityIdToModel($input);

        $expected = $input;
        $expected['entity'] = $fakeEntity;

        self::assertSame($expected, $actual, 'keys and non model values should be preserved');
        self::assertNull(Utility::entityIdToModel(null));
        self::assertSame([], Utility::entityIdToModel([]));
    }

    public function testModelToId(): void
    {
        $input = [
            3 => new stdClass(),
            'model' => new class() implements Model {
                public function getId(): ?int
                {
                    return 123456;
                }
            },
            4 => 1,
            'entityId' => new EntityID(_em(), User::class, '456'),
        ];

        $actual = Utility::modelToId($input);

        $expected = $input;
        $expected['model'] = 123456;
        $expected['entityId'] = '456';

        self::assertSame($expected, $actual, 'models must be replaced by their ids, other values should be preserved');
    }

    private function createArray(): array
    {
        $object1 = new class() {
        };

        $object2 = new class() {
        };

        return [
            $object1,
            3,
            $object2,
            3,
            $object1,
            2,
            '2',
        ];
    }

    public function testUnique(): void
    {
        $array = $this->createArray();
        $actual = Utility::unique($array);

        $expected = [
            $array[0],
            $array[1],
            $array[2],
            $array[5],
            $array[6],
        ];

        self::assertSame($expected, $actual);
    }

    /**
     * @dataProvider providerNativeUniqueWillThrowWithOurTestObject
     */
    public function testNativeUniqueWillThrowWithOurTestObject(int $flag): void
    {
        set_error_handler(
            function (int $errno, string $message): void {
                restore_error_handler();

                throw new Exception($message);
            }
        );

        try {
            $foo = array_unique($this->createArray(), $flag);

        } catch (Throwable $e) {
            self::assertStringStartsWith('Object of class class@anonymous could not be converted to ', $e->getMessage());
        }
    }

    public static function providerNativeUniqueWillThrowWithOurTestObject(): iterable
    {
        yield [SORT_REGULAR];
        yield [SORT_NUMERIC];
        yield [SORT_STRING];
        yield [SORT_LOCALE_STRING];
    }

    /**
     * @dataProvider providerQuoteArray
     */
    public function testQuoteArray(array $input, string $expected): void
    {
        self::assertSame($expected, Utility::quoteArray($input));
    }

    public static function providerQuoteArray(): iterable
    {
        yield [[1, 2], "'1', '2'"];
        yield [['foo bar', 'baz'], "'foo bar', 'baz'"];
        yield [[], ''];
        yield [[''], "''"];
        yield [[false], ''];
        yield [[null], ''];
        yield [[0], "'0'"];
        yield [[true], "'1'"];
        yield [[1.23], "'1.23'"];
    }

    public function getCookieDomainProvider(): iterable
    {
        yield ['', null];
        yield ['localhost', null];
        yield ['example.com', '.example.com'];
        yield ['www.example.com', '.example.com'];
        yield ['example.com:123', '.example.com'];
        yield ['www.example.com:123', '.example.com'];
    }

    /**
     * @dataProvider getCookieDomainProvider
     */
    public function testGetCookieDomain(string $input, ?string $expected): void
    {
        $actual = Utility::getCookieDomain($input);
        self::assertSame($expected, $actual);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace EcodevTests\Felix;
6
7			use Ecodev\Felix\Model\Model;
8			use Ecodev\Felix\Utility;
9			use EcodevTests\Felix\Blog\Model\User;
10			use EcodevTests\Felix\Traits\TestWithEntityManager;
11			use Exception;
12			use GraphQL\Doctrine\Definition\EntityID;
13			use PHPUnit\Framework\TestCase;
14			use stdClass;
15			use Throwable;
16
17			final class UtilityTest extends TestCase
18			{
19			use TestWithEntityManager;
20
21			public function testGetShortClassName(): void
22			{
23			self::assertSame('User', Utility::getShortClassName(new User()));
24			self::assertSame('User', Utility::getShortClassName(User::class));
25			}
26
27			public function testEntityIdToModel(): void
28			{
29			$fakeEntity = new stdClass();
30			$input = [
31			3 => new stdClass(),
32			4 => 1,
33			'model' => new User(),
34			'entity' => new class($fakeEntity) extends EntityID {
35			public function __construct(private readonly object $fakeEntity)
36			{
37			}
38
39			public function getEntity(): object
40			{
41			return $this->fakeEntity;
42			}
43			},
44			];
45
46			$actual = Utility::entityIdToModel($input);
47
48			$expected = $input;
49			$expected['entity'] = $fakeEntity;
50
51			self::assertSame($expected, $actual, 'keys and non model values should be preserved');
52			self::assertNull(Utility::entityIdToModel(null));
53			self::assertSame([], Utility::entityIdToModel([]));
54			}
55
56			public function testModelToId(): void
57			{
58			$input = [
59			3 => new stdClass(),
60			'model' => new class() implements Model {
61			public function getId(): ?int
62			{
63			return 123456;
64			}
65			},
66			4 => 1,
67			'entityId' => new EntityID(_em(), User::class, '456'),
68			];
69
70			$actual = Utility::modelToId($input);
71
72			$expected = $input;
73			$expected['model'] = 123456;
74			$expected['entityId'] = '456';
75
76			self::assertSame($expected, $actual, 'models must be replaced by their ids, other values should be preserved');
77			}
78
79			private function createArray(): array
80			{
81			$object1 = new class() {
82			};
83
84			$object2 = new class() {
85			};
86
87			return [
88			$object1,
89			3,
90			$object2,
91			3,
92			$object1,
93			2,
94			'2',
95			];
96			}
97
98			public function testUnique(): void
99			{
100			$array = $this->createArray();
101			$actual = Utility::unique($array);
102
103			$expected = [
104			$array[0],
105			$array[1],
106			$array[2],
107			$array[5],
108			$array[6],
109			];
110
111			self::assertSame($expected, $actual);
112			}
113
114			/**
115			* @dataProvider providerNativeUniqueWillThrowWithOurTestObject
116			*/
117			public function testNativeUniqueWillThrowWithOurTestObject(int $flag): void
118			{
119			set_error_handler(
120			function (int $errno, string $message): void {
121			restore_error_handler();
122
123			throw new Exception($message);
124			}
125			);
126
127			try {
128			$foo = array_unique($this->createArray(), $flag);
			0 ignored issues – show Unused Code introduced 2022-07-20 09:17 UTC by Report Bug Copy Issue Report The assignment to `$foo` is dead and can be removed. Loading history...
129			} catch (Throwable $e) {
130			self::assertStringStartsWith('Object of class class@anonymous could not be converted to ', $e->getMessage());
131			}
132			}
133
134			public static function providerNativeUniqueWillThrowWithOurTestObject(): iterable
135			{
136			yield [SORT_REGULAR];
137			yield [SORT_NUMERIC];
138			yield [SORT_STRING];
139			yield [SORT_LOCALE_STRING];
140			}
141
142			/**
143			* @dataProvider providerQuoteArray
144			*/
145			public function testQuoteArray(array $input, string $expected): void
146			{
147			self::assertSame($expected, Utility::quoteArray($input));
148			}
149
150			public static function providerQuoteArray(): iterable
151			{
152			yield [[1, 2], "'1', '2'"];
153			yield [['foo bar', 'baz'], "'foo bar', 'baz'"];
154			yield [[], ''];
155			yield [[''], "''"];
156			yield [[false], ''];
157			yield [[null], ''];
158			yield [[0], "'0'"];
159			yield [[true], "'1'"];
160			yield [[1.23], "'1.23'"];
161			}
162
163			public function getCookieDomainProvider(): iterable
164			{
165			yield ['', null];
166			yield ['localhost', null];
167			yield ['example.com', '.example.com'];
168			yield ['www.example.com', '.example.com'];
169			yield ['example.com:123', '.example.com'];
170			yield ['www.example.com:123', '.example.com'];
171			}
172
173			/**
174			* @dataProvider getCookieDomainProvider
175			*/
176			public function testGetCookieDomain(string $input, ?string $expected): void
177			{
178			$actual = Utility::getCookieDomain($input);
179			self::assertSame($expected, $actual);
180			}
181			}
182

Ecodev / felix

Push — master ( 79fe9e...36c6ba )

UtilityTest::testQuoteArray()

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like