Skip to content

Commit 6bbebce

Browse files
wilcorreawilcorrea
committed
feat: faker support
1 parent fe8f195 commit 6bbebce

12 files changed

+816
-273
lines changed

‎tests/Core/Fake/Resolver/FromCollectionTest.php‎

Lines changed: 39 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -4,46 +4,58 @@
44

55
namespace Constructo\Test\Core\Fake\Resolver;
66

7-
use Constructo\Core\Fake\Resolver\FromCollection;
87
use Constructo\Support\Set;
9-
use Constructo\Test\Stub\Domain\Collection\GameCollection;
8+
use Constructo\Test\Stub\Domain\Collection\Game\FeatureCollection;
109
use PHPUnit\Framework\TestCase;
11-
use ReflectionMethod;
10+
use ReflectionNamedType;
1211
use ReflectionParameter;
12+
use Constructo\Core\Fake\Resolver\FromCollection;
13+
use stdClass;
1314

1415
final class FromCollectionTest extends TestCase
1516
{
16-
public function testShouldResolveCollectionParameter(): void
17-
{
18-
$resolver = new FromCollection();
19-
$method = new ReflectionMethod($this, 'methodWithCollection');
20-
$parameter = $method->getParameters()[0];
21-
$presets = Set::createFrom([]);
22-
23-
$result = $resolver->resolve($parameter, $presets);
24-
25-
$this->assertNotNull($result);
26-
$this->assertIsArray($result->get());
27-
$this->assertNotEmpty($result->get());
28-
}
29-
30-
public function testShouldReturnNullForNonCollectionParameter(): void
17+
public function testShouldResolveSuccessfully(): void
3118
{
32-
$resolver = new FromCollection();
33-
$method = new ReflectionMethod($this, 'methodWithString');
34-
$parameter = $method->getParameters()[0];
19+
// Arrange
20+
$type = $this->createMock(ReflectionNamedType::class);
21+
$type->expects($this->once())
22+
->method('getName')
23+
->willReturn(FeatureCollection::class);
24+
$parameter = $this->createMock(ReflectionParameter::class);
25+
$parameter->expects($this->once())
26+
->method('getType')
27+
->willReturn($type);
28+
29+
$fromCollection = new FromCollection();
3530
$presets = Set::createFrom([]);
3631

37-
$result = $resolver->resolve($parameter, $presets);
32+
// Act
33+
$result = $fromCollection->resolve($parameter, $presets);
3834

39-
$this->assertNull($result);
35+
// Assert
36+
$this->assertIsArray($result->content);
37+
$this->assertNotEmpty($result->content);
4038
}
4139

42-
private function methodWithCollection(GameCollection $collection): void
43-
{
44-
}
4540

46-
private function methodWithString(string $value): void
41+
public function testShouldNotResolveCollectionWhenParameterIsNotCollection(): void
4742
{
43+
// Arrange
44+
$type = $this->createMock(ReflectionNamedType::class);
45+
$type->expects($this->once())
46+
->method('getName')
47+
->willReturn(stdClass::class);
48+
$parameter = $this->createMock(ReflectionParameter::class);
49+
$parameter->expects($this->once())
50+
->method('getType')
51+
->willReturn($type);
52+
$set = Set::createFrom([]);
53+
$fromCollection = new FromCollection();
54+
55+
// Act
56+
$result = $fromCollection->resolve($parameter, $set);
57+
58+
// Assert
59+
$this->assertNull($result);
4860
}
4961
}

‎tests/Core/Fake/Resolver/FromDefaultValueTest.php‎

Lines changed: 50 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -5,59 +5,79 @@
55
namespace Constructo\Test\Core\Fake\Resolver;
66

77
use Constructo\Core\Fake\Resolver\FromDefaultValue;
8+
use Constructo\Support\Reflective\Factory\Target;
9+
use Constructo\Support\Reflective\Notation;
810
use Constructo\Support\Set;
11+
use Constructo\Test\Stub\Builtin;
12+
use Constructo\Test\Stub\Command;
13+
use Constructo\Test\Stub\NullableAndOptional;
914
use PHPUnit\Framework\TestCase;
10-
use ReflectionMethod;
1115

