Skip to content

Commit 474a12a

Browse files
SerafimArtsSerafimArts
committed
Fix and actualize tests
1 parent e219729 commit 474a12a

File tree

9 files changed

+80
-123
lines changed

9 files changed

+80
-123
lines changed

‎tests/Concerns/InteractWithRuntimeContext.php‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ protected static function createNormalizationContext(mixed $value, ?Configuratio
1919
context: self::createMapperContext($config),
2020
value: $value,
2121
direction: Direction::Normalize,
22-
types: self::getTypeRepository(Direction::Normalize),
22+
types: self::getTypeRepository(),
2323
);
2424
}
2525

@@ -29,7 +29,7 @@ protected static function createDenormalizationContext(mixed $value, ?Configurat
2929
context: self::createMapperContext($config),
3030
value: $value,
3131
direction: Direction::Denormalize,
32-
types: self::getTypeRepository(Direction::Denormalize),
32+
types: self::getTypeRepository(),
3333
);
3434
}
3535
}

‎tests/Concerns/InteractWithTypeRepository.php‎

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -27,20 +27,19 @@ protected static function withTypeRepository(TypeRepositoryInterface $repository
2727
self::$currentTypeRepository = $repository;
2828
}
2929

30-
private static function createTypeRepository(DirectionInterface $direction): TypeRepositoryInterface
30+
private static function createTypeRepository(): TypeRepositoryInterface
3131
{
3232
$platform = self::getPlatform();
3333

3434
return new TypeRepository(
3535
context: self::createMapperContext(),
36-
direction: $direction,
3736
builders: $platform->getTypes()
3837
);
3938
}
4039

41-
protected static function getTypeRepository(DirectionInterface $direction): TypeRepositoryInterface
40+
protected static function getTypeRepository(): TypeRepositoryInterface
4241
{
4342
return self::$currentTypeRepository
44-
??= self::createTypeRepository($direction);
43+
??= self::createTypeRepository();
4544
}
4645
}

‎tests/Mapping/Reference/ReferencesResolverTest.php‎

Lines changed: 56 additions & 87 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@
44

55
namespace TypeLang\Mapper\Tests\Mapping\Reference;
66

7+
use PHPUnit\Framework\Attributes\TestDox;
78
use TypeLang\Mapper\Mapping\Reference\Reader\ReferencesReaderInterface;
89
use TypeLang\Mapper\Mapping\Reference\ReferencesResolver;
910
use TypeLang\Mapper\Tests\Mapping\Reference\Stub\SimpleClassStub;
@@ -12,162 +13,130 @@
1213

