AcceptHeaderItemTest::emptyItemProvider() - Code Metrics - Inspection of "Merge spiral/http component" - spiral/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 9013bb...125cf1 )

by Kirill

created 2020-08-19 23:24 UTC

AcceptHeaderItemTest::emptyItemProvider() A

↳ Parent: AcceptHeaderItemTest

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	6
c	1
b	0
f	0
dl	0
loc	8
rs	10
cc	2
nc	2
nop	0

<?php

/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Pavel Z
 */

declare(strict_types=1);

namespace Spiral\Tests\Http;

use PHPUnit\Framework\TestCase;
use Spiral\Http\Header\AcceptHeader;
use Spiral\Http\Header\AcceptHeaderItem;

class AcceptHeaderItemTest extends TestCase
{
    /**
     * @dataProvider emptyItemProvider
     * @param AcceptHeaderItem $item
     */
    public function testEmptyItem(AcceptHeaderItem $item): void
    {
        $this->assertEmpty($item->getValue());
        $this->assertEquals('', (string)$item);
    }

    /**
     * @return iterable
     */
    public function emptyItemProvider(): iterable
    {
        $values = ['', ' '];
        foreach ($values as $value) {
            yield from [
                [AcceptHeaderItem::fromString($value)],
                [new AcceptHeaderItem($value)],
                [(new AcceptHeaderItem('*/*'))->withValue($value)],
            ];
        }
    }

    /**
     * @dataProvider valueProvider
     * @param string $value
     */
    public function testValue(string $value): void
    {
        $item = AcceptHeaderItem::fromString($value);
        $this->assertEquals($value, $item->getValue());

        $acceptHeader = new AcceptHeader([$item]);
        $this->assertCount(1, $acceptHeader->getAll());

        $item = AcceptHeaderItem::fromString(" $value ");
        $this->assertEquals($value, $item->getValue());

        $acceptHeader = new AcceptHeader([$item]);
        $this->assertCount(1, $acceptHeader->getAll());
        $this->assertEquals($value, (string)$acceptHeader->getAll()[0]);
    }

    /**
     * @return iterable
     */
    public function valueProvider(): iterable
    {
        return [
            ['text/html'],
            ['text/*'],
            ['*/*'],
            ['*'],
        ];
    }

    /**
     * @dataProvider qualityBoundariesProvider
     * @param float            $quality
     * @param AcceptHeaderItem $item
     */
    public function testItemQualityBoundaries(float $quality, AcceptHeaderItem $item): void
    {
        if ($quality > 1) {
            $this->assertSame(1.0, $item->getQuality());
        }

        if ($quality < 0) {
            $this->assertSame(0.0, $item->getQuality());
        }

        $this->assertGreaterThanOrEqual(0, $item->getQuality());
        $this->assertLessThanOrEqual(1, $item->getQuality());
    }

    /**
     * @return iterable
     */
    public function qualityBoundariesProvider(): iterable
    {
        $qualities = [-1, 0, 0.5, 1, 2];
        foreach ($qualities as $quality) {
            yield from [
                [$quality, AcceptHeaderItem::fromString("*;q=$quality")],
                [$quality, AcceptHeaderItem::fromString("*;Q=$quality")],
                [$quality, new AcceptHeaderItem('*', $quality)],
                [$quality, (new AcceptHeaderItem('*'))->withQuality($quality)],
            ];
        }
    }

    /**
     * @dataProvider paramsProvider
     * @param array            $params
     * @param AcceptHeaderItem $item
     */
    public function testParams(array $params, AcceptHeaderItem $item): void
    {
        $this->assertSame($params, $item->getParams());
    }

    /**
     * @return iterable
     */
    public function paramsProvider(): iterable
    {
        $set = [
            [
                'expected' => [],
                'passed'   => []
            ],
            [
                'expected' => ['a' => 'b'],
                'passed'   => ['a' => 'b']
            ],
            [
                'expected' => [],
                'passed'   => ['c', '' => 'd', false, true, null, 1, '1' => 'e']
            ]
        ];

        foreach ($set as $params) {
            $formattedParams = [];
            foreach ($params['passed'] as $k => $v) {
                $formattedParams[] = "$k=$v";
            }

            $formattedParams = implode(';', $formattedParams);

            yield from [
                [$params['expected'], AcceptHeaderItem::fromString("*;$formattedParams")],
                [$params['expected'], AcceptHeaderItem::fromString("*;$formattedParams")],
                [$params['expected'], new AcceptHeaderItem('*', 0, $params['passed'])],
                [$params['expected'], (new AcceptHeaderItem('*'))->withParams($params['passed'])],
            ];
        }

        $invalid = ['c', '' => 'd', false, true, null, [], new \stdClass(), 1, '1' => 'e'];
        yield from [
            [[], new AcceptHeaderItem('*', 0, $invalid)],
            [[], (new AcceptHeaderItem('*'))->withParams($invalid)]
        ];
    }