1216
final class FromDefaultValueTest extends TestCase
1317
{
1418
public function testShouldResolveParameterWithDefaultValue(): void
1519
{
16-
$resolver = new FromDefaultValue();
17-
$method = new ReflectionMethod($this, 'methodWithDefaultValue');
18-
$parameter = $method->getParameters()[0];
19-
$presets = Set::createFrom([]);
20+
$resolver = new FromDefaultValue(Notation::SNAKE);
21+
$target = Target::createFrom(NullableAndOptional::class);
22+
$parameters = $target->getReflectionParameters();
2023

21-
$result = $resolver->resolve($parameter, $presets);
24+
$this->assertCount(3, $parameters);
2225

23-
$this->assertNotNull($result);
24-
$this->assertEquals('default', $result->get());
26+
[2 => $optional] = $parameters;
27+
28+
$set = Set::createFrom([]);
29+
$value = $resolver->resolve($optional, $set);
30+
31+
$this->assertNotNull($value);
32+
$this->assertEquals(10, $value->content);
2533
}
2634

27-
public function testShouldResolveNullableParameter(): void
35+
public function testShouldResolveOptionalParameter(): void
2836
{
29-
$resolver = new FromDefaultValue();
30-
$method = new ReflectionMethod($this, 'methodWithNullableParameter');
31-
$parameter = $method->getParameters()[0];
32-
$presets = Set::createFrom([]);
37+
$resolver = new FromDefaultValue(Notation::SNAKE);
38+
$target = Target::createFrom(Command::class);
39+
$parameters = $target->getReflectionParameters();
40+
41+
// A classe Command tem vários parâmetros opcionais
42+
[6 => $address] = $parameters; // O parâmetro 'address' é opcional e permite null
3343

34-
$result = $resolver->resolve($parameter, $presets);
44+
$set = Set::createFrom([]);
45+
$value = $resolver->resolve($address, $set);
3546

36-
$this->assertNotNull($result);
37-
$this->assertNull($result->get());
47+
$this->assertNotNull($value);
48+
$this->assertNull($value->content);
3849
}
3950

40-
public function testShouldReturnNullForRequiredParameter(): void
51+
public function testShouldResolveNullableParameter(): void
4152
{
42-
$resolver = new FromDefaultValue();
43-
$method = new ReflectionMethod($this, 'methodWithRequiredParameter');
44-
$parameter = $method->getParameters()[0];
45-
$presets = Set::createFrom([]);
53+
$resolver = new FromDefaultValue(Notation::SNAKE);
54+
$target = Target::createFrom(NullableAndOptional::class);
55+
$parameters = $target->getReflectionParameters();
4656

47-
$result = $resolver->resolve($parameter, $presets);
57+
$this->assertCount(3, $parameters);
4858

49-
$this->assertNull($result);
50-
}
59+
[0 => $nullable] = $parameters;
5160

52-
private function methodWithDefaultValue(string $value = 'default'): void
53-
{
54-
}
61+
$set = Set::createFrom([]);
62+
$value = $resolver->resolve($nullable, $set);
5563

56-
private function methodWithNullableParameter(?string $value): void
57-
{
64+
$this->assertNotNull($value);
65+
$this->assertNull($value->content);
5866
}
5967

60-
private function methodWithRequiredParameter(string $value): void
68+
public function testShouldFallbackToNextResolver(): void
6169
{
70+
$resolver = new FromDefaultValue(Notation::SNAKE);
71+
$target = Target::createFrom(Builtin::class);
72+
$parameters = $target->getReflectionParameters();
73+
74+
$this->assertCount(6, $parameters);
75+
76+
[0 => $string] = $parameters;
77+
78+
$set = Set::createFrom([]);
79+
$value = $resolver->resolve($string, $set);
80+
81+
$this->assertNull($value);
6282
}
6383
}

‎tests/Core/Fake/Resolver/FromDependencyTest.php‎

Lines changed: 89 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -4,60 +4,122 @@
44

55
namespace Constructo\Test\Core\Fake\Resolver;
66

7-
use Constructo\Core\Fake\Resolver\FromDependency;
7+
use Constructo\Support\Reflective\Notation;
88
use Constructo\Support\Set;
9-
use Constructo\Test\Stub\Domain\Entity\Game;
109
use PHPUnit\Framework\TestCase;
11-
use ReflectionMethod;
10+
use Constructo\Support\Reflective\Factory\Target;
11+
use Constructo\Test\Stub\Builtin;
12+
use Constructo\Test\Stub\Complex;
13+
use Constructo\Test\Stub\EntityStub;
14+
use Constructo\Test\Stub\Intersection;
15+
use Constructo\Test\Stub\Type\Intersected;
16+
use Constructo\Test\Stub\Union;
17+
use Constructo\Test\Stub\Variety;
18+
use Constructo\Core\Fake\Resolver\FromDependency;
1219

