WorkflowTest::testWorkflowWithObjects() - Code Metrics - ddeboer/data-import - Measure and Improve Code Quality continuously with Scrutinizer

WorkflowTest::testWorkflowWithObjects() B
last analyzed 2017-08-31 09:23 UTC

↳ Parent: WorkflowTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	30
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	30
rs	8.8571
c	0
b	0
f	0
cc	1
eloc	20
nc	1
nop	0

<?php

namespace Ddeboer\DataImport\Tests;

use Ddeboer\DataImport\Exception\WriterException;
use Ddeboer\DataImport\Reader\ArrayReader;
use Ddeboer\DataImport\Step\ConverterStep;
use Ddeboer\DataImport\Step\FilterStep;
use Ddeboer\DataImport\Step\MappingStep;
use Ddeboer\DataImport\Step\ValueConverterStep;
use Ddeboer\DataImport\Writer\ArrayWriter;
use Ddeboer\DataImport\Workflow\StepAggregator;
use Ddeboer\DataImport\Filter\CallbackFilter;
use Ddeboer\DataImport\ValueConverter\CallbackValueConverter;
use Ddeboer\DataImport\ItemConverter\CallbackItemConverter;
use Ddeboer\DataImport\Writer\CallbackWriter;
use Ddeboer\DataImport\Exception\SourceNotFoundException;

class WorkflowTest extends \PHPUnit_Framework_TestCase
{
    public function testAddStep()
    {
        $step = $this->getMock('Ddeboer\DataImport\Step');

        $this->getWorkflow()->addStep($step);
    }

    public function testAddCallbackWriter()
    {
        $this->getWorkflow()->addWriter(new CallbackWriter(function($item) {

//            var_dump($item);
        }));
    }

    public function testWriterIsPreparedAndFinished()
    {
        $writer = $this->getMockBuilder('\Ddeboer\DataImport\Writer\CallbackWriter')
            ->disableOriginalConstructor()
            ->getMock();

        $writer->expects($this->once())
            ->method('prepare');

        $writer->expects($this->once())
            ->method('finish');

        $this->getWorkflow()->addWriter($writer)
            ->process();
    }

    public function testWorkflowWithObjects()
    {
        $reader = new ArrayReader(array(
            new Dummy('foo'),
            new Dummy('bar'),
            new Dummy('foobar'),
        ));

        $data = array();
        $writer = new ArrayWriter($data);

        $workflow = new StepAggregator($reader);
        $workflow->addWriter($writer);

        $converterStep = new ConverterStep([
            function($item) { return array('name' => $item->name); }
        ]);

        $valueStep = new ValueConverterStep();
        $valueStep->add('[name]', function($name) { return strrev($name); });

        $workflow->addStep($converterStep)->addStep($valueStep);
        $workflow->process();

        $this->assertEquals(array(
            array('name' => 'oof'),
            array('name' => 'rab'),
            array('name' => 'raboof')
        ), $data);
    }

    /**
     * @expectedException \Ddeboer\DataImport\Exception\UnexpectedTypeException
     */
    public function testItemConverterWhichReturnObjects()
    {
        $reader = new ArrayReader(array(
            new Dummy('foo'),
            new Dummy('bar'),
            new Dummy('foobar'),
        ));

        $data = array();
        $writer = new ArrayWriter($data);

        $workflow = new StepAggregator($reader);
        $workflow->addWriter($writer);

        $converterStep = new ConverterStep();
        $converterStep->add(function($item) { return $item; });

        $workflow->addStep($converterStep)->process();
    }

    /**
     * @expectedException \Ddeboer\DataImport\Exception\UnexpectedTypeException
     */
    public function testItemConverterWithObjectsAndNoItemConverters()
    {
        $reader = new ArrayReader(array(
            new Dummy('foo'),
            new Dummy('bar'),
            new Dummy('foobar'),
        ));

        $data = array();
        $writer = new ArrayWriter($data);

        $workflow = new StepAggregator($reader);
        $workflow->addWriter($writer);

        $workflow->process();
    }

