HydratorTest::testInvalidHydratorConfig() - Code Metrics - Inspection of "Improved code climate" - apparat/resource - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3ce016...a5eae9 )

by Joschi

created 2016-02-04 21:34 UTC

HydratorTest::testInvalidHydratorConfig() A

↳ Parent: HydratorTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	0

<?php

/**
 * apparat-resource
 *
 * @category    Apparat
 * @package     Apparat\Resource
 * @subpackage  Apparat\Resource\Tests
 * @author      Joschi Kuphal <[email protected]> / @jkphl
 * @copyright   Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
 * @license     http://opensource.org/licenses/MIT The MIT License (MIT)
 */

/***********************************************************************************
 *  The MIT License (MIT)
 *
 *  Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy of
 *  this software and associated documentation Fixture (the "Software"), to deal in
 *  the Software without restriction, including without limitation the rights to
 *  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 *  the Software, and to permit persons to whom the Software is furnished to do so,
 *  subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in all
 *  copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 *  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 *  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 *  IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 *  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ***********************************************************************************/

namespace Apparat\Resource\Tests;

use Apparat\Kernel\Ports\Kernel;
use Apparat\Kernel\Tests\AbstractTest;
use Apparat\Resource\Domain\Factory\HydratorFactory;
use Apparat\Resource\Domain\Model\Hydrator\HydratorInterface;
use Apparat\Resource\Domain\Model\Hydrator\InvalidArgumentException;
use Apparat\Resource\Domain\Model\Hydrator\RuntimeException;
use Apparat\Resource\Domain\Model\Part\OutOfBoundsException;
use Apparat\Resource\Infrastructure\Model\Hydrator\TextHydrator;
use Apparat\Resource\Infrastructure\Model\Part\TextPart;

/**
 * Hydrator tests
 *
 * @package     Apparat\Resource
 * @subpackage  Apparat\Resource\Tests
 */
class HydratorTest extends AbstractTest
{

    /**
     * Tears down the fixture
     */
    public function tearDown()
    {
        putenv('MOCK_VALIDATE_PARAMETERS');
        putenv('MOCK_OCCURRENCE_DEHYDRATION');
        putenv('MOCK_AGGREGATE_CLASS');
        putenv('MOCK_EMPTY_OCCURRENCE');
        putenv('MOCK_SUBHYDRATOR_NAME');
        putenv('MOCK_PART_INSTANCE');
        putenv('MOCK_OCCURRENCE_NUMBER');
        putenv('MOCK_ASSIGNMENT_PART_IDENTIFIER');
        putenv('MOCK_EMPTY_OCCURRENCE');
        putenv('MOCK_SUBHYDRATOR_NAME');
        putenv('MOCK_PART_INSTANCE');
        parent::tearDown();
    }

    /**
     * Test an invalid hydrator configuraton
     *
     * @expectedException InvalidArgumentException
     * @expectedExceptionCode 1447019565
     */
    public function testInvalidHydratorConfig()
    {
        HydratorFactory::build([]);
    }

    /**
     * Test an invalid hydrator content model configuraton
     *
     * @expectedException InvalidArgumentException
     * @expectedExceptionCode 1447020287
     */
    public function testInvalidHydratorContentModel()
    {
        HydratorFactory::build([[]]);
    }

    /**
     * Test an invalid subhydrator name
     *
     * @expectedException InvalidArgumentException
     * @expectedExceptionCode 1447364401
     */
    public function testInvalidSubhydratorNae()
    {
        HydratorFactory::build([['~' => true]]);
    }

    /**
     * Test a missing multipart hydrator
     *
     * @expectedException InvalidArgumentException
     * @expectedExceptionCode 1447107537
     */
    public function testMissingMultipartHydrator()
    {
        HydratorFactory::build([[1, 2]]);
    }

    /**
     * Test an empty multipart hydrator class
     *
     * @expectedException InvalidArgumentException
     * @expectedExceptionCode 1447107792
     */
    public function testEmptyMultipartHydratorClass()
    {
        HydratorFactory::build([[1, 2], '']);
    }

    /**
     * Test an invalid multipart hydrator class
     *
     * @expectedException InvalidArgumentException
     * @expectedExceptionCode 1447107792
     */
    public function testInvalidMultipartHydratorClass()
    {
        HydratorFactory::build([[1, 2], \stdClass::class]);
    }