1320
final class FromDependencyTest extends TestCase
1421
{
1522
public function testShouldResolveClassDependency(): void
1623
{
17-
$resolver = new FromDependency();
18-
$method = new ReflectionMethod($this, 'methodWithClassDependency');
19-
$parameter = $method->getParameters()[0];
20-
$presets = Set::createFrom([]);
24+
$resolver = new FromDependency(Notation::SNAKE);
25+
$target = Target::createFrom(Complex::class);
26+
$parameters = $target->getReflectionParameters();
27+
28+
[0 => $entityParameter] = $parameters;
29+
30+
$set = Set::createFrom([]);
31+
$value = $resolver->resolve($entityParameter, $set);
32+
33+
$this->assertNotNull($value);
34+
$this->assertIsArray($value->content);
35+
$this->assertArrayHasKey('id', $value->content);
36+
$this->assertArrayHasKey('price', $value->content);
37+
$this->assertArrayHasKey('name', $value->content);
38+
$this->assertArrayHasKey('is_active', $value->content);
39+
}
40+
41+
public function testShouldNotResolveBuiltinType(): void
42+
{
43+
$resolver = new FromDependency(Notation::SNAKE);
44+
$target = Target::createFrom(Builtin::class);
45+
$parameters = $target->getReflectionParameters();
2146

22-
$result = $resolver->resolve($parameter, $presets);
47+
[0 => $stringParameter] = $parameters;
2348

24-
$this->assertNotNull($result);
25-
$this->assertIsArray($result->get());
49+
$set = Set::createFrom([]);
50+
$value = $resolver->resolve($stringParameter, $set);
51+
52+
$this->assertNull($value);
2653
}
2754

28-
public function testShouldReturnNullForBuiltinType(): void
55+
public function testShouldNotResolveEnumType(): void
2956
{
30-
$resolver = new FromDependency();
31-
$method = new ReflectionMethod($this, 'methodWithBuiltinType');
32-
$parameter = $method->getParameters()[0];
33-
$presets = Set::createFrom([]);
57+
$resolver = new FromDependency(Notation::SNAKE);
58+
$target = Target::createFrom(EntityStub::class);
59+
$parameters = $target->getReflectionParameters();
60+
61+
[8 => $enumParameter] = $parameters;
3462

35-
$result = $resolver->resolve($parameter, $presets);
63+
$set = Set::createFrom([]);
64+
$value = $resolver->resolve($enumParameter, $set);
3665

37-
$this->assertNull($result);
66+
$this->assertNull($value);
3867
}
3968

40-
public function testShouldReturnNullForIntersectionType(): void
69+
public function testShouldNotResolveIntersectionType(): void
4170
{
42-
$resolver = new FromDependency();
43-
$method = new ReflectionMethod($this, 'methodWithIntersectionType');
44-
$parameter = $method->getParameters()[0];
45-
$presets = Set::createFrom([]);
71+
$resolver = new FromDependency(Notation::SNAKE);
72+
$target = Target::createFrom(Variety::class);
73+
$parameters = $target->getReflectionParameters();
4674

47-
$result = $resolver->resolve($parameter, $presets);
75+
[1 => $intersectionParameter] = $parameters;
4876

49-
$this->assertNull($result);
77+
$set = Set::createFrom([]);
78+
$value = $resolver->resolve($intersectionParameter, $set);
79+
80+
$this->assertNull($value);
5081
}
5182

52-
private function methodWithClassDependency(Game $game): void
83+
public function testShouldResolveUnionTypeWithFirstEligibleType(): void
5384
{
85+
$resolver = new FromDependency(Notation::SNAKE);
86+
$target = Target::createFrom(Union::class);
87+
$parameters = $target->getReflectionParameters();
88+
89+
[2 => $nativeUnionParameter] = $parameters;
90+
91+
$set = Set::createFrom([]);
92+
$value = $resolver->resolve($nativeUnionParameter, $set);
93+
94+
$this->assertNotNull($value);
95+
$this->assertIsArray($value->content);
5496
}
5597

56-
private function methodWithBuiltinType(string $value): void
98+
public function testShouldFallbackToNextResolverForNonExistingClass(): void
5799
{
100+
$resolver = new FromDependency(Notation::SNAKE);
101+
$target = Target::createFrom(Intersection::class);
102+
$parameters = $target->getReflectionParameters();
103+
104+
[0 => $intersectedParameter] = $parameters;
105+
106+
$set = Set::createFrom(['intersected' => new Intersected()]);
107+
$value = $resolver->resolve($intersectedParameter, $set);
108+
109+
$this->assertNull($value);
58110
}
59111

60-
private function methodWithIntersectionType(\Countable&\Iterator $value): void
112+
public function testShouldReturnNullForParameterWithoutType(): void
61113
{
114+
$resolver = new FromDependency(Notation::SNAKE);
115+
$target = Target::createFrom(Variety::class);
116+
$parameters = $target->getReflectionParameters();
117+
118+
[3 => $whateverParameter] = $parameters;
119+
120+
$set = Set::createFrom([]);
121+
$value = $resolver->resolve($whateverParameter, $set);
122+
123+
$this->assertNull($value);
62124
}
63125
}

0 commit comments

Comments
 (0)