Skip to content

Commit 8341c9d

Browse files
ArticusArticus
committed
- new configurable strategy and validator to deal with serialized values
1 parent b1c310c commit 8341c9d

File tree

5 files changed

+465
-1
lines changed

5 files changed

+465
-1
lines changed

‎spec/Articus/DataTransfer/Strategy/SerializableValue.spec.php

+219
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,219 @@
1+
<?php
2+
declare(strict_types=1);
3+
4+
use Articus\DataTransfer as DT;
5+
use spec\Example;
6+
7+
describe(DT\Strategy\SerializableValue::class, function ()
8+
{
9+
describe('->extract', function ()
10+
{
11+
afterEach(function ()
12+
{
13+
Mockery::close();
14+
});
15+
it('extracts null', function ()
16+
{
17+
$valueStrategy = mock(DT\Strategy\StrategyInterface::class);
18+
$serializer = mock(Example\InvokableInterface::class);
19+
$unserializer = mock(Example\InvokableInterface::class);
20+
21+
$strategy = new DT\Strategy\SerializableValue($valueStrategy, $serializer, $unserializer);
22+
expect($strategy->extract(null))->toBeNull();
23+
});
24+
it('delegates non-null extraction to value strategy', function ()
25+
{
26+
$source = mock();
27+
$extractedSource = mock();
28+
$destination = 'some string';
29+
$valueStrategy = mock(DT\Strategy\StrategyInterface::class);
30+
$serializer = mock(Example\InvokableInterface::class);
31+
$unserializer = mock(Example\InvokableInterface::class);
32+
33+
$valueStrategy->shouldReceive('extract')->with($source)->andReturn($extractedSource)->once();
34+
$serializer->shouldReceive('__invoke')->with($extractedSource)->andReturn($destination)->once();
35+
36+
$strategy = new DT\Strategy\SerializableValue($valueStrategy, $serializer, $unserializer);
37+
expect($strategy->extract($source))->toBe($destination);
38+
});
39+
});
40+
describe('->hydrate', function ()
41+
{
42+
afterEach(function ()
43+
{
44+
Mockery::close();
45+
});
46+
it('hydrates from null', function ()
47+
{
48+
$source = null;
49+
$destination = mock();
50+
$valueStrategy = mock(DT\Strategy\StrategyInterface::class);
51+
$serializer = mock(Example\InvokableInterface::class);
52+
$unserializer = mock(Example\InvokableInterface::class);
53+
54+
$strategy = new DT\Strategy\SerializableValue($valueStrategy, $serializer, $unserializer);
55+
$strategy->hydrate($source, $destination);
56+
expect($destination)->toBeNull();
57+
});
58+
it('throws on non-string source', function ()
59+
{
60+
$source = mock();
61+
$destination = mock();
62+
$valueStrategy = mock(DT\Strategy\StrategyInterface::class);
63+
$serializer = mock(Example\InvokableInterface::class);
64+
$unserializer = mock(Example\InvokableInterface::class);
65+
66+
$strategy = new DT\Strategy\SerializableValue($valueStrategy, $serializer, $unserializer);
67+
try
68+
{
69+
$strategy->hydrate($source, $destination);
70+
throw new LogicException('No expected exception');
71+
}
72+
catch (DT\Exception\InvalidData $e)
73+
{
74+
expect($e->getViolations())->toBe(DT\Exception\InvalidData::DEFAULT_VIOLATION);
75+
expect($e->getPrevious())->toBeAnInstanceOf(InvalidArgumentException::class);
76+
expect($e->getPrevious()->getMessage())->toBe(
77+
sprintf('Hydration can be done only from string, not %s', get_class($source))
78+
);
79+
}
80+
});
81+
it('delegates hydration to value strategy if source is string', function ()
82+
{
83+
$source = 'aaa';
84+
$extractedSource = mock();
85+
$oldDestination = mock();
86+
$newDestination = mock();
87+
$destination = $oldDestination;
88+
$valueStrategy = mock(DT\Strategy\StrategyInterface::class);
89+
$serializer = mock(Example\InvokableInterface::class);
90+
$unserializer = mock(Example\InvokableInterface::class);
91+
92+
$unserializer->shouldReceive('__invoke')->with($source)->andReturn($extractedSource)->once();
93+
$valueStrategy->shouldReceive('hydrate')->withArgs(
94+
function ($a, &$b) use (&$extractedSource, &$oldDestination, &$newDestination)
95+
{
96+
$result = ($a === $extractedSource) && ($b === $oldDestination);
97+
if ($result)
98+
{
99+
$b = $newDestination;
100+
}
101+
return $result;
102+
}
103+
)->once();
104+
105+
$strategy = new DT\Strategy\SerializableValue($valueStrategy, $serializer, $unserializer);
106+
$strategy->hydrate($source, $destination);
107+
expect($destination)->toBe($newDestination);
108+
});
109+
});
110+
describe('->merge', function ()
111+
{
112+
afterEach(function ()
113+
{
114+
Mockery::close();
115+
});
116+
it('merges from null', function ()
117+
{
118+
$source = null;
119+
$destination = 'some destination';
120+
$valueStrategy = mock(DT\Strategy\StrategyInterface::class);
121+
$serializer = mock(Example\InvokableInterface::class);
122+
$unserializer = mock(Example\InvokableInterface::class);
123+
124+
$strategy = new DT\Strategy\SerializableValue($valueStrategy, $serializer, $unserializer);
125+
$strategy->merge($source, $destination);
126+
expect($destination)->toBeNull();
127+
});
128+
it('throws on non-string source', function ()
129+
{
130+
$source = mock();
131+
$destination = 'some destination';
132+
$valueStrategy = mock(DT\Strategy\StrategyInterface::class);
133+
$serializer = mock(Example\InvokableInterface::class);
134+
$unserializer = mock(Example\InvokableInterface::class);
135+
136+
$strategy = new DT\Strategy\SerializableValue($valueStrategy, $serializer, $unserializer);
137+
try
138+
{
139+
$strategy->merge($source, $destination);
140+
throw new LogicException('No expected exception');
141+
}
142+
catch (DT\Exception\InvalidData $e)
143+
{
144+
expect($e->getViolations())->toBe(DT\Exception\InvalidData::DEFAULT_VIOLATION);
145+
expect($e->getPrevious())->toBeAnInstanceOf(InvalidArgumentException::class);
146+
expect($e->getPrevious()->getMessage())->toBe(
147+
sprintf('Merge can be done only from string, not %s', get_class($source))
148+
);
149+
}
150+
});
151+
it('copies source to destination if source is string and destination is null', function ()
152+
{
153+
$source = 'some source';
154+
$destination = null;
155+
$valueStrategy = mock(DT\Strategy\StrategyInterface::class);
156+
$serializer = mock(Example\InvokableInterface::class);
157+
$unserializer = mock(Example\InvokableInterface::class);
158+
159+
$strategy = new DT\Strategy\SerializableValue($valueStrategy, $serializer, $unserializer);
160+
$strategy->merge($source, $destination);
161+
expect($destination)->toBe($source);
162+
});
163+
it('throws on string source and non-string destination', function ()
164+
{
165+
$source = 'some source';
166+
$destination = mock();
167+
$valueStrategy = mock(DT\Strategy\StrategyInterface::class);
168+
$serializer = mock(Example\InvokableInterface::class);
169+
$unserializer = mock(Example\InvokableInterface::class);
170+
171+
$strategy = new DT\Strategy\SerializableValue($valueStrategy, $serializer, $unserializer);
172+
try
173+
{
174+
$strategy->merge($source, $destination);
175+
throw new LogicException('No expected exception');
176+
}
177+
catch (DT\Exception\InvalidData $e)
178+
{
179+
expect($e->getViolations())->toBe(DT\Exception\InvalidData::DEFAULT_VIOLATION);
180+
expect($e->getPrevious())->toBeAnInstanceOf(InvalidArgumentException::class);
181+
expect($e->getPrevious()->getMessage())->toBe(
182+
sprintf('Merge can be done only to string, not %s', get_class($destination))
183+
);
184+
}
185+
});
186+
it('delegates merge to value strategy if source is string and destination is string', function ()
187+
{
188+
$source = 'some source';
189+
$extractedSource = mock();
190+
$oldDestination = 'some old destination';
191+
$oldExtractedDestination = mock();
192+
$newDestination = 'some new destination';
193+
$newExtractedDestination = mock();
194+
$destination = $oldDestination;
195+
$valueStrategy = mock(DT\Strategy\StrategyInterface::class);
196+
$serializer = mock(Example\InvokableInterface::class);
197+
$unserializer = mock(Example\InvokableInterface::class);
198+
199+
$unserializer->shouldReceive('__invoke')->with($source)->andReturn($extractedSource)->once();
200+
$unserializer->shouldReceive('__invoke')->with($oldDestination)->andReturn($oldExtractedDestination)->once();
201+
$valueStrategy->shouldReceive('merge')->withArgs(
202+
function ($a, &$b) use (&$extractedSource, &$oldExtractedDestination, &$newExtractedDestination)
203+
{
204+
$result = ($a === $extractedSource) && ($b === $oldExtractedDestination);
205+
if ($result)
206+
{
207+
$b = $newExtractedDestination;
208+
}
209+
return $result;
210+
}
211+
)->once();
212+
$serializer->shouldReceive('__invoke')->with($newExtractedDestination)->andReturn($newDestination)->once();
213+
214+
$strategy = new DT\Strategy\SerializableValue($valueStrategy, $serializer, $unserializer);
215+
$strategy->merge($source, $destination);
216+
expect($destination)->toBe($newDestination);
217+
});
218+
});
219+
});