    /**
     * Test invalid multipart hydrator parameters
     *
     * @expectedException InvalidArgumentException
     * @expectedExceptionCode 1447109790
     */
    public function testInvalidMultipartHydratorParameters()
    {
        putenv('MOCK_VALIDATE_PARAMETERS=1');
        HydratorFactory::build([[1, 2], AbstractSequenceHydrator::class, true]);
    }

    /**
     * Test too few multipart hydrator parameters
     *
     * @expectedException InvalidArgumentException
     * @expectedExceptionCode 1447866302
     */
    public function testTooFewMultipartHydratorParameters()
    {
        HydratorFactory::build([[1, 2], AbstractSequenceHydrator::class, 0]);
    }

    /**
     * Test invalid multipart hydrator occurrences minimum
     *
     * @expectedException \Apparat\Resource\Domain\Model\Part\InvalidArgumentException
     * @expectedExceptionCode 1447021191
     */
    public function testInvalidMultipartHydratorMinimumOccurrences()
    {
        HydratorFactory::build([[1, 2], AbstractSequenceHydrator::class, 0, 1]);
    }

    /**
     * Test invalid multipart hydrator occurrences maximum
     *
     * @expectedException \Apparat\Resource\Domain\Model\Part\InvalidArgumentException
     * @expectedExceptionCode 1447021211
     */
    public function testInvalidMultipartHydratorMaximumOccurrences()
    {
        HydratorFactory::build([[1, 2], AbstractSequenceHydrator::class, 2, 1]);
    }

    /**
     * Test an invalid multipart hydrator class
     *
     * @expectedException InvalidArgumentException
     * @expectedExceptionCode 1447868909
     */
    public function testInvalidMultipartSubhydratorClass()
    {
        HydratorFactory::build([[\stdClass::class, \stdClass::class], AbstractSequenceHydrator::class, 1, 1]);
    }

