purgatory-bundle/tests/Cache/PropertyResolver/MethodResolverTest.php at f31c4e5ebbfad0fc3663a7c894c547675b020446 · HypeMC/purgatory-bundle · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
<?php

declare(strict_types=1);

namespace Sofascore\PurgatoryBundle\Tests\Cache\PropertyResolver;

use Doctrine\Persistence\ManagerRegistry;
use Doctrine\Persistence\Mapping\ClassMetadata;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\TestWith;
use PHPUnit\Framework\TestCase;
use Sofascore\PurgatoryBundle\Attribute\PurgeOn;
use Sofascore\PurgatoryBundle\Attribute\Target\ForProperties;
use Sofascore\PurgatoryBundle\Cache\PropertyResolver\MethodResolver;
use Sofascore\PurgatoryBundle\Cache\PropertyResolver\PropertyResolver;
use Sofascore\PurgatoryBundle\Cache\RouteMetadata\RouteMetadata;
use Sofascore\PurgatoryBundle\Cache\Subscription\PurgeSubscription;
use Sofascore\PurgatoryBundle\Tests\Cache\PropertyResolver\Fixtures\DummyEntity;
use Symfony\Component\PropertyInfo\PropertyReadInfo;
use Symfony\Component\PropertyInfo\PropertyReadInfoExtractorInterface;
use Symfony\Component\Routing\Route;

#[CoversClass(MethodResolver::class)]
final class MethodResolverTest extends TestCase
{
    #[TestWith(['foo', 1])]
    #[TestWith(['getFoo', 0])]
    public function testResolveMethod(string $target, int $invocationCount): void
    {
        $propertyReadInfoExtractor = $this->createMock(PropertyReadInfoExtractorInterface::class);
        $propertyReadInfoExtractor->expects(self::exactly($invocationCount))
            ->method('getReadInfo')
            ->with(DummyEntity::class, 'foo')
            ->willReturn(new PropertyReadInfo(
                PropertyReadInfo::TYPE_METHOD,
                'getFoo',
                PropertyReadInfo::VISIBILITY_PUBLIC,
                false,
                false,
            ));

        $resolver = new MethodResolver(
            [new PropertyResolver(self::createStub(ManagerRegistry::class))],
            $propertyReadInfoExtractor,
        );

        $classMetadata = self::createStub(ClassMetadata::class);
        $classMetadata->method('hasField')
            ->willReturnCallback(static fn (string $property) => match ($property) {
                'bar' => true,
                'baz' => true,
            });

        $purgeSubscriptions = $resolver->resolveSubscription(
            routeMetadata: new RouteMetadata(
                routeName: 'route_foo',
                route: new Route('/foo'),
                purgeOn: new PurgeOn(
                    class: DummyEntity::class,
                    target: new ForProperties([$target]),
                ),
                reflectionMethod: self::createStub(\ReflectionMethod::class),
            ),
            classMetadata: $classMetadata,
            routeParams: [],
            target: $target,
        );

        /** @var PurgeSubscription[] $subscriptions */
        $subscriptions = [...$purgeSubscriptions];

        self::assertTrue($purgeSubscriptions->getReturn());

        self::assertContainsOnlyInstancesOf(PurgeSubscription::class, $subscriptions);
        self::assertCount(2, $subscriptions);

        self::assertSame('bar', $subscriptions[0]->property);
        self::assertSame(DummyEntity::class, $subscriptions[0]->class);

        self::assertSame('baz', $subscriptions[1]->property);
        self::assertSame(DummyEntity::class, $subscriptions[1]->class);
    }

    public function testTargetNotMethod(): void
    {
        $propertyReadInfoExtractor = $this->createMock(PropertyReadInfoExtractorInterface::class);
        $propertyReadInfoExtractor->expects(self::once())
            ->method('getReadInfo')
            ->with(DummyEntity::class, 'bar')
            ->willReturn(new PropertyReadInfo(
                PropertyReadInfo::TYPE_PROPERTY,
                'bar',
                PropertyReadInfo::VISIBILITY_PUBLIC,
                false,
                false,
            ));

        $resolver = new MethodResolver(
            [],
            $propertyReadInfoExtractor,
        );

        $classMetadata = self::createStub(ClassMetadata::class);

        $purgeSubscriptions = $resolver->resolveSubscription(
            routeMetadata: new RouteMetadata(
                routeName: 'route_foo',
                route: new Route('/foo'),
                purgeOn: new PurgeOn(
                    class: DummyEntity::class,
                    target: new ForProperties(['bar']),
                ),
                reflectionMethod: self::createStub(\ReflectionMethod::class),
            ),
            classMetadata: $classMetadata,
            routeParams: [],
            target: 'bar',
        );

        /** @var PurgeSubscription[] $subscriptions */
        $subscriptions = [...$purgeSubscriptions];

        self::assertFalse($purgeSubscriptions->getReturn());

        self::assertCount(0, $subscriptions);
    }
}