‎spec/Articus/DataTransfer/Validator/SerializableValue.spec.php

+65
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,65 @@
1+
<?php
2+
declare(strict_types=1);
3+
4+
use Articus\DataTransfer as DT;
5+
use spec\Example;
6+
7+
describe(DT\Validator\SerializableValue::class, function ()
8+
{
9+
describe('->validate', function ()
10+
{
11+
afterEach(function ()
12+
{
13+
Mockery::close();
14+
});
15+
it('allows null', function ()
16+
{
17+
$valueValidator = mock(DT\Validator\ValidatorInterface::class);
18+
$unserializer = mock(Example\InvokableInterface::class);
19+
20+
$validator = new DT\Validator\SerializableValue($valueValidator, $unserializer);
21+
expect($validator->validate(null))->toBe([]);
22+
});
23+
it('denies non-string', function ()
24+
{
25+
$error = [DT\Validator\SerializableValue::INVALID => 'Invalid data: expecting string.'];
26+
$valueValidator = mock(DT\Validator\ValidatorInterface::class);
27+
$unserializer = mock(Example\InvokableInterface::class);
28+
29+
$validator = new DT\Validator\SerializableValue($valueValidator, $unserializer);
30+
expect($validator->validate(true))->toBe($error);
31+
expect($validator->validate(123))->toBe($error);
32+
expect($validator->validate(123.456))->toBe($error);
33+
expect($validator->validate([]))->toBe($error);
34+
expect($validator->validate(new stdClass()))->toBe($error);
35+
});
36+
it('denies string with invalid serialized value', function ()
37+
{
38+
$data = 'some data';
39+
$value = mock();
40+
$valueError = ['aaa' => 111];
41+
$error = [DT\Validator\SerializableValue::INVALID_INNER => $valueError];
42+
$valueValidator = mock(DT\Validator\ValidatorInterface::class);
43+
$unserializer = mock(Example\InvokableInterface::class);
44+
45+
$unserializer->shouldReceive('__invoke')->with($data)->andReturn($value)->once();
46+
$valueValidator->shouldReceive('validate')->with($value)->andReturn($valueError)->once();
47+
48+
$validator = new DT\Validator\SerializableValue($valueValidator, $unserializer);
49+
expect($validator->validate($data))->toBe($error);
50+
});
51+
it('allows string with valid serialized value', function ()
52+
{
53+
$data = 'some data';
54+
$value = mock();
55+
$valueValidator = mock(DT\Validator\ValidatorInterface::class);
56+
$unserializer = mock(Example\InvokableInterface::class);
57+
58+
$unserializer->shouldReceive('__invoke')->with($data)->andReturn($value)->once();
59+
$valueValidator->shouldReceive('validate')->with($value)->andReturn([])->once();
60+
61+
$validator = new DT\Validator\SerializableValue($valueValidator, $unserializer);
62+
expect($validator->validate($data))->toBe([]);
63+
});
64+
});
65+
});

0 commit comments

Comments
 (0)