    /**
     * @dataProvider itemProvider
     * @param string           $expected
     * @param AcceptHeaderItem $item
     */
    public function testItem(string $expected, AcceptHeaderItem $item): void
    {
        $this->assertSame($expected, (string)$item);
    }

    /**
     * @return iterable
     */
    public function itemProvider(): iterable
    {
        $value = '*/*';

        yield from [
            [$value, new AcceptHeaderItem($value)],
            [$value, AcceptHeaderItem::fromString($value)],
            [$value, (new AcceptHeaderItem(''))->withValue($value)],
        ];

        $quality = 0.5;
        yield from [
            ["$value; q=$quality", new AcceptHeaderItem($value, $quality)],
            ["$value; q=$quality", AcceptHeaderItem::fromString("$value;Q=$quality")],
            ["$value; q=$quality", (new AcceptHeaderItem(''))->withValue($value)->withQuality($quality)],
        ];

        $params = ['a' => 'b', 'c' => 'd'];
        yield from [
            ["$value; q=$quality; a=b; c=d", new AcceptHeaderItem($value, $quality, $params)],
            ["$value; q=$quality; a=b; c=d", AcceptHeaderItem::fromString("$value;Q=$quality;a=b ; c = d")],
            [
                "$value; q=$quality; a=b; c=d",
                (new AcceptHeaderItem(''))->withValue($value)->withQuality($quality)->withParams($params)
            ],
        ];
    }
}