    /**
     * Test multipart hydrator
     */
    public function testMultipartHydrator()
    {
        /** @var AbstractSequenceHydrator $sequenceHydrator */
        $sequenceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractSequenceHydrator::class,
                1,
                1
            ]
        );
        $this->assertInstanceOf(AbstractSequenceHydrator::class, $sequenceHydrator);
    }

    /**
     * Test multipart hydrator name
     */
    public function testMultipartHydratorName()
    {
        /** @var AbstractSequenceHydrator $sequenceHydrator */
        $sequenceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractSequenceHydrator::class,
                1,
                1
            ]
        );
        $this->assertEquals(HydratorInterface::STANDARD, $sequenceHydrator->getName());
    }

    /**
     * Test multipart hydrator dehydration with an invalid part
     *
     * @expectedException InvalidArgumentException
     * @expectedExceptionCode 1448107001
     */
    public function testMultipartHydratorDehydrationOfInvalidPart()
    {
        /** @var TextPart $textPart */
        $textPart = Kernel::create(TextPart::class, [Kernel::create(TextHydrator::class, ['name']), '']);

        /** @var AbstractSequenceHydrator $sequenceHydrator */
        $sequenceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractSequenceHydrator::class,
                1,
                1
            ]
        );

        $sequenceHydrator->dehydrate($textPart);
    }

    /**
     * Test multipart hydrator dehydration with an invalid part
     *
     * @expectedException RuntimeException
     * @expectedExceptionCode 1448112964
     */
    public function testMultipartHydratorDehydrationWithInvalidOccurrenceDehydration()
    {
        /** @var AbstractSequenceHydrator $sequenceHydrator */
        $sequenceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractSequenceHydrator::class,
                1,
                1
            ]
        );
        $sequence = $sequenceHydrator->hydrate('one|two');

        putenv('MOCK_OCCURRENCE_DEHYDRATION=1');
        $sequenceHydrator->dehydrate($sequence);
    }

    /**
     * Test sequence hydration with invalid aggregate class
     *
     * @expectedException RuntimeException
     * @expectedExceptionCode 1447887703
     */
    public function testMultipartHydratorInvalidAggregateClass()
    {
        /** @var AbstractSequenceHydrator $sequenceHydrator */
        $sequenceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractSequenceHydrator::class,
                1,
                1
            ]
        );

        putenv('MOCK_AGGREGATE_CLASS=1');
        $sequenceHydrator->hydrate('one|two');
    }

    /**
     * Test sequence dehydration with empty occurrence
     *
     * @expectedException \Apparat\Resource\Domain\Model\Hydrator\SkippedOccurrenceDehydrationException
     * @expectedExceptionCode 1448108316
     */
    public function testMultipartHydratorSequenceEmptyOccurrence()
    {
        /** @var AbstractSequenceHydrator $sequenceHydrator */
        $sequenceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractSequenceHydrator::class,
                1,
                1
            ]
        );
        $sequence = $sequenceHydrator->hydrate('one|two');
        putenv('MOCK_EMPTY_OCCURRENCE=1');
        $sequenceHydrator->dehydrate($sequence);
    }

    /**
     * Test sequence dehydration with unknown subhydrator name
     *
     * @expectedException \Apparat\Resource\Domain\Model\Hydrator\SkippedOccurrenceDehydrationException
     * @expectedExceptionCode 1448108444
     */
    public function testMultipartHydratorSequenceInvalidSubhydratorName()
    {
        /** @var AbstractSequenceHydrator $sequenceHydrator */
        $sequenceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractSequenceHydrator::class,
                1,
                1
            ]
        );
        $sequence = $sequenceHydrator->hydrate('one|two');
        putenv('MOCK_SUBHYDRATOR_NAME=1');
        $sequenceHydrator->dehydrate($sequence);
    }

    /**
     * Test sequence dehydration with invalid part instance
     *
     * @expectedException \Apparat\Resource\Domain\Model\Hydrator\SkippedOccurrenceDehydrationException
     * @expectedExceptionCode 1448108849
     */
    public function testMultipartHydratorSequenceInvalidPartInstance()
    {
        /** @var AbstractSequenceHydrator $sequenceHydrator */
        $sequenceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractSequenceHydrator::class,
                1,
                1
            ]
        );
        $sequence = $sequenceHydrator->hydrate('one|two');
        putenv('MOCK_PART_INSTANCE=1');
        $sequenceHydrator->dehydrate($sequence);
    }

    /**
     * Test sequence part count
     */
    public function testMultipartHydratorSequenceCount()
    {
        /** @var AbstractSequenceHydrator $sequenceHydrator */
        $sequenceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractSequenceHydrator::class,
                1,
                1
            ]
        );
        $this->assertEquals(1, count($sequenceHydrator->hydrate('one|two')));
    }

    /**
     * Test invalid occurrences number
     *
     * @expectedException OutOfBoundsException
     * @expectedExceptionCode 1447976806
     */
    public function testMultipartHydratorSequenceInvalidOccurrenceNumber()
    {
        /** @var AbstractSequenceHydrator $sequenceHydrator */
        $sequenceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractSequenceHydrator::class,
                1,
                1
            ]
        );
        putenv('MOCK_OCCURRENCE_NUMBER=1');
        $sequenceHydrator->hydrate('one|two');
    }

    /**
     * Test sequence serialization
     */
    public function testMultipartHydratorSequenceSerialization()
    {
        /** @var AbstractSequenceHydrator $sequenceHydrator */
        $sequenceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractSequenceHydrator::class,
                1,
                1
            ]
        );
        $sequence = $sequenceHydrator->hydrate('one|two');
        $this->assertEquals('onetwo', strval($sequence));
    }

    /**
     * Test invalid assignment part identifier
     *
     * @expectedException InvalidArgumentException
     * @expectedExceptionCode 1447364401
     */
    public function testMultipartHydratorSequenceInvalidAssignmentPartIdentifier()
    {
        /** @var AbstractSequenceHydrator $sequenceHydrator */
        $sequenceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractSequenceHydrator::class,
                1,
                1
            ]
        );
        putenv('MOCK_ASSIGNMENT_PART_IDENTIFIER=1');
        $sequenceHydrator->hydrate('one|two');
    }

    /**
     * Test sequence unknown delegate method
     *
     * @expectedException \Apparat\Resource\Domain\Model\Part\InvalidArgumentException
     * @expectedExceptionCode 1448225222
     */
    public function testMultipartHydratorSequenceUnknownMethod()
    {
        /** @var AbstractSequenceHydrator $sequenceHydrator */
        $sequenceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractSequenceHydrator::class,
                1,
                1
            ]
        );
        $sequence = $sequenceHydrator->hydrate('one|two');
        $sequence->delegate('unknownMethod', [], []);
    }

    /**
     * Test choice dehydration with empty occurrence
     *
     * @expectedException \Apparat\Resource\Domain\Model\Hydrator\SkippedOccurrenceDehydrationException
     * @expectedExceptionCode 1448108316
     */
    public function testMultipartHydratorChoiceEmptyOccurrence()
    {
        /** @var AbstractChoiceHydrator $choiceHydrator */
        $choiceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractChoiceHydrator::class,
                1,
                1
            ]
        );
        $choice = $choiceHydrator->hydrate('one');
        putenv('MOCK_EMPTY_OCCURRENCE=1');
        $choiceHydrator->dehydrate($choice);
    }

    /**
     * Test choice dehydration with unknown subhydrator name
     *
     * @expectedException \Apparat\Resource\Domain\Model\Hydrator\SkippedOccurrenceDehydrationException
     * @expectedExceptionCode 1448108444
     */
    public function testMultipartHydratorChoiceInvalidSubhydratorName()
    {
        /** @var AbstractChoiceHydrator $choiceHydrator */
        $choiceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractChoiceHydrator::class,
                1,
                1
            ]
        );
        $choice = $choiceHydrator->hydrate('one');
        putenv('MOCK_SUBHYDRATOR_NAME=1');
        $choiceHydrator->dehydrate($choice);
    }

    /**
     * Test choice dehydration with invalid part instance
     *
     * @expectedException \Apparat\Resource\Domain\Model\Hydrator\SkippedOccurrenceDehydrationException
     * @expectedExceptionCode 1448108849
     */
    public function testMultipartHydratorChoiceInvalidPartInstance()
    {
        /** @var AbstractChoiceHydrator $choiceHydrator */
        $choiceHydrator = HydratorFactory::build(
            [
                [TextHydrator::class, TextHydrator::class],
                AbstractChoiceHydrator::class,
                1,
                1
            ]
        );
        $choice = $choiceHydrator->hydrate('one');
        putenv('MOCK_PART_INSTANCE=1');
        $choiceHydrator->dehydrate($choice);
    }

    /**
     * Test an invalid singlepart hydrator class
     *
     * @expectedException InvalidArgumentException
     * @expectedExceptionCode 1447110065
     */
    public function testInvalidSinglepartHydratorClass()
    {
        HydratorFactory::build([[HydratorInterface::STANDARD => \stdClass::class]]);
    }

    /**
     * Test the text hydrator (short form)
     */
    public function testTextHydratorShort()
    {
        $textHydrator = HydratorFactory::build([TextHydrator::class]);
        $this->assertInstanceOf(TextHydrator::class, $textHydrator);
    }

    /**
     * Test the text hydrator (verbose form)
     */
    public function testTextHydratorVerbose()
    {
        $textHydrator = HydratorFactory::build([[HydratorInterface::STANDARD => TextHydrator::class]]);
        $this->assertInstanceOf(TextHydrator::class, $textHydrator);
    }

    /**
     * Test the text hydrator name
     */
    public function testTextHydratorName()
    {
        $textHydrator = HydratorFactory::build([[HydratorInterface::STANDARD => TextHydrator::class]]);
        $this->assertEquals(HydratorInterface::STANDARD, $textHydrator->getName());
    }
}