    public function testFilterPriority()
    {
        $offsetFilter = $this->getMockBuilder('\Ddeboer\DataImport\Filter\OffsetFilter')
            ->disableOriginalConstructor()
            ->setMethods(array('__invoke'))
            ->getMock();
        $offsetFilter->expects($this->never())->method('filter');

        $validatorFilter = $this->getMockBuilder('\Ddeboer\DataImport\Filter\ValidatorFilter')
            ->disableOriginalConstructor()
            ->setMethods(array('__invoke'))
            ->getMock();
        $validatorFilter->expects($this->exactly(3))
            ->method('__invoke')
            ->will($this->returnValue(false));

        $filterStep = (new FilterStep())
            ->add($offsetFilter)
            ->add($validatorFilter);

        $this->getWorkflow()
            ->addStep($filterStep)
            ->process();
    }

    public function testFilterPriorityOverride()
    {
        $offsetFilter = $this->getMockBuilder('\Ddeboer\DataImport\Filter\OffsetFilter')
            ->disableOriginalConstructor()
            ->setMethods(array('__invoke'))
            ->getMock();
        $offsetFilter->expects($this->exactly(3))
            ->method('__invoke')
            ->will($this->returnValue(false));

        $validatorFilter = $this->getMockBuilder('\Ddeboer\DataImport\Filter\ValidatorFilter')
            ->disableOriginalConstructor()
            ->setMethods(array('__invoke'))
            ->getMock();
        $validatorFilter->expects($this->never())->method('filter');

        $filterStep = (new FilterStep())
            ->add($offsetFilter, 257)
            ->add($validatorFilter);

        $this->getWorkflow()
            ->addStep($filterStep)
            ->process();
    }

    public function testExceptionInterfaceThrownFromWriterIsCaught()
    {
        $originalData = array(array('foo' => 'bar'));
        $reader = new ArrayReader($originalData);

        $array = array();
        $writer = $this->getMock('Ddeboer\DataImport\Writer\ArrayWriter', array(), array(&$array));

        $exception = new SourceNotFoundException("Log me!");

        $writer->expects($this->once())
            ->method('writeItem')
            ->with($originalData[0])
            ->will($this->throwException($exception));

        $logger = $this->getMock('Psr\Log\LoggerInterface');
        $logger->expects($this->once())
            ->method('error')
            ->with($exception->getMessage());


        $workflow = new StepAggregator($reader);
        $workflow->setLogger($logger);
        $workflow->setSkipItemOnFailure(true);
        $workflow->addWriter($writer);
        $workflow->process();
    }

    public function testWorkflowResultWhenAllSuccessful()
    {
        $workflow   = $this->getWorkflow();
        $result     = $workflow->process();

        $this->assertInstanceOf('Ddeboer\DataImport\Result', $result);
        $this->assertInstanceOf('DateTime', $result->getStartTime());
        $this->assertInstanceOf('DateTime', $result->getEndTime());
        $this->assertInstanceOf('DateInterval', $result->getElapsed());
        $this->assertInstanceOf('Ddeboer\DataImport\Result', $result);
        $this->assertSame(3, $result->getTotalProcessedCount());
        $this->assertSame(3, $result->getSuccessCount());
        $this->assertSame(0, $result->getErrorCount());
        $this->assertFalse($result->hasErrors());
        $this->assertEmpty($result->getExceptions());
        $this->assertSame(null, $result->getName());
    }

    public function testMultipleMappingsForAnItemAfterAnotherItemConverterwasAdded()
    {
        $originalData = array(array('foo' => 'bar', 'baz' => 'value'));

        $outputTestData = array();

        $writer = new ArrayWriter($outputTestData);
        $reader = new ArrayReader($originalData);

        $workflow = new StepAggregator($reader);

        $converterStep = new ConverterStep();

        // add a dummy item converter
        $converterStep->add(function($item) { return $item; });

        $mappingStep = (new MappingStep())
            ->map('[foo]', '[bar]')
            ->map('[baz]', '[bazzoo]');

        // add multiple mappings
        $workflow
            ->addStep($converterStep)
            ->addStep($mappingStep)
            ->addWriter($writer)
            ->process()
        ;

        $this->assertArrayHasKey('bar', $outputTestData[0]);
        $this->assertArrayHasKey('bazzoo', $outputTestData[0]);
    }

