AttributeUtils/tests/FunctionAnalyzerTest.php at 4dfb5d464f8e1eeac7f765a81b026594c924a407 · Crell/AttributeUtils · 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
<?php

declare(strict_types=1);

namespace Crell\AttributeUtils;

use Crell\AttributeUtils\Attributes\Functions\HasParameters;
use Crell\AttributeUtils\Attributes\Functions\IncludesReflection;
use Crell\AttributeUtils\Attributes\Functions\ParameterAttrib;
use Crell\AttributeUtils\Attributes\Functions\RequiredArg;
use Crell\AttributeUtils\Attributes\Functions\SubChild;
use Crell\AttributeUtils\Attributes\Functions\SubParent;
use Crell\AttributeUtils\SubattributeReflection\ComponentAttribute;
use Crell\AttributeUtils\SubattributeReflection\FuncAllFeaturesForSubAttrib;
use Crell\AttributeUtils\SubattributeReflection\SubAttributeReflect;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\TestCase;

// @phpstan-ignore-next-line
#[RequiredArg]
function required_attribute_arguments_missing() {}

#[IncludesReflection]
function from_reflection() {}

#[SubParent]
#[SubChild(b: 'Override')]
function has_sub_attributes() {}

#[HasParameters(ParameterAttrib::class)]
function has_parameters(
    #[ParameterAttrib] int $first,
    #[ParameterAttrib('Override')] int $second,
) {}


#[FuncAllFeaturesForSubAttrib, SubAttributeReflect]
function func_for_subattrib(
    #[ComponentAttribute, SubAttributeReflect] string $parameter,
) {}

class FunctionAnalyzerTest extends TestCase
{
    protected string $ns;

    public function setUp(): void
    {
        $this->ns = __NAMESPACE__;
    }

    #[Test, DataProvider('attributeTestProvider')]
    public function analyze_functions(string|\Closure $subject, string $attribute, callable $test): void
    {
        $analyzer = new FuncAnalyzer();

        $classDef = $analyzer->analyze($subject, $attribute);

        $test($classDef);
    }

    #[Test]
    public function missing_required_fields(): void
    {
        $this->expectException(RequiredAttributeArgumentsMissing::class);
        $analyzer = new FuncAnalyzer();

        $analyzer->analyze("{$this->ns}\\required_attribute_arguments_missing", Attributes\Functions\RequiredArg::class);
    }

    /**
     * @see analyze_classes()
     */
    public static function attributeTestProvider(): \Generator
    {
        $ns = __NAMESPACE__ . '\\';

        yield 'Includes Reflection' => [
            'subject' => "{$ns}from_reflection",
            'attribute' => IncludesReflection::class,
            'test' => static function(IncludesReflection $funcDef) use ($ns) {
                static::assertEquals("{$ns}from_reflection", $funcDef->name);
            },
        ];

        yield 'Includes Sub-attribute' => [
            'subject' => "{$ns}has_sub_attributes",
            'attribute' => SubParent::class,
            'test' => static function(SubParent $funcDef) use ($ns) {
                static::assertEquals('Override', $funcDef->child->b);
            },
        ];

        yield 'Includes parameters' => [
            'subject' => "{$ns}has_parameters",
            'attribute' => HasParameters::class,
            'test' => static function(HasParameters $funcDef) use ($ns) {
                static::assertEquals('default', $funcDef->parameters['first']->a);
                static::assertEquals('Override', $funcDef->parameters['second']->a);
            },
        ];

        yield 'Closure' => [
            'subject' => #[HasParameters(ParameterAttrib::class)] fn (#[ParameterAttrib] int $first,
                             #[ParameterAttrib('Override')] int $second,
            ): int => $first * $second,
            'attribute' => HasParameters::class,
            'test' => static function(HasParameters $funcDef) use ($ns) {
                static::assertEquals('default', $funcDef->parameters['first']->a);
                static::assertEquals('Override', $funcDef->parameters['second']->a);
            },
        ];

        yield 'Subattributes with FromReflection (function)' => [
            'subject' => "{$ns}func_for_subattrib",
            'attribute' => FuncAllFeaturesForSubAttrib::class,
            'test' => static function(FuncAllFeaturesForSubAttrib $funcDef) use ($ns) {
                static::assertEquals("{$ns}func_for_subattrib", $funcDef->sub->name);
                static::assertEquals('parameter', $funcDef->parameters['parameter']->sub->name);
            },
        ];
    }
}