1314
final class ReferencesResolverTest extends ReferenceTestCase
1415
{
15-
public function testResolveWithSimpleNameInSameNamespace(): void
16+
private function getResolver(array $useStatements = []): ReferencesResolver
1617
{
1718
$reader = $this->createMock(ReferencesReaderInterface::class);
18-
$reader->method('getUseStatements')->willReturn([]);
1919

20-
$resolver = new ReferencesResolver($reader);
21-
$statement = new NamedTypeNode('TestClass');
22-
$context = new \ReflectionClass(SimpleClassStub::class);
20+
$reader->method('getUseStatements')
21+
->willReturn($useStatements);
22+
23+
return new ReferencesResolver($reader);
24+
}
25+
26+
#[TestDox('if no "use" stmt, then the namespace must be same as the class')]
27+
public function testResolveWithSimpleNameInSameNamespace(): void
28+
{
29+
$needle = new NamedTypeNode('TestClass');
30+
$haystack = new \ReflectionClass(SimpleClassStub::class);
2331

24-
$result = $resolver->resolve($statement, $context);
32+
$result = $this->getResolver()
33+
->resolve($needle, $haystack);
2534

2635
self::assertInstanceOf(NamedTypeNode::class, $result);
27-
self::assertSame('TestClass', $result->name->toString());
36+
self::assertSame('TypeLang\Mapper\Tests\Mapping\Reference\Stub\TestClass', $result->name->toString());
2837
}
2938

3039
public function testResolveWithUseStatement(): void
3140
{
32-
$reader = $this->createMock(ReferencesReaderInterface::class);
33-
$reader->method('getUseStatements')->willReturn([
41+
$needle = new NamedTypeNode('Any');
42+
$haystack = new \ReflectionClass(SimpleClassStub::class);
43+
44+
$result = $this->getResolver([
3445
'Any' => 'Some\\Any',
3546
'Example' => 'Some\\Any\\Test',
36-
]);
37-
38-
$resolver = new ReferencesResolver($reader);
39-
$statement = new NamedTypeNode('Any');
40-
$context = new \ReflectionClass(SimpleClassStub::class);
41-
42-
$result = $resolver->resolve($statement, $context);
47+
])
48+
->resolve($needle, $haystack);
4349

4450
self::assertInstanceOf(NamedTypeNode::class, $result);
4551
self::assertSame('Some\\Any', $result->name->toString());
4652
}
4753

4854
public function testResolveWithAliasedUseStatement(): void
4955
{
50-
$reader = $this->createMock(ReferencesReaderInterface::class);
51-
$reader->method('getUseStatements')->willReturn([
52-
'Example' => 'Some\\Any\\Test',
53-
]);
56+
$needle = new NamedTypeNode('Example');
57+
$haystack = new \ReflectionClass(SimpleClassStub::class);
5458

55-
$resolver = new ReferencesResolver($reader);
56-
$statement = new NamedTypeNode('Example');
57-
$context = new \ReflectionClass(SimpleClassStub::class);
58-
59-
$result = $resolver->resolve($statement, $context);
59+
$result = $this->getResolver([
60+
'Example' => 'Some\\Any\\Test',
61+
])
62+
->resolve($needle, $haystack);
6063

6164
self::assertInstanceOf(NamedTypeNode::class, $result);
6265
self::assertSame('Some\\Any\\Test', $result->name->toString());
6366
}
6467

6568
public function testResolveWithNamespaceKeyword(): void
6669
{
67-
$reader = $this->createMock(ReferencesReaderInterface::class);
68-
$reader->method('getUseStatements')->willReturn([]);
69-
70-
$resolver = new ReferencesResolver($reader);
71-
$statement = new NamedTypeNode('namespace\\TestClass');
72-
$context = new \ReflectionClass(SimpleClassStub::class);
70+
$needle = new NamedTypeNode('namespace\\TestClass');
71+
$haystack = new \ReflectionClass(SimpleClassStub::class);
7372

74-
$result = $resolver->resolve($statement, $context);
73+
$result = $this->getResolver()
74+
->resolve($needle, $haystack);
7575

7676
self::assertInstanceOf(NamedTypeNode::class, $result);
7777
self::assertSame('TypeLang\\Mapper\\Tests\\Mapping\\Reference\\Stub\\TestClass', $result->name->toString());
7878
}
7979

8080
public function testResolveWithNamespaceKeywordInGlobalNamespace(): void
8181
{
82-
$reader = $this->createMock(ReferencesReaderInterface::class);
83-
$reader->method('getUseStatements')->willReturn([]);
84-
85-
$resolver = new ReferencesResolver($reader);
86-
$statement = new NamedTypeNode('namespace\\TestClass');
87-
$context = new \ReflectionClass(\stdClass::class); // stdClass is in global namespace
82+
$needle = new NamedTypeNode('namespace\\TestClass');
83+
$haystack = new \ReflectionClass(\stdClass::class); // stdClass is in global namespace
8884

89-
$result = $resolver->resolve($statement, $context);
85+
$result = $this->getResolver()
86+
->resolve($needle, $haystack);
9087

9188
self::assertInstanceOf(NamedTypeNode::class, $result);
9289
self::assertSame('TestClass', $result->name->toString());
9390
}
9491

9592
public function testResolveWithFullyQualifiedName(): void
9693
{
97-
$reader = $this->createMock(ReferencesReaderInterface::class);
98-
$reader->method('getUseStatements')->willReturn([]);
99-
100-
$resolver = new ReferencesResolver($reader);
101-
$statement = new NamedTypeNode(new FullQualifiedName('\\Some\\Fully\\Qualified\\Class'));
102-
$context = new \ReflectionClass(SimpleClassStub::class);
94+
$needle = new NamedTypeNode(new FullQualifiedName('\\Some\\Fully\\Qualified\\Class'));
95+
$haystack = new \ReflectionClass(SimpleClassStub::class);
10396

104-
$result = $resolver->resolve($statement, $context);
97+
$result = $this->getResolver()
98+
->resolve($needle, $haystack);
10599

106100
self::assertInstanceOf(NamedTypeNode::class, $result);
107101
self::assertSame('\\Some\\Fully\\Qualified\\Class', $result->name->toString());
108102
}
109103

110-
public function testResolveWithNonExistentClassInNamespace(): void
111-
{
112-
$reader = $this->createMock(ReferencesReaderInterface::class);
113-
$reader->method('getUseStatements')->willReturn([]);
114-
115-
$resolver = new ReferencesResolver($reader);
116-
$statement = new NamedTypeNode('NonExistentClass');
117-
$context = new \ReflectionClass(SimpleClassStub::class);
118-
119-
$result = $resolver->resolve($statement, $context);
120-
121-
// Should return original statement if class doesn't exist in namespace
122-
self::assertInstanceOf(NamedTypeNode::class, $result);
123-
self::assertSame('NonExistentClass', $result->name->toString());
124-
}
125-
126104
public function testResolveWithComplexNamespaceKeyword(): void
127105
{
128-
$reader = $this->createMock(ReferencesReaderInterface::class);
129-
$reader->method('getUseStatements')->willReturn([]);
130-
131-
$resolver = new ReferencesResolver($reader);
132-
$statement = new NamedTypeNode('namespace\\Sub\\Namespace\\TestClass');
133-
$context = new \ReflectionClass(SimpleClassStub::class);
106+
$needle = new NamedTypeNode('namespace\\Sub\\Namespace\\TestClass');
107+
$haystack = new \ReflectionClass(SimpleClassStub::class);
134108

135-
$result = $resolver->resolve($statement, $context);
109+
$result = $this->getResolver()
110+
->resolve($needle, $haystack);
136111

137112
self::assertInstanceOf(NamedTypeNode::class, $result);
138113
self::assertSame('TypeLang\\Mapper\\Tests\\Mapping\\Reference\\Stub\\Sub\\Namespace\\TestClass', $result->name->toString());
139114
}
140115

141116
public function testResolveWithMixedUseStatements(): void
142117
{
143-
$reader = $this->createMock(ReferencesReaderInterface::class);
144-
$reader->method('getUseStatements')->willReturn([
118+
$needle = new NamedTypeNode('GlobalClass');
119+
$haystack = new \ReflectionClass(SimpleClassStub::class);
120+
121+
$result = $this->getResolver([
145122
'Any' => 'Some\\Any',
146123
'Example' => 'Some\\Any\\Test',
147124
'GlobalClass', // No alias, just the class name
148-
]);
149-
150-
$resolver = new ReferencesResolver($reader);
151-
$statement = new NamedTypeNode('Example');
152-
$context = new \ReflectionClass(SimpleClassStub::class);
153-
154-
$result = $resolver->resolve($statement, $context);
125+
])
126+
->resolve($needle, $haystack);
155127

156128
self::assertInstanceOf(NamedTypeNode::class, $result);
157-
self::assertSame('Some\\Any\\Test', $result->name->toString());
129+
self::assertSame('GlobalClass', $result->name->toString());
158130
}
159131

160132
public function testResolvePreservesOriginalStatementWhenNoResolutionNeeded(): void
161133
{
162-
$reader = $this->createMock(ReferencesReaderInterface::class);
163-
$reader->method('getUseStatements')->willReturn([]);
164-
165-
$resolver = new ReferencesResolver($reader);
166-
$statement = new NamedTypeNode('\\Fully\\Qualified\\Class');
167-
$context = new \ReflectionClass(SimpleClassStub::class);
134+
$needle = new NamedTypeNode('\\Fully\\Qualified\\Class');
135+
$haystack = new \ReflectionClass(SimpleClassStub::class);
168136

169-
$result = $resolver->resolve($statement, $context);
137+
$result = $this->getResolver()
138+
->resolve($needle, $haystack);
170139

171-
self::assertSame($statement, $result);
140+
self::assertSame($needle, $result);
172141
}
173142
}