1			<?php
2
3			/**
4			* Spiral Framework.
5			*
6			* @license MIT
7			* @author Pavel Z
8			*/
9
10			declare(strict_types=1);
11
12			namespace Spiral\Tests\Http;
13
14			use PHPUnit\Framework\TestCase;
15			use Spiral\Http\Header\AcceptHeader;
16			use Spiral\Http\Header\AcceptHeaderItem;
17
18			class AcceptHeaderItemTest extends TestCase
19			{
20			/**
21			* @dataProvider emptyItemProvider
22			* @param AcceptHeaderItem $item
23			*/
24			public function testEmptyItem(AcceptHeaderItem $item): void
25			{
26			$this->assertEmpty($item->getValue());
27			$this->assertEquals('', (string)$item);
28			}
29
30			/**
31			* @return iterable
32			*/
33			public function emptyItemProvider(): iterable
34			{
35			$values = ['', ' '];
36			foreach ($values as $value) {
37			yield from [
38			[AcceptHeaderItem::fromString($value)],
39			[new AcceptHeaderItem($value)],
40			[(new AcceptHeaderItem('/'))->withValue($value)],
41			];
42			}
43			}
44
45			/**
46			* @dataProvider valueProvider
47			* @param string $value
48			*/
49			public function testValue(string $value): void
50			{
51			$item = AcceptHeaderItem::fromString($value);
52			$this->assertEquals($value, $item->getValue());
53
54			$acceptHeader = new AcceptHeader([$item]);
55			$this->assertCount(1, $acceptHeader->getAll());
56
57			$item = AcceptHeaderItem::fromString(" $value ");
58			$this->assertEquals($value, $item->getValue());
59
60			$acceptHeader = new AcceptHeader([$item]);
61			$this->assertCount(1, $acceptHeader->getAll());
62			$this->assertEquals($value, (string)$acceptHeader->getAll()[0]);
63			}
64
65			/**
66			* @return iterable
67			*/
68			public function valueProvider(): iterable
69			{
70			return [
71			['text/html'],
72			['text/*'],
73			['/'],
74			['*'],
75			];
76			}
77
78			/**
79			* @dataProvider qualityBoundariesProvider
80			* @param float $quality
81			* @param AcceptHeaderItem $item
82			*/
83			public function testItemQualityBoundaries(float $quality, AcceptHeaderItem $item): void
84			{
85			if ($quality > 1) {
86			$this->assertSame(1.0, $item->getQuality());
87			}
88
89			if ($quality < 0) {
90			$this->assertSame(0.0, $item->getQuality());
91			}
92
93			$this->assertGreaterThanOrEqual(0, $item->getQuality());
94			$this->assertLessThanOrEqual(1, $item->getQuality());
95			}
96
97			/**
98			* @return iterable
99			*/
100			public function qualityBoundariesProvider(): iterable
101			{
102			$qualities = [-1, 0, 0.5, 1, 2];
103			foreach ($qualities as $quality) {
104			yield from [
105			[$quality, AcceptHeaderItem::fromString("*;q=$quality")],
106			[$quality, AcceptHeaderItem::fromString("*;Q=$quality")],
107			[$quality, new AcceptHeaderItem('*', $quality)],
108			[$quality, (new AcceptHeaderItem('*'))->withQuality($quality)],
109			];
110			}
111			}
112
113			/**
114			* @dataProvider paramsProvider
115			* @param array $params
116			* @param AcceptHeaderItem $item
117			*/
118			public function testParams(array $params, AcceptHeaderItem $item): void
119			{
120			$this->assertSame($params, $item->getParams());
121			}
122
123			/**
124			* @return iterable
125			*/
126			public function paramsProvider(): iterable
127			{
128			$set = [
129			[
130			'expected' => [],
131			'passed' => []
132			],
133			[
134			'expected' => ['a' => 'b'],
135			'passed' => ['a' => 'b']
136			],
137			[
138			'expected' => [],
139			'passed' => ['c', '' => 'd', false, true, null, 1, '1' => 'e']
140			]
141			];
142
143			foreach ($set as $params) {
144			$formattedParams = [];
145			foreach ($params['passed'] as $k => $v) {
146			$formattedParams[] = "$k=$v";
147			}
148
149			$formattedParams = implode(';', $formattedParams);
150
151			yield from [
152			[$params['expected'], AcceptHeaderItem::fromString("*;$formattedParams")],
153			[$params['expected'], AcceptHeaderItem::fromString("*;$formattedParams")],
154			[$params['expected'], new AcceptHeaderItem('*', 0, $params['passed'])],
155			[$params['expected'], (new AcceptHeaderItem('*'))->withParams($params['passed'])],
156			];
157			}
158
159			$invalid = ['c', '' => 'd', false, true, null, [], new \stdClass(), 1, '1' => 'e'];
160			yield from [
161			[[], new AcceptHeaderItem('*', 0, $invalid)],
162			[[], (new AcceptHeaderItem('*'))->withParams($invalid)]
163			];
164			}
165
166			/**
167			* @dataProvider itemProvider
168			* @param string $expected
169			* @param AcceptHeaderItem $item
170			*/
171			public function testItem(string $expected, AcceptHeaderItem $item): void
172			{
173			$this->assertSame($expected, (string)$item);
174			}
175
176			/**
177			* @return iterable
178			*/
179			public function itemProvider(): iterable
180			{
181			$value = '/';
182
183			yield from [
184			[$value, new AcceptHeaderItem($value)],
185			[$value, AcceptHeaderItem::fromString($value)],
186			[$value, (new AcceptHeaderItem(''))->withValue($value)],
187			];
188
189			$quality = 0.5;
190			yield from [
191			["$value; q=$quality", new AcceptHeaderItem($value, $quality)],
192			["$value; q=$quality", AcceptHeaderItem::fromString("$value;Q=$quality")],
193			["$value; q=$quality", (new AcceptHeaderItem(''))->withValue($value)->withQuality($quality)],
194			];
195
196			$params = ['a' => 'b', 'c' => 'd'];
197			yield from [
198			["$value; q=$quality; a=b; c=d", new AcceptHeaderItem($value, $quality, $params)],
199			["$value; q=$quality; a=b; c=d", AcceptHeaderItem::fromString("$value;Q=$quality;a=b ; c = d")],
200			[
201			"$value; q=$quality; a=b; c=d",
202			(new AcceptHeaderItem(''))->withValue($value)->withQuality($quality)->withParams($params)
203			],
204			];
205			}
206			}
207

spiral / framework

Push — master ( 9013bb...125cf1 )

AcceptHeaderItemTest::emptyItemProvider() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like