UtilityTest.php$3 ➔ providerGetCookieDomain() - Code Metrics - Inspection of "Enable parallel php-cs-fixer #11599" - Ecodev/felix - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( e5e2c7...04c6d9 )

by Adrien

created 2025-07-08 09:59 UTC

UtilityTest.php$3 ➔ providerGetCookieDomain() A

↳ Parent: UtilityTest

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	8
rs	10
cc	1

<?php

declare(strict_types=1);

namespace EcodevTests\Felix;

use ArrayIterator;
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'"];
    }

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

    public static function providerGetCookieDomain(): 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'];
    }

    public function testConcat(): void
    {
        $iterable = new ArrayIterator([1 => 'one', 'a' => 'overridden', 'c' => 'c']);
        $actual = Utility::concat(['a' => 'a', 2 => 'two'], $iterable);

        self::assertSame([
            'a' => 'overridden',
            2 => 'two',
            1 => 'one',
            'c' => 'c',
        ], iterator_to_array($actual));
    }

    public function testFilterByKeys(): void
    {
        $things = new ArrayIterator(['a' => 'a', 'b' => 'b', 'c' => 'c']);

        self::assertSame(['a' => 'a'], iterator_to_array(Utility::filterByKeys($things, 'a')));
        self::assertSame(['a' => 'a', 'c' => 'c'], iterator_to_array(Utility::filterByKeys($things, 'c', 'a')));
        self::assertSame([], iterator_to_array(Utility::filterByKeys($things, 'unknown-key')));
        self::assertSame([], iterator_to_array(Utility::filterByKeys($things)));
    }
}


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

Ecodev / felix

Push — master ( e5e2c7...04c6d9 )

UtilityTest.php$3 ➔ providerGetCookieDomain() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like