‎tests/Platform/PlatformTestCase.php‎

Lines changed: 4 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -285,7 +285,7 @@ public static function typesDataProvider(): iterable
285285

286286
abstract protected function createTypePlatform(): PlatformInterface;
287287

288-
private function testTypeIsAvailable(string $definition, bool $supports, DirectionInterface $direction): void
288+
private function assertTypeIsAvailable(string $definition, bool $supports): void
289289
{
290290
if (!$supports) {
291291
$this->expectException(ParseException::class);
@@ -302,19 +302,13 @@ private function testTypeIsAvailable(string $definition, bool $supports, Directi
302302
$this->expectNotToPerformAssertions();
303303
}
304304

305-
$repository = self::createTypeRepository($direction);
305+
$repository = self::createTypeRepository();
306306
$repository->getTypeByStatement($statement);
307307
}
308308

309309
#[DataProvider('typesDataProvider')]
310-
public function testNormalizationTypeIsAvailable(string $definition, bool $supports): void
310+
public function testTypeIsAvailable(string $definition, bool $supports): void
311311
{
312-
$this->testTypeIsAvailable($definition, $supports, Direction::Normalize);
313-
}
314-
315-
#[DataProvider('typesDataProvider')]
316-
public function testDenormalizationTypeIsAvailable(string $definition, bool $supports): void
317-
{
318-
$this->testTypeIsAvailable($definition, $supports, Direction::Denormalize);
312+
$this->assertTypeIsAvailable($definition, $supports);
319313
}
320314
}