1			<?php
2
3			/**
4			* apparat-resource
5			*
6			* @category Apparat
7			* @package Apparat\Resource
8			* @subpackage Apparat\Resource\Tests
9			* @author Joschi Kuphal <[email protected]> / @jkphl
10			* @copyright Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
11			* @license http://opensource.org/licenses/MIT The MIT License (MIT)
12			*/
13
14			/***********************************************************************************
15			* The MIT License (MIT)
16			*
17			* Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
18			*
19			* Permission is hereby granted, free of charge, to any person obtaining a copy of
20			* this software and associated documentation Fixture (the "Software"), to deal in
21			* the Software without restriction, including without limitation the rights to
22			* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
23			* the Software, and to permit persons to whom the Software is furnished to do so,
24			* subject to the following conditions:
25			*
26			* The above copyright notice and this permission notice shall be included in all
27			* copies or substantial portions of the Software.
28			*
29			* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
30			* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
31			* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
32			* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
33			* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
34			* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35			***********************************************************************************/
36
37			namespace Apparat\Resource\Tests;
38
39			use Apparat\Kernel\Ports\Kernel;
40			use Apparat\Kernel\Tests\AbstractTest;
41			use Apparat\Resource\Domain\Factory\HydratorFactory;
42			use Apparat\Resource\Domain\Model\Hydrator\HydratorInterface;
43			use Apparat\Resource\Domain\Model\Hydrator\InvalidArgumentException;
44			use Apparat\Resource\Domain\Model\Hydrator\RuntimeException;
45			use Apparat\Resource\Domain\Model\Part\OutOfBoundsException;
46			use Apparat\Resource\Infrastructure\Model\Hydrator\TextHydrator;
47			use Apparat\Resource\Infrastructure\Model\Part\TextPart;
48
49			/**
50			* Hydrator tests
51			*
52			* @package Apparat\Resource
53			* @subpackage Apparat\Resource\Tests
54			*/
55			class HydratorTest extends AbstractTest
56			{
57
58			/**
59			* Tears down the fixture
60			*/
61			public function tearDown()
62			{
63			putenv('MOCK_VALIDATE_PARAMETERS');
64			putenv('MOCK_OCCURRENCE_DEHYDRATION');
65			putenv('MOCK_AGGREGATE_CLASS');
66			putenv('MOCK_EMPTY_OCCURRENCE');
67			putenv('MOCK_SUBHYDRATOR_NAME');
68			putenv('MOCK_PART_INSTANCE');
69			putenv('MOCK_OCCURRENCE_NUMBER');
70			putenv('MOCK_ASSIGNMENT_PART_IDENTIFIER');
71			putenv('MOCK_EMPTY_OCCURRENCE');
72			putenv('MOCK_SUBHYDRATOR_NAME');
73			putenv('MOCK_PART_INSTANCE');
74			parent::tearDown();
75			}
76
77			/**
78			* Test an invalid hydrator configuraton
79			*
80			* @expectedException InvalidArgumentException
81			* @expectedExceptionCode 1447019565
82			*/
83			public function testInvalidHydratorConfig()
84			{
85			HydratorFactory::build([]);
86			}
87
88			/**
89			* Test an invalid hydrator content model configuraton
90			*
91			* @expectedException InvalidArgumentException
92			* @expectedExceptionCode 1447020287
93			*/
94			public function testInvalidHydratorContentModel()
95			{
96			HydratorFactory::build([[]]);
97			}
98
99			/**
100			* Test an invalid subhydrator name
101			*
102			* @expectedException InvalidArgumentException
103			* @expectedExceptionCode 1447364401
104			*/
105			public function testInvalidSubhydratorNae()
106			{
107			HydratorFactory::build([['~' => true]]);
108			}
109
110			/**
111			* Test a missing multipart hydrator
112			*
113			* @expectedException InvalidArgumentException
114			* @expectedExceptionCode 1447107537
115			*/
116			public function testMissingMultipartHydrator()
117			{
118			HydratorFactory::build([[1, 2]]);
119			}
120
121			/**
122			* Test an empty multipart hydrator class
123			*
124			* @expectedException InvalidArgumentException
125			* @expectedExceptionCode 1447107792
126			*/
127			public function testEmptyMultipartHydratorClass()
128			{
129			HydratorFactory::build([[1, 2], '']);
130			}
131
132			/**
133			* Test an invalid multipart hydrator class
134			*
135			* @expectedException InvalidArgumentException
136			* @expectedExceptionCode 1447107792
137			*/
138			public function testInvalidMultipartHydratorClass()
139			{
140			HydratorFactory::build([[1, 2], \stdClass::class]);
141			}
142
143			/**
144			* Test invalid multipart hydrator parameters
145			*
146			* @expectedException InvalidArgumentException
147			* @expectedExceptionCode 1447109790
148			*/
149			public function testInvalidMultipartHydratorParameters()
150			{
151			putenv('MOCK_VALIDATE_PARAMETERS=1');
152			HydratorFactory::build([[1, 2], AbstractSequenceHydrator::class, true]);
153			}
154
155			/**
156			* Test too few multipart hydrator parameters
157			*
158			* @expectedException InvalidArgumentException
159			* @expectedExceptionCode 1447866302
160			*/
161			public function testTooFewMultipartHydratorParameters()
162			{
163			HydratorFactory::build([[1, 2], AbstractSequenceHydrator::class, 0]);
164			}
165
166			/**
167			* Test invalid multipart hydrator occurrences minimum
168			*
169			* @expectedException \Apparat\Resource\Domain\Model\Part\InvalidArgumentException
170			* @expectedExceptionCode 1447021191
171			*/
172			public function testInvalidMultipartHydratorMinimumOccurrences()
173			{
174			HydratorFactory::build([[1, 2], AbstractSequenceHydrator::class, 0, 1]);
175			}
176
177			/**
178			* Test invalid multipart hydrator occurrences maximum
179			*
180			* @expectedException \Apparat\Resource\Domain\Model\Part\InvalidArgumentException
181			* @expectedExceptionCode 1447021211
182			*/
183			public function testInvalidMultipartHydratorMaximumOccurrences()
184			{
185			HydratorFactory::build([[1, 2], AbstractSequenceHydrator::class, 2, 1]);
186			}
187
188			/**
189			* Test an invalid multipart hydrator class
190			*
191			* @expectedException InvalidArgumentException
192			* @expectedExceptionCode 1447868909
193			*/
194			public function testInvalidMultipartSubhydratorClass()
195			{
196			HydratorFactory::build([[\stdClass::class, \stdClass::class], AbstractSequenceHydrator::class, 1, 1]);
197			}
198
199			/**
200			* Test multipart hydrator
201			*/
202			public function testMultipartHydrator()
203			{
204			/** @var AbstractSequenceHydrator $sequenceHydrator */
205			$sequenceHydrator = HydratorFactory::build(
206			[
207			[TextHydrator::class, TextHydrator::class],
208			AbstractSequenceHydrator::class,
209			1,
210			1
211			]
212			);
213			$this->assertInstanceOf(AbstractSequenceHydrator::class, $sequenceHydrator);
214			}
215
216			/**
217			* Test multipart hydrator name
218			*/
219			public function testMultipartHydratorName()
220			{
221			/** @var AbstractSequenceHydrator $sequenceHydrator */
222			$sequenceHydrator = HydratorFactory::build(
223			[
224			[TextHydrator::class, TextHydrator::class],
225			AbstractSequenceHydrator::class,
226			1,
227			1
228			]
229			);
230			$this->assertEquals(HydratorInterface::STANDARD, $sequenceHydrator->getName());
231			}
232
233			/**
234			* Test multipart hydrator dehydration with an invalid part
235			*
236			* @expectedException InvalidArgumentException
237			* @expectedExceptionCode 1448107001
238			*/
239			public function testMultipartHydratorDehydrationOfInvalidPart()
240			{
241			/** @var TextPart $textPart */
242			$textPart = Kernel::create(TextPart::class, [Kernel::create(TextHydrator::class, ['name']), '']);
243
244			/** @var AbstractSequenceHydrator $sequenceHydrator */
245			$sequenceHydrator = HydratorFactory::build(
246			[
247			[TextHydrator::class, TextHydrator::class],
248			AbstractSequenceHydrator::class,
249			1,
250			1
251			]
252			);
253
254			$sequenceHydrator->dehydrate($textPart);
255			}
256
257			/**
258			* Test multipart hydrator dehydration with an invalid part
259			*
260			* @expectedException RuntimeException
261			* @expectedExceptionCode 1448112964
262			*/
263			public function testMultipartHydratorDehydrationWithInvalidOccurrenceDehydration()
264			{
265			/** @var AbstractSequenceHydrator $sequenceHydrator */
266			$sequenceHydrator = HydratorFactory::build(
267			[
268			[TextHydrator::class, TextHydrator::class],
269			AbstractSequenceHydrator::class,
270			1,
271			1
272			]
273			);
274			$sequence = $sequenceHydrator->hydrate('one\|two');
275
276			putenv('MOCK_OCCURRENCE_DEHYDRATION=1');
277			$sequenceHydrator->dehydrate($sequence);
278			}
279
280			/**
281			* Test sequence hydration with invalid aggregate class
282			*
283			* @expectedException RuntimeException
284			* @expectedExceptionCode 1447887703
285			*/
286			public function testMultipartHydratorInvalidAggregateClass()
287			{
288			/** @var AbstractSequenceHydrator $sequenceHydrator */
289			$sequenceHydrator = HydratorFactory::build(
290			[
291			[TextHydrator::class, TextHydrator::class],
292			AbstractSequenceHydrator::class,
293			1,
294			1
295			]
296			);
297
298			putenv('MOCK_AGGREGATE_CLASS=1');
299			$sequenceHydrator->hydrate('one\|two');
300			}
301
302			/**
303			* Test sequence dehydration with empty occurrence
304			*
305			* @expectedException \Apparat\Resource\Domain\Model\Hydrator\SkippedOccurrenceDehydrationException
306			* @expectedExceptionCode 1448108316
307			*/
308			public function testMultipartHydratorSequenceEmptyOccurrence()
309			{
310			/** @var AbstractSequenceHydrator $sequenceHydrator */
311			$sequenceHydrator = HydratorFactory::build(
312			[
313			[TextHydrator::class, TextHydrator::class],
314			AbstractSequenceHydrator::class,
315			1,
316			1
317			]
318			);
319			$sequence = $sequenceHydrator->hydrate('one\|two');
320			putenv('MOCK_EMPTY_OCCURRENCE=1');
321			$sequenceHydrator->dehydrate($sequence);
322			}
323
324			/**
325			* Test sequence dehydration with unknown subhydrator name
326			*
327			* @expectedException \Apparat\Resource\Domain\Model\Hydrator\SkippedOccurrenceDehydrationException
328			* @expectedExceptionCode 1448108444
329			*/
330			public function testMultipartHydratorSequenceInvalidSubhydratorName()
331			{
332			/** @var AbstractSequenceHydrator $sequenceHydrator */
333			$sequenceHydrator = HydratorFactory::build(
334			[
335			[TextHydrator::class, TextHydrator::class],
336			AbstractSequenceHydrator::class,
337			1,
338			1
339			]
340			);
341			$sequence = $sequenceHydrator->hydrate('one\|two');
342			putenv('MOCK_SUBHYDRATOR_NAME=1');
343			$sequenceHydrator->dehydrate($sequence);
344			}
345
346			/**
347			* Test sequence dehydration with invalid part instance
348			*
349			* @expectedException \Apparat\Resource\Domain\Model\Hydrator\SkippedOccurrenceDehydrationException
350			* @expectedExceptionCode 1448108849
351			*/
352			public function testMultipartHydratorSequenceInvalidPartInstance()
353			{
354			/** @var AbstractSequenceHydrator $sequenceHydrator */
355			$sequenceHydrator = HydratorFactory::build(
356			[
357			[TextHydrator::class, TextHydrator::class],
358			AbstractSequenceHydrator::class,
359			1,
360			1
361			]
362			);
363			$sequence = $sequenceHydrator->hydrate('one\|two');
364			putenv('MOCK_PART_INSTANCE=1');
365			$sequenceHydrator->dehydrate($sequence);
366			}
367
368			/**
369			* Test sequence part count
370			*/
371			public function testMultipartHydratorSequenceCount()
372			{
373			/** @var AbstractSequenceHydrator $sequenceHydrator */
374			$sequenceHydrator = HydratorFactory::build(
375			[
376			[TextHydrator::class, TextHydrator::class],
377			AbstractSequenceHydrator::class,
378			1,
379			1
380			]
381			);
382			$this->assertEquals(1, count($sequenceHydrator->hydrate('one\|two')));
383			}
384
385			/**
386			* Test invalid occurrences number
387			*
388			* @expectedException OutOfBoundsException
389			* @expectedExceptionCode 1447976806
390			*/
391			public function testMultipartHydratorSequenceInvalidOccurrenceNumber()
392			{
393			/** @var AbstractSequenceHydrator $sequenceHydrator */
394			$sequenceHydrator = HydratorFactory::build(
395			[
396			[TextHydrator::class, TextHydrator::class],
397			AbstractSequenceHydrator::class,
398			1,
399			1
400			]
401			);
402			putenv('MOCK_OCCURRENCE_NUMBER=1');
403			$sequenceHydrator->hydrate('one\|two');
404			}
405
406			/**
407			* Test sequence serialization
408			*/
409			public function testMultipartHydratorSequenceSerialization()
410			{
411			/** @var AbstractSequenceHydrator $sequenceHydrator */
412			$sequenceHydrator = HydratorFactory::build(
413			[
414			[TextHydrator::class, TextHydrator::class],
415			AbstractSequenceHydrator::class,
416			1,
417			1
418			]
419			);
420			$sequence = $sequenceHydrator->hydrate('one\|two');
421			$this->assertEquals('onetwo', strval($sequence));
422			}
423
424			/**
425			* Test invalid assignment part identifier
426			*
427			* @expectedException InvalidArgumentException
428			* @expectedExceptionCode 1447364401
429			*/
430			public function testMultipartHydratorSequenceInvalidAssignmentPartIdentifier()
431			{
432			/** @var AbstractSequenceHydrator $sequenceHydrator */
433			$sequenceHydrator = HydratorFactory::build(
434			[
435			[TextHydrator::class, TextHydrator::class],
436			AbstractSequenceHydrator::class,
437			1,
438			1
439			]
440			);
441			putenv('MOCK_ASSIGNMENT_PART_IDENTIFIER=1');
442			$sequenceHydrator->hydrate('one\|two');
443			}
444
445			/**
446			* Test sequence unknown delegate method
447			*
448			* @expectedException \Apparat\Resource\Domain\Model\Part\InvalidArgumentException
449			* @expectedExceptionCode 1448225222
450			*/
451			public function testMultipartHydratorSequenceUnknownMethod()
452			{
453			/** @var AbstractSequenceHydrator $sequenceHydrator */
454			$sequenceHydrator = HydratorFactory::build(
455			[
456			[TextHydrator::class, TextHydrator::class],
457			AbstractSequenceHydrator::class,
458			1,
459			1
460			]
461			);
462			$sequence = $sequenceHydrator->hydrate('one\|two');
463			$sequence->delegate('unknownMethod', [], []);
464			}
465
466			/**
467			* Test choice dehydration with empty occurrence
468			*
469			* @expectedException \Apparat\Resource\Domain\Model\Hydrator\SkippedOccurrenceDehydrationException
470			* @expectedExceptionCode 1448108316
471			*/
472			public function testMultipartHydratorChoiceEmptyOccurrence()
473			{
474			/** @var AbstractChoiceHydrator $choiceHydrator */
475			$choiceHydrator = HydratorFactory::build(
476			[
477			[TextHydrator::class, TextHydrator::class],
478			AbstractChoiceHydrator::class,
479			1,
480			1
481			]
482			);
483			$choice = $choiceHydrator->hydrate('one');
484			putenv('MOCK_EMPTY_OCCURRENCE=1');
485			$choiceHydrator->dehydrate($choice);
486			}
487
488			/**
489			* Test choice dehydration with unknown subhydrator name
490			*
491			* @expectedException \Apparat\Resource\Domain\Model\Hydrator\SkippedOccurrenceDehydrationException
492			* @expectedExceptionCode 1448108444
493			*/
494			public function testMultipartHydratorChoiceInvalidSubhydratorName()
495			{
496			/** @var AbstractChoiceHydrator $choiceHydrator */
497			$choiceHydrator = HydratorFactory::build(
498			[
499			[TextHydrator::class, TextHydrator::class],
500			AbstractChoiceHydrator::class,
501			1,
502			1
503			]
504			);
505			$choice = $choiceHydrator->hydrate('one');
506			putenv('MOCK_SUBHYDRATOR_NAME=1');
507			$choiceHydrator->dehydrate($choice);
508			}
509
510			/**
511			* Test choice dehydration with invalid part instance
512			*
513			* @expectedException \Apparat\Resource\Domain\Model\Hydrator\SkippedOccurrenceDehydrationException
514			* @expectedExceptionCode 1448108849
515			*/
516			public function testMultipartHydratorChoiceInvalidPartInstance()
517			{
518			/** @var AbstractChoiceHydrator $choiceHydrator */
519			$choiceHydrator = HydratorFactory::build(
520			[
521			[TextHydrator::class, TextHydrator::class],
522			AbstractChoiceHydrator::class,
523			1,
524			1
525			]
526			);
527			$choice = $choiceHydrator->hydrate('one');
528			putenv('MOCK_PART_INSTANCE=1');
529			$choiceHydrator->dehydrate($choice);
530			}
531
532			/**
533			* Test an invalid singlepart hydrator class
534			*
535			* @expectedException InvalidArgumentException
536			* @expectedExceptionCode 1447110065
537			*/
538			public function testInvalidSinglepartHydratorClass()
539			{
540			HydratorFactory::build([[HydratorInterface::STANDARD => \stdClass::class]]);
541			}
542
543			/**
544			* Test the text hydrator (short form)
545			*/
546			public function testTextHydratorShort()
547			{
548			$textHydrator = HydratorFactory::build([TextHydrator::class]);
549			$this->assertInstanceOf(TextHydrator::class, $textHydrator);
550			}
551
552			/**
553			* Test the text hydrator (verbose form)
554			*/
555			public function testTextHydratorVerbose()
556			{
557			$textHydrator = HydratorFactory::build([[HydratorInterface::STANDARD => TextHydrator::class]]);
558			$this->assertInstanceOf(TextHydrator::class, $textHydrator);
559			}
560
561			/**
562			* Test the text hydrator name
563			*/
564			public function testTextHydratorName()
565			{
566			$textHydrator = HydratorFactory::build([[HydratorInterface::STANDARD => TextHydrator::class]]);
567			$this->assertEquals(HydratorInterface::STANDARD, $textHydrator->getName());
568			}
569			}
570

apparat / resource

Push — master ( 3ce016...a5eae9 )

HydratorTest::testInvalidHydratorConfig() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like