    public function _testWorkflowResultWithExceptionThrowFromWriter()
    {
        $workflow   = $this->getWorkflow();
        $workflow->setSkipItemOnFailure(true);
        $writer     = $this->getMock('Ddeboer\DataImport\Writer\WriterInterface');

        $e = new WriterException();

        $writer
            ->expects($this->at(1))
            ->method('writeItem')
            ->with(array('first' => 'James', 'last'  => 'Bond'))
            ->will($this->throwException($e));

        $workflow->addWriter($writer);
        $result = $workflow->process();

        $this->assertInstanceOf('Ddeboer\DataImport\Result', $result);
        $this->assertInstanceOf('DateTime', $result->getStartTime());
        $this->assertInstanceOf('DateTime', $result->getEndTime());
        $this->assertInstanceOf('DateInterval', $result->getElapsed());
        $this->assertInstanceOf('Ddeboer\DataImport\Result', $result);
        $this->assertSame(3, $result->getTotalProcessedCount());
        $this->assertSame(2, $result->getSuccessCount());
        $this->assertSame(1, $result->getErrorCount());
        $this->assertTrue($result->hasErrors());
        $this->assertSame(array($e), iterator_to_array($result->getExceptions()));
        $this->assertSame(null, $result->getName());
    }

    protected function getWorkflow()
    {
        $reader = new ArrayReader(array(
            array(
                'first' => 'James',
                'last'  => 'Bond'
            ),
            array(
                'first' => 'Miss',
                'last'  => 'Moneypenny'
            ),
            array(
                'first' => null,
                'last'  => 'Doe'
            )
        ));

        return new StepAggregator($reader);
    }
}

class Dummy
{
    public $name;

    public function __construct($name)
    {
        $this->name = $name;
    }
}


