testGetWithInvalidDefinition()   A
last analyzed

Complexity

Conditions 1
Paths 1

Size

Total Lines 16

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
dl 0
loc 16
rs 9.7333
c 0
b 0
f 0
cc 1
nc 1
nop 0
1
<?php
2
3
/*
4
 * (c) Christian Gripp <[email protected]>
5
 *
6
 * For the full copyright and license information, please view the LICENSE
7
 * file that was distributed with this source code.
8
 */
9
10
namespace Core23\SitemapBundle\Tests\Sitemap;
11
12
use Core23\SitemapBundle\Definition\SitemapDefinition;
13
use Core23\SitemapBundle\Definition\SitemapDefinitionInterface;
14
use Core23\SitemapBundle\Exception\SitemapNotFoundException;
15
use Core23\SitemapBundle\Sitemap\SitemapServiceInterface;
16
use Core23\SitemapBundle\Sitemap\SitemapServiceManager;
17
use Core23\SitemapBundle\Tests\Fixtures\SitemapService;
18
use PHPUnit\Framework\TestCase;
19
use ReflectionClass;
20
use stdClass;
21
use Symfony\Component\OptionsResolver\Exception\UndefinedOptionsException;
22
use TypeError;
23
24
final class SitemapServiceManagerTest extends TestCase
25
{
26
    public function testCreationWithInvalidServices(): void
27
    {
28
        $this->expectException(TypeError::class);
29
30
        new SitemapServiceManager([
0 ignored issues
show
Documentation introduced by core23
array('invalid' => new \stdClass()) is of type array<string,object<stdC...d":"object<stdClass>"}>, but the function expects a array<integer,object<Cor...temapServiceInterface>>.

It seems like the type of the argument is not accepted by the function/method which you are calling.

In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug.

We suggest to add an explicit type cast like in the following example:

function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
Loading history...
31
            'invalid' => new stdClass(),
32
        ]);
33
    }
34
35
    public function testGet(): void
36
    {
37
        $definition = new SitemapDefinition('my-type', []);
38
39
        $service = new SitemapService();
40
41
        $manager = new SitemapServiceManager([
42
            'my-type' => $service,
43
        ]);
44
        $result =  $manager->get($definition);
45
46
        static::assertInstanceOf(SitemapServiceInterface::class, $result);
47
        static::assertSame([
48
            'custom'           => 'foo',
49
            'use_cache'        => true,
50
            'extra_cache_keys' => [],
51
            'ttl'              => 86400,
52
        ], $definition->getSettings());
53
    }
54
55
    public function testGetWithOverride(): void
56
    {
57
        $definition = new SitemapDefinition('my-type', [
58
            'custom'           => 'bar',
59
            'use_cache'        => false,
60
            'extra_cache_keys' => ['my-key'],
61
            'ttl'              => 0,
62
        ]);
63
64
        $service = new SitemapService();
65
66
        $manager = new SitemapServiceManager([
67
            'my-type' => $service,
68
        ]);
69
        $result =  $manager->get($definition);
70
71
        static::assertInstanceOf(SitemapServiceInterface::class, $result);
72
        static::assertSame([
73
            'use_cache'        => false,
74
            'extra_cache_keys' => ['my-key'],
75
            'ttl'              => 0,
76
            'custom'           => 'bar',
77
        ], $definition->getSettings());
78
    }
79
80
    public function testGetWithInvalidOverride(): void
81
    {
82
        $this->expectException(UndefinedOptionsException::class);
83
        $this->expectExceptionMessage('The option "invalid" does not exist. Defined options are: "custom", "extra_cache_keys", "ttl", "use_cache"');
84
85
        $definition = new SitemapDefinition('my-type', [
86
            'invalid' => 'value',
87
        ]);
88
89
        $service = new SitemapService();
90
91
        $manager = new SitemapServiceManager([
92
            'my-type' => $service,
93
        ]);
94
        $manager->get($definition);
95
    }
96
97
    public function testGetWithInvalidDefinition(): void
98
    {
99
        $this->expectException(SitemapNotFoundException::class);
100
        $this->expectExceptionMessage('The sitemap service "my-type" does not exist');
101
102
        $definition = $this->prophesize(SitemapDefinitionInterface::class);
103
        $definition->getType()
104
            ->willReturn('my-type')
105
        ;
106
        $definition->getSettings()
107
            ->willReturn([])
108
        ;
109
110
        $manager = new SitemapServiceManager();
111
        $manager->get($definition->reveal());
112
    }
113
114
    public function testAddSitemap(): void
115
    {
116
        $service = $this->prophesize(SitemapServiceInterface::class);
117
118
        $manager = new SitemapServiceManager();
119
        $manager->addSitemap('my-type', $service->reveal());
120
121
        $reflection       = new ReflectionClass($manager);
122
123
        $servicesProperty = $reflection->getProperty('services');
124
        $servicesProperty->setAccessible(true);
125
126
        static::assertSame([
127
            'my-type' => $service->reveal(),
128
        ], $servicesProperty->getValue($manager));
129
    }
130
}
131