‎tests/TestCase.php‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,6 @@
55
namespace TypeLang\Mapper\Tests;
66

77
use PHPUnit\Framework\TestCase as BaseTestCase;
8-
use TypeLang\Mapper\Exception\Runtime\InvalidValueException;
98

109
abstract class TestCase extends BaseTestCase
1110
{

‎tests/Type/Coercer/ArrayKeyTypeCoercerTest.php‎

Lines changed: 0 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -56,21 +56,11 @@ protected static function castValues(bool $normalize): iterable
5656
$value === 'false' => 'false',
5757
$value === 'non empty' => 'non empty',
5858
$value === '' => '',
59-
$value === '42' => 42,
60-
$value === '1' => 1,
61-
$value === '0' => 0,
62-
$value === '-1' => -1,
63-
$value === '-42' => -42,
6459
$value === 42.0 => 42,
6560
$value === 1.0 => 1,
6661
$value === 0.0 => 0,
6762
$value === -1.0 => -1,
6863
$value === -42.0 => -42,
69-
$value === '42.0' => 42,
70-
$value === '1.0' => 1,
71-
$value === '0.0' => 0,
72-
$value === '-1.0' => -1,
73-
$value === '-42.0' => -42,
7464
$value === null => 0,
7565
$value === true => 1,
7666
$value === false => 0,

‎tests/Type/Coercer/TypeCoercerTestCase.php‎

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -22,12 +22,12 @@ abstract protected static function castValues(bool $normalize): iterable;
2222
abstract protected static function createCoercer(): TypeCoercerInterface;
2323

2424
/**
25-
* @return iterable<mixed, \ValueError>
25+
* @return iterable<mixed, mixed>
2626
*/
2727
final protected static function defaultCoercionSamples(): iterable
2828
{
2929
return (new DataSamples())
30-
->getCastsIterator();
30+
->getCoercionIterator();
3131
}
3232

3333
/**
@@ -44,8 +44,6 @@ public static function castNormalizationDataProvider(): iterable
4444
#[DataProvider('castNormalizationDataProvider')]
4545
public function testCoerceForNormalization(mixed $value, mixed $expected): void
4646
{
47-
$this->expectTypeErrorIfException($expected);
48-
4947
$coercer = static::createCoercer();
5048

5149
$actual = $coercer->tryCoerce($value, self::createNormalizationContext(
@@ -69,8 +67,6 @@ public static function castDenormalizationDataProvider(): iterable
6967
#[DataProvider('castDenormalizationDataProvider')]
7068
public function testCoerceForDenormalization(mixed $value, mixed $expected): void
7169
{
72-
$this->expectTypeErrorIfException($expected);
73-
7470
$coercer = static::createCoercer();
7571

7672
$actual = $coercer->tryCoerce($value, self::createNormalizationContext(

‎tests/Type/Stub/DataSamples.php‎

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -36,11 +36,21 @@ public function getCastsIterator(): \Traversable
3636
foreach ($this as $value) {
3737
yield $value => new \ValueError(\sprintf(
3838
'Passed value %s is invalid',
39-
$printer->print($value)
39+
$printer->print($value),
4040
));
4141
}
4242
}
4343

44+
/**
45+
* @return \Traversable<mixed, mixed>
46+
*/
47+
public function getCoercionIterator(): \Traversable
48+
{
49+
foreach ($this as $value) {
50+
yield $value => $value;
51+
}
52+
}
53+
4454
/**
4555
* @return iterable<array-key, mixed>
4656
*/

0 commit comments

Comments
 (0)