1			<?php
2
3			namespace Ddeboer\DataImport\Tests;
4
5			use Ddeboer\DataImport\Exception\WriterException;
6			use Ddeboer\DataImport\Reader\ArrayReader;
7			use Ddeboer\DataImport\Step\ConverterStep;
8			use Ddeboer\DataImport\Step\FilterStep;
9			use Ddeboer\DataImport\Step\MappingStep;
10			use Ddeboer\DataImport\Step\ValueConverterStep;
11			use Ddeboer\DataImport\Writer\ArrayWriter;
12			use Ddeboer\DataImport\Workflow\StepAggregator;
13			use Ddeboer\DataImport\Filter\CallbackFilter;
14			use Ddeboer\DataImport\ValueConverter\CallbackValueConverter;
15			use Ddeboer\DataImport\ItemConverter\CallbackItemConverter;
16			use Ddeboer\DataImport\Writer\CallbackWriter;
17			use Ddeboer\DataImport\Exception\SourceNotFoundException;
18
19			class WorkflowTest extends \PHPUnit_Framework_TestCase
20			{
21			public function testAddStep()
22			{
23			$step = $this->getMock('Ddeboer\DataImport\Step');
24
25			$this->getWorkflow()->addStep($step);
26			}
27
28			public function testAddCallbackWriter()
29			{
30			$this->getWorkflow()->addWriter(new CallbackWriter(function($item) {
			0 ignored issues – show Unused Code introduced 2015-12-09 23:34 UTC by Report Bug Copy Issue Report The parameter `$item` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
31			// var_dump($item);
32			}));
33			}
34
35			public function testWriterIsPreparedAndFinished()
36			{
37			$writer = $this->getMockBuilder('\Ddeboer\DataImport\Writer\CallbackWriter')
38			->disableOriginalConstructor()
39			->getMock();
40
41			$writer->expects($this->once())
42			->method('prepare');
43
44			$writer->expects($this->once())
45			->method('finish');
46
47			$this->getWorkflow()->addWriter($writer)
48			->process();
49			}
50
51			public function testWorkflowWithObjects()
52			{
53			$reader = new ArrayReader(array(
54			new Dummy('foo'),
55			new Dummy('bar'),
56			new Dummy('foobar'),
57			));
58
59			$data = array();
60			$writer = new ArrayWriter($data);
61
62			$workflow = new StepAggregator($reader);
63			$workflow->addWriter($writer);
64
65			$converterStep = new ConverterStep([
66			function($item) { return array('name' => $item->name); }
67			]);
68
69			$valueStep = new ValueConverterStep();
70			$valueStep->add('[name]', function($name) { return strrev($name); });
71
72			$workflow->addStep($converterStep)->addStep($valueStep);
73			$workflow->process();
74
75			$this->assertEquals(array(
76			array('name' => 'oof'),
77			array('name' => 'rab'),
78			array('name' => 'raboof')
79			), $data);
80			}
81
82			/**
83			* @expectedException \Ddeboer\DataImport\Exception\UnexpectedTypeException
84			*/
85			public function testItemConverterWhichReturnObjects()
86			{
87			$reader = new ArrayReader(array(
88			new Dummy('foo'),
89			new Dummy('bar'),
90			new Dummy('foobar'),
91			));
92
93			$data = array();
94			$writer = new ArrayWriter($data);
95
96			$workflow = new StepAggregator($reader);
97			$workflow->addWriter($writer);
98
99			$converterStep = new ConverterStep();
100			$converterStep->add(function($item) { return $item; });
101
102			$workflow->addStep($converterStep)->process();
103			}
104
105			/**
106			* @expectedException \Ddeboer\DataImport\Exception\UnexpectedTypeException
107			*/
108			public function testItemConverterWithObjectsAndNoItemConverters()
109			{
110			$reader = new ArrayReader(array(
111			new Dummy('foo'),
112			new Dummy('bar'),
113			new Dummy('foobar'),
114			));
115
116			$data = array();
117			$writer = new ArrayWriter($data);
118
119			$workflow = new StepAggregator($reader);
120			$workflow->addWriter($writer);
121
122			$workflow->process();
123			}
124
125			public function testFilterPriority()
126			{
127			$offsetFilter = $this->getMockBuilder('\Ddeboer\DataImport\Filter\OffsetFilter')
128			->disableOriginalConstructor()
129			->setMethods(array('__invoke'))
130			->getMock();
131			$offsetFilter->expects($this->never())->method('filter');
132
133			$validatorFilter = $this->getMockBuilder('\Ddeboer\DataImport\Filter\ValidatorFilter')
134			->disableOriginalConstructor()
135			->setMethods(array('__invoke'))
136			->getMock();
137			$validatorFilter->expects($this->exactly(3))
138			->method('__invoke')
139			->will($this->returnValue(false));
140
141			$filterStep = (new FilterStep())
142			->add($offsetFilter)
143			->add($validatorFilter);
144
145			$this->getWorkflow()
146			->addStep($filterStep)
147			->process();
148			}
149
150			public function testFilterPriorityOverride()
151			{
152			$offsetFilter = $this->getMockBuilder('\Ddeboer\DataImport\Filter\OffsetFilter')
153			->disableOriginalConstructor()
154			->setMethods(array('__invoke'))
155			->getMock();
156			$offsetFilter->expects($this->exactly(3))
157			->method('__invoke')
158			->will($this->returnValue(false));
159
160			$validatorFilter = $this->getMockBuilder('\Ddeboer\DataImport\Filter\ValidatorFilter')
161			->disableOriginalConstructor()
162			->setMethods(array('__invoke'))
163			->getMock();
164			$validatorFilter->expects($this->never())->method('filter');
165
166			$filterStep = (new FilterStep())
167			->add($offsetFilter, 257)
168			->add($validatorFilter);
169
170			$this->getWorkflow()
171			->addStep($filterStep)
172			->process();
173			}
174
175			public function testExceptionInterfaceThrownFromWriterIsCaught()
176			{
177			$originalData = array(array('foo' => 'bar'));
178			$reader = new ArrayReader($originalData);
179
180			$array = array();
181			$writer = $this->getMock('Ddeboer\DataImport\Writer\ArrayWriter', array(), array(&$array));
182
183			$exception = new SourceNotFoundException("Log me!");
184
185			$writer->expects($this->once())
186			->method('writeItem')
187			->with($originalData[0])
188			->will($this->throwException($exception));
189
190			$logger = $this->getMock('Psr\Log\LoggerInterface');
191			$logger->expects($this->once())
192			->method('error')
193			->with($exception->getMessage());
194
195
196			$workflow = new StepAggregator($reader);
197			$workflow->setLogger($logger);
198			$workflow->setSkipItemOnFailure(true);
199			$workflow->addWriter($writer);
200			$workflow->process();
201			}
202
203			public function testWorkflowResultWhenAllSuccessful()
204			{
205			$workflow = $this->getWorkflow();
206			$result = $workflow->process();
207
208			$this->assertInstanceOf('Ddeboer\DataImport\Result', $result);
209			$this->assertInstanceOf('DateTime', $result->getStartTime());
210			$this->assertInstanceOf('DateTime', $result->getEndTime());
211			$this->assertInstanceOf('DateInterval', $result->getElapsed());
212			$this->assertInstanceOf('Ddeboer\DataImport\Result', $result);
213			$this->assertSame(3, $result->getTotalProcessedCount());
214			$this->assertSame(3, $result->getSuccessCount());
215			$this->assertSame(0, $result->getErrorCount());
216			$this->assertFalse($result->hasErrors());
217			$this->assertEmpty($result->getExceptions());
218			$this->assertSame(null, $result->getName());
219			}
220
221			public function testMultipleMappingsForAnItemAfterAnotherItemConverterwasAdded()
222			{
223			$originalData = array(array('foo' => 'bar', 'baz' => 'value'));
224
225			$outputTestData = array();
226
227			$writer = new ArrayWriter($outputTestData);
228			$reader = new ArrayReader($originalData);
229
230			$workflow = new StepAggregator($reader);
231
232			$converterStep = new ConverterStep();
233
234			// add a dummy item converter
235			$converterStep->add(function($item) { return $item; });
236
237			$mappingStep = (new MappingStep())
238			->map('[foo]', '[bar]')
239			->map('[baz]', '[bazzoo]');
240
241			// add multiple mappings
242			$workflow
243			->addStep($converterStep)
244			->addStep($mappingStep)
245			->addWriter($writer)
246			->process()
247			;
248
249			$this->assertArrayHasKey('bar', $outputTestData[0]);
250			$this->assertArrayHasKey('bazzoo', $outputTestData[0]);
251			}
252
253			public function _testWorkflowResultWithExceptionThrowFromWriter()
254			{
255			$workflow = $this->getWorkflow();
256			$workflow->setSkipItemOnFailure(true);
257			$writer = $this->getMock('Ddeboer\DataImport\Writer\WriterInterface');
258
259			$e = new WriterException();
260
261			$writer
262			->expects($this->at(1))
263			->method('writeItem')
264			->with(array('first' => 'James', 'last' => 'Bond'))
265			->will($this->throwException($e));
266
267			$workflow->addWriter($writer);
268			$result = $workflow->process();
269
270			$this->assertInstanceOf('Ddeboer\DataImport\Result', $result);
271			$this->assertInstanceOf('DateTime', $result->getStartTime());
272			$this->assertInstanceOf('DateTime', $result->getEndTime());
273			$this->assertInstanceOf('DateInterval', $result->getElapsed());
274			$this->assertInstanceOf('Ddeboer\DataImport\Result', $result);
275			$this->assertSame(3, $result->getTotalProcessedCount());
276			$this->assertSame(2, $result->getSuccessCount());
277			$this->assertSame(1, $result->getErrorCount());
278			$this->assertTrue($result->hasErrors());
279			$this->assertSame(array($e), iterator_to_array($result->getExceptions()));
280			$this->assertSame(null, $result->getName());
281			}
282
283			protected function getWorkflow()
284			{
285			$reader = new ArrayReader(array(
286			array(
287			'first' => 'James',
288			'last' => 'Bond'
289			),
290			array(
291			'first' => 'Miss',
292			'last' => 'Moneypenny'
293			),
294			array(
295			'first' => null,
296			'last' => 'Doe'
297			)
298			));
299
300			return new StepAggregator($reader);
301			}
302			}
303
304			class Dummy
305			{
306			public $name;
307
308			public function __construct($name)
309			{
310			$this->name = $name;
311			}
312			}
313

ddeboer / data-import

WorkflowTest::testWorkflowWithObjects() B last analyzed 2017-08-31 09:23 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

WorkflowTest::testWorkflowWithObjects() B
last analyzed 2017-08-31 09:23 UTC