Actualización

vendor/ddeboer/data-import/tests/Reader/CountableIteratorReaderTest.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace Ddeboer\DataImport\Tests\Reader;
+
+use Ddeboer\DataImport\Reader\CountableIteratorReader;
+
+/**
+ * @author Márk Sági-Kazár <mark.sagikazar@gmail.com>
+ */
+class CountableIteratorReaderTest extends \PHPUnit_Framework_TestCase
+{
+    public function testCount()
+    {
+        $iterator = new \ArrayIterator([
+            [
+                'id'       => 1,
+                'username' => 'john.doe',
+                'name'     => 'John Doe',
+            ],
+        ]);
+
+        $reader = new CountableIteratorReader($iterator);
+
+        // We need to rewind the iterator
+        $reader->rewind();
+
+        $this->assertEquals(1, $reader->count());
+    }
+
+    public function testIteratorCount()
+    {
+        $reader = new CountableIteratorReader(new CountableIterator);
+
+        // We need to rewind the iterator
+        $reader->rewind();
+
+        $this->assertEquals(0, $reader->count());
+    }
+}
+
+class CountableIterator extends \EmptyIterator
+{
+
+}

vendor/ddeboer/data-import/tests/Reader/CsvReaderTest.php

@@ -0,0 +1,281 @@
+<?php
+
+namespace Ddeboer\DataImport\Tests\Reader;
+
+use Ddeboer\DataImport\Reader\CsvReader;
+
+class CsvReaderTest extends \PHPUnit_Framework_TestCase
+{
+    public function testReadCsvFileWithColumnHeaders()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_column_headers.csv');
+        $csvReader = new CsvReader($file);
+        $csvReader->setHeaderRowNumber(0);
+
+        $this->assertEquals(
+            array(
+                'id', 'number', 'description'
+            ),
+            $csvReader->getFields()
+        );
+
+        foreach ($csvReader as $row) {
+            $this->assertNotNull($row['id']);
+            $this->assertNotNull($row['number']);
+            $this->assertNotNull($row['description']);
+        }
+
+        $this->assertEquals(
+            array(
+                'id'        => 6,
+                'number'    => '456',
+                'description' => 'Another description'
+            ),
+            $csvReader->getRow(2)
+        );
+    }
+
+    public function testReadCsvFileWithoutColumnHeaders()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_no_column_headers.csv');
+        $csvReader = new CsvReader($file);
+
+        $this->assertEmpty($csvReader->getColumnHeaders());
+    }
+
+    public function testReadCsvFileWithManualColumnHeaders()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_no_column_headers.csv');
+        $csvReader = new CsvReader($file);
+        $csvReader->setColumnHeaders(array('id', 'number', 'description'));
+
+        foreach ($csvReader as $row) {
+            $this->assertNotNull($row['id']);
+            $this->assertNotNull($row['number']);
+            $this->assertNotNull($row['description']);
+        }
+    }
+
+    public function testReadCsvFileWithTrailingBlankLines()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_blank_lines.csv');
+        $csvReader = new CsvReader($file);
+        $csvReader->setColumnHeaders(array('id', 'number', 'description'));
+
+        foreach ($csvReader as $row) {
+            $this->assertNotNull($row['id']);
+            $this->assertNotNull($row['number']);
+            $this->assertNotNull($row['description']);
+        }
+    }
+
+    public function testCountWithoutHeaders()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_no_column_headers.csv');
+        $csvReader = new CsvReader($file);
+        $this->assertEquals(3, $csvReader->count());
+    }
+
+    public function testCountWithHeaders()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_column_headers.csv');
+        $csvReader = new CsvReader($file);
+        $csvReader->setHeaderRowNumber(0);
+        $this->assertEquals(3, $csvReader->count(), 'Row count should not include header');
+    }
+
+    public function testCountWithFewerElementsThanColumnHeadersNotStrict()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_fewer_elements_than_column_headers.csv');
+        $csvReader = new CsvReader($file);
+        $csvReader->setStrict(false);
+        $csvReader->setHeaderRowNumber(0);
+
+        $this->assertEquals(3, $csvReader->count());
+    }
+
+    public function testCountWithMoreElementsThanColumnHeadersNotStrict()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_more_elements_than_column_headers.csv');
+        $csvReader = new CsvReader($file);
+        $csvReader->setStrict(false);
+        $csvReader->setHeaderRowNumber(0);
+
+        $this->assertEquals(3, $csvReader->count());
+        $this->assertFalse($csvReader->hasErrors());
+        $this->assertEquals(array(6, 456, 'Another description'), array_values($csvReader->getRow(2)));
+    }
+
+    public function testCountDoesNotMoveFilePointer()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_column_headers.csv');
+        $csvReader = new CsvReader($file);
+        $csvReader->setHeaderRowNumber(0);
+
+        $key_before_count = $csvReader->key();
+        $csvReader->count();
+        $key_after_count = $csvReader->key();
+
+        $this->assertEquals($key_after_count, $key_before_count);
+    }
+
+    public function testVaryingElementCountWithColumnHeadersNotStrict()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_column_headers_varying_element_count.csv');
+        $csvReader = new CsvReader($file);
+        $csvReader->setStrict(false);
+        $csvReader->setHeaderRowNumber(0);
+
+        $this->assertEquals(4, $csvReader->count());
+        $this->assertFalse($csvReader->hasErrors());
+    }
+
+    public function testVaryingElementCountWithoutColumnHeadersNotStrict()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_no_column_headers_varying_element_count.csv');
+        $csvReader = new CsvReader($file);
+        $csvReader->setStrict(false);
+        $csvReader->setColumnHeaders(array('id', 'number', 'description'));
+
+        $this->assertEquals(5, $csvReader->count());
+        $this->assertFalse($csvReader->hasErrors());
+    }
+
+    public function testInvalidCsv()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_column_headers_varying_element_count.csv');
+        $reader = new CsvReader($file);
+        $reader->setHeaderRowNumber(0);
+
+        $this->assertTrue($reader->hasErrors());
+
+        $this->assertCount(2, $reader->getErrors());
+
+        $errors = $reader->getErrors();
+        $this->assertEquals(2, key($errors));
+        $this->assertEquals(array('123', 'test'), current($errors));
+
+        next($errors);
+        $this->assertEquals(3, key($errors));
+        $this->assertEquals(array('7', '7890', 'Some more info', 'too many columns'), current($errors));
+    }
+
+    public function testLastRowInvalidCsv()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_no_column_headers_varying_element_count.csv');
+        $reader = new CsvReader($file);
+        $reader->setColumnHeaders(array('id', 'number', 'description'));
+
+        $this->assertTrue($reader->hasErrors());
+        $this->assertCount(3, $reader->getErrors());
+
+        $errors = $reader->getErrors();
+        $this->assertEquals(1, key($errors));
+        $this->assertEquals(array('6', 'strictly invalid'), current($errors));
+
+        next($errors);
+        $this->assertEquals(3, key($errors));
+        $this->assertEquals(array('3','230','Yet more info','Even more info'), current($errors));
+
+        next($errors);
+        $this->assertEquals(4, key($errors));
+        $this->assertEquals(array('strictly invalid'), current($errors));
+    }
+
+    public function testLineBreaks()
+    {
+        $reader = $this->getReader('data_cr_breaks.csv');
+        $this->assertCount(3, $reader);
+    }
+
+    /**
+     * @expectedException \Ddeboer\DataImport\Exception\DuplicateHeadersException description
+     */
+    public function testDuplicateHeadersThrowsException()
+    {
+        $reader = $this->getReader('data_column_headers_duplicates.csv');
+        $reader->setHeaderRowNumber(0);
+    }
+
+    public function testDuplicateHeadersIncrement()
+    {
+        $reader = $this->getReader('data_column_headers_duplicates.csv');
+        $reader->setHeaderRowNumber(0, CsvReader::DUPLICATE_HEADERS_INCREMENT);
+        $reader->rewind();
+        $current = $reader->current();
+
+        $this->assertEquals(
+            array('id', 'description', 'description1', 'description2', 'details', 'details1', 'last'),
+            $reader->getColumnHeaders()
+        );
+
+        $this->assertEquals(
+            array(
+                'id'           => '50',
+                'description'  => 'First',
+                'description1' => 'Second',
+                'description2' => 'Third',
+                'details'      => 'Details1',
+                'details1'     => 'Details2',
+                'last'         => 'Last one'
+            ),
+            $current
+        );
+    }
+
+    public function testDuplicateHeadersMerge()
+    {
+        $reader = $this->getReader('data_column_headers_duplicates.csv');
+        $reader->setHeaderRowNumber(0, CsvReader::DUPLICATE_HEADERS_MERGE);
+        $reader->rewind();
+        $current = $reader->current();
+
+        $this->assertCount(4, $reader->getColumnHeaders());
+
+        $expected = array(
+            'id'          => '50',
+            'description' => array('First', 'Second', 'Third'),
+            'details'     => array('Details1', 'Details2'),
+            'last'        => 'Last one'
+        );
+        $this->assertEquals($expected, $current);
+    }
+
+    public function testMaximumNesting()
+    {
+        if (!function_exists('xdebug_is_enabled')) {
+            $this->markTestSkipped('xDebug is not installed');
+        }
+
+        $xdebug_start = !xdebug_is_enabled();
+        if ($xdebug_start) {
+            xdebug_enable();
+        }
+
+        ini_set('xdebug.max_nesting_level', 200);
+
+        $file = new \SplTempFileObject();
+        for($i = 0; $i < 500; $i++) {
+            $file->fwrite("1,2,3\n");
+        }
+
+        $reader = new CsvReader($file);
+        $reader->rewind();
+        $reader->setStrict(true);
+        $reader->setColumnHeaders(array('one','two'));
+
+        $current = $reader->current();
+        $this->assertEquals(null, $current);
+
+        if ($xdebug_start) {
+            xdebug_disable();
+        }
+    }
+
+    protected function getReader($filename)
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/'.$filename);
+
+        return new CsvReader($file);
+    }
+}

vendor/ddeboer/data-import/tests/Reader/DbalReaderTest.php

@@ -0,0 +1,200 @@
+<?php
+
+namespace Ddeboer\DataImport\Tests\Reader;
+
+use Ddeboer\DataImport\Reader\DbalReader;
+use Doctrine\DBAL\Configuration;
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\DriverManager;
+use Doctrine\DBAL\Platforms\SqlitePlatform;
+use Doctrine\DBAL\Schema\Schema;
+
+class DbalReaderTest extends \PHPUnit_Framework_TestCase
+{
+    public function testCalculateRowCount()
+    {
+        $reader = $this->getReader();
+
+        $reader->setRowCountCalculated();
+        $this->assertTrue($reader->isRowCountCalculated());
+
+        $reader->setRowCountCalculated(false);
+        $this->assertFalse($reader->isRowCountCalculated());
+
+        $reader->setRowCountCalculated(true);
+        $this->assertTrue($reader->isRowCountCalculated());
+    }
+
+    public function testGetFields()
+    {
+        $fields = $this->getReader()->getFields();
+        $this->assertInternalType('array', $fields);
+        $this->assertEquals(array('id', 'username', 'name'), $fields);
+    }
+
+    public function testCount()
+    {
+        $this->assertEquals(10, $this->getReader()->count());
+    }
+
+    public function testCountInhibited()
+    {
+        $reader = $this->getReader();
+        $reader->setRowCountCalculated(false);
+
+        $this->assertEquals(null, $reader->count());
+    }
+
+    public function testSqlAndParamsAreMutable()
+    {
+        $reader = $this->getReader();
+
+        $reader->setSql('SELECT * FROM groups WHERE id = :id', array('id' => 2));
+        $this->assertAttributeEquals('SELECT * FROM groups WHERE id = :id', 'sql', $reader);
+        $this->assertAttributeEquals(array('id' => 2), 'params', $reader);
+    }
+
+    public function testChangeSqlOrParamsClearsNumRowsAndStatement()
+    {
+        $reader = $this->getReader();
+        $reader->count();
+        $reader->getFields();
+
+        $this->assertAttributeNotEmpty('rowCount', $reader);
+        $this->assertAttributeNotEmpty('stmt', $reader);
+
+        $reader->setSql('SELECT * FROM `user` WHERE id IN (:id)', array('id' => array()));
+
+        $this->assertAttributeEmpty('rowCount', $reader);
+        $this->assertAttributeEmpty('stmt', $reader);
+    }
+
+    public function testIterate()
+    {
+        $i=31;
+        foreach ($this->getReader() as $key => $row) {
+            $this->assertInternalType('array', $row);
+            $this->assertEquals('user-'.$i, $row['username']);
+            $this->assertEquals($i - 31, $key);
+            $i++;
+        }
+
+        $this->assertEquals(41, $i);
+    }
+
+    public function testReaderRewindWorksCorrectly()
+    {
+        $reader = $this->getReader();
+        foreach ($reader as $row) {
+            if (!isset($row['username'])) {
+                $this->fail('There should be a username');
+            }
+            if ($row['username'] == 'user-35') {
+                break;
+            }
+        }
+
+        $reader->rewind();
+
+        $this->assertEquals(array(
+            'id' => 31,
+            'username' => 'user-31',
+            'name' => 'name 4',
+        ), $reader->current());
+    }
+
+    public function testCallingCurrentTwiceShouldNotAdvance()
+    {
+        $reader = $this->getReader();
+
+        $expected = array(
+            'id' => 31,
+            'username' => 'user-31',
+            'name' => 'name 4',
+        );
+        $this->assertEquals($expected, $reader->current());
+        $this->assertEquals($expected, $reader->current());
+    }
+
+    public function testEmptyResultDoesNotThrowException()
+    {
+        $reader = $this->getReader();
+
+        $reader->setSql(null, array('name' => 'unknown group'));
+        $this->assertInternalType('array', $reader->getFields());
+    }
+
+    public function testCallValidRewindsIfNeeded()
+    {
+        $reader = $this->getReader();
+
+        $this->assertTrue($reader->valid());
+        $this->assertAttributeInternalType('array', 'data', $reader);
+    }
+
+    public function getConnection()
+    {
+        $params = array(
+            'driver' => 'pdo_sqlite',
+            'memory' => true,
+        );
+
+        $connection = DriverManager::getConnection($params, new Configuration());
+
+        $schema = new Schema();
+
+        $table = $schema->createTable('groups');
+        $table->addColumn('id', 'integer', ['autoincrement' => true]);
+        $table->addColumn('name', 'string', array('length' => 45));
+        $table->setPrimaryKey(array('id'));
+
+        $myTable = $schema->createTable('user');
+        $myTable->addColumn('id', 'integer', array('unsigned' => true, 'autoincrement' => true));
+        $myTable->addColumn('username', 'string', array('length' => 32));
+        $myTable->addColumn('group_id', 'integer');
+        $myTable->setPrimaryKey(array('id'));
+        $myTable->addUniqueIndex(array('username'));
+        $myTable->addForeignKeyConstraint($table, array('group_id'), array('id'));
+
+        foreach ($schema->toSql(new SqlitePlatform()) as $query) {
+            $connection->query($query);
+        };
+
+        return $connection;
+    }
+
+    protected function getReader()
+    {
+        $connection = $this->getConnection();
+        $this->loadFixtures($connection);
+
+        return new DbalReader($connection, implode(' ', array(
+            'SELECT u.id, u.username, g.name',
+            'FROM `user` u INNER JOIN groups g ON u.group_id = g.id',
+            'WHERE g.name LIKE :name',
+        )), array(
+            'name' => 'name 4',
+        ));
+    }
+
+    /**
+     * @param Connection $connection
+     */
+    protected function loadFixtures($connection)
+    {
+        $counter = 1;
+        for ($i = 1; $i <= 10; $i++) {
+            $connection->insert('groups', array('name' => "name {$i}"));
+            $id = $connection->lastInsertId();
+
+            for ($j = 1; $j <= 10; $j++) {
+                $connection->insert('user', array(
+                    'username' => "user-{$counter}",
+                    'group_id' => $id,
+                ));
+
+                $counter++;
+            }
+        }
+    }
+}

vendor/ddeboer/data-import/tests/Reader/DoctrineReaderTest.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace Ddeboer\DataImport\Tests\Reader;
+
+use Ddeboer\DataImport\Reader\DoctrineReader;
+use Doctrine\ORM\EntityManager;
+use Doctrine\ORM\Tools\Setup;
+use Ddeboer\DataImport\Tests\Fixtures\Entity\User;
+
+class DoctrineReaderTest extends \PHPUnit_Framework_TestCase
+{
+    public function testGetFields()
+    {
+        $fields = $this->getReader()->getFields();
+        $this->assertInternalType('array', $fields);
+        $this->assertEquals(array('id', 'username'), $fields);
+    }
+
+    public function testCount()
+    {
+        $this->assertEquals(100, $this->getReader()->count());
+    }
+
+    public function testIterate()
+    {
+        $i = 1;
+        foreach ($this->getReader() as $data) {
+            $this->assertInternalType('array', $data);
+            $this->assertEquals('user' . $i, $data['username']);
+            $i++;
+        }
+    }
+
+    protected function getReader()
+    {
+        $em = $this->getEntityManager();
+
+        for ($i = 1; $i <= 100; $i++) {
+            $user = new User();
+            $user->setUsername('user'. $i);
+            $em->persist($user);
+        }
+
+        $em->flush();
+
+        return new DoctrineReader($em, 'Ddeboer\DataImport\Tests\Fixtures\Entity\User');
+    }
+
+    protected function getEntityManager()
+    {
+        $dbParams = array(
+            'driver'   => 'pdo_sqlite',
+        );
+
+        $paths = array(
+            __DIR__.'/../Fixtures/Entity'
+        );
+
+        $config = Setup::createAnnotationMetadataConfiguration($paths, true);
+        $em = EntityManager::create($dbParams, $config);
+
+        $schemaTool = new \Doctrine\ORM\Tools\SchemaTool($em);
+        $schemaTool->createSchema(
+            array(
+                $em->getMetadataFactory()->getMetadataFor('Ddeboer\DataImport\Tests\Fixtures\Entity\User')
+            )
+        );
+
+        return $em;
+    }
+}

vendor/ddeboer/data-import/tests/Reader/ExcelReaderTest.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace Ddeboer\DataImport\Tests\Reader;
+
+use Ddeboer\DataImport\Reader\ExcelReader;
+
+class ExcelReaderTest extends \PHPUnit_Framework_TestCase
+{
+    public function setUp()
+    {
+        if (!extension_loaded('zip')) {
+            $this->markTestSkipped();
+        }
+    }
+
+    public function testGetFields()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_column_headers.xlsx');
+        $reader = new ExcelReader($file, 0);
+        $this->assertEquals(array('id', 'number', 'description'), $reader->getFields());
+        $this->assertEquals(array('id', 'number', 'description'), $reader->getColumnHeaders());
+    }
+
+    public function testCountWithoutHeaders()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_no_column_headers.xls');
+        $reader = new ExcelReader($file);
+        $this->assertEquals(3, $reader->count());
+    }
+
+    public function testCountWithHeaders()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_column_headers.xlsx');
+        $reader = new ExcelReader($file, 0);
+        $this->assertEquals(3, $reader->count());
+    }
+
+    public function testIterate()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_column_headers.xlsx');
+        $reader = new ExcelReader($file, 0);
+        foreach ($reader as $row) {
+            $this->assertInternalType('array', $row);
+            $this->assertEquals(array('id', 'number', 'description'), array_keys($row));
+        }
+    }
+
+    public function testMultiSheet()
+    {
+        $file = new \SplFileObject(__DIR__.'/../Fixtures/data_multi_sheet.xls');
+        $sheet1reader = new ExcelReader($file, null, 0);
+        $this->assertEquals(3, $sheet1reader->count());
+
+        $sheet2reader = new ExcelReader($file, null, 1);
+        $this->assertEquals(2, $sheet2reader->count());
+    }
+}

vendor/ddeboer/data-import/tests/Reader/Factory/CsvReaderFactoryTest.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Ddeboer\DataImport\Tests\Reader\Factory;
+
+use Ddeboer\DataImport\Reader\Factory\CsvReaderFactory;
+
+class CsvReaderFactoryTest extends \PHPUnit_Framework_TestCase
+{
+    public function testGetReader()
+    {
+        $factory = new CsvReaderFactory();
+        $reader = $factory->getReader(new \SplFileObject(__DIR__.'/../../Fixtures/data_column_headers.csv'));
+
+        $this->assertInstanceOf('\Ddeboer\DataImport\Reader\CsvReader', $reader);
+        $this->assertCount(4, $reader);
+
+        $factory = new CsvReaderFactory(0);
+        $reader = $factory->getReader(new \SplFileObject(__DIR__.'/../../Fixtures/data_column_headers.csv'));
+
+        $this->assertCount(3, $reader);
+    }
+}

vendor/ddeboer/data-import/tests/Reader/Factory/DbalReaderFactoryTest.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Ddeboer\DataImport\Tests\Reader\Factory;
+
+use Ddeboer\DataImport\Reader\Factory\ExcelReaderFactory;
+
+class DbalReaderFactoryTest extends \PHPUnit_Framework_TestCase
+{
+    public function setUp()
+    {
+        if (!extension_loaded('zip')) {
+            $this->markTestSkipped();
+        }
+    }
+
+    public function testGetReader()
+    {
+        $factory = new ExcelReaderFactory();
+        $reader = $factory->getReader(new \SplFileObject(__DIR__.'/../../Fixtures/data_column_headers.xlsx'));
+        $this->assertInstanceOf('\Ddeboer\DataImport\Reader\ExcelReader', $reader);
+        $this->assertCount(4, $reader);
+
+        $factory = new ExcelReaderFactory(0);
+        $reader = $factory->getReader(new \SplFileObject(__DIR__.'/../../Fixtures/data_column_headers.xlsx'));
+        $this->assertCount(3, $reader);
+    }
+}

vendor/ddeboer/data-import/tests/Reader/Factory/DoctrineReaderFactoryTest.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Ddeboer\DataImport\Tests\Reader\Factory;
+
+use Ddeboer\DataImport\Reader\Factory\DoctrineReaderFactory;
+
+class DoctrineReaderFactoryTest extends \PHPUnit_Framework_TestCase
+{
+    public function testGetReader()
+    {
+        $om = $this->getMockBuilder('\Doctrine\Common\Persistence\ObjectManager')->getMock();
+        $factory = new DoctrineReaderFactory($om);
+        $reader = $factory->getReader('Some:Object');
+        $this->assertInstanceOf('\Ddeboer\DataImport\Reader\DoctrineReader', $reader);
+    }
+}

vendor/ddeboer/data-import/tests/Reader/Factory/ExcelReaderFactoryTest.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Ddeboer\DataImport\Tests\Reader\Factory;
+
+use Ddeboer\DataImport\Reader\Factory\DoctrineReaderFactory;
+
+class ExcelReaderFactoryTest extends \PHPUnit_Framework_TestCase
+{
+    public function testGetReader()
+    {
+        $om = $this->getMockBuilder('\Doctrine\Common\Persistence\ObjectManager')->getMock();
+        $factory = new DoctrineReaderFactory($om);
+        $reader = $factory->getReader('Some:Object');
+        $this->assertInstanceOf('\Ddeboer\DataImport\Reader\DoctrineReader', $reader);
+    }
+}

vendor/ddeboer/data-import/tests/Reader/IteratorReaderTest.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Ddeboer\DataImport\Tests\Reader;
+
+use Ddeboer\DataImport\Reader\IteratorReader;
+
+/**
+ * @author Márk Sági-Kazár <mark.sagikazar@gmail.com>
+ */
+class IteratorReaderTest extends \PHPUnit_Framework_TestCase
+{
+    public function testGetFields()
+    {
+        $iterator = new \ArrayIterator([
+            [
+                'id'       => 1,
+                'username' => 'john.doe',
+                'name'     => 'John Doe',
+            ],
+        ]);
+
+        $reader = new IteratorReader($iterator);
+
+        // We need to rewind the iterator
+        $reader->rewind();
+
+        $fields = $reader->getFields();
+
+        $this->assertInternalType('array', $fields);
+        $this->assertEquals(['id', 'username', 'name'], $fields);
+    }
+}

vendor/ddeboer/data-import/tests/Reader/OneToManyReaderTest.php

@@ -0,0 +1,347 @@
+<?php
+
+namespace Ddeboer\DataImport\Tests\Reader;
+
+use Ddeboer\DataImport\Reader\ArrayReader;
+use Ddeboer\DataImport\Reader\OneToManyReader;
+
+/**
+ * Class OneToManyReaderTest
+ * @package Ddeboer\DataImport\Tests\Reader
+ * @author Aydin Hassan <aydin@hotmail.co.uk>
+ */
+class OneToManyReaderTest extends \PHPUnit_Framework_TestCase
+{
+    public function testReaderMergesOneToMany()
+    {
+        $leftData = array(
+            array(
+                'OrderId'   => 1,
+                'Price'     => 30,
+            ),
+            array(
+                'OrderId'   => 2,
+                'Price'     => 15,
+            ),
+        );
+
+        $rightData = array(
+            array(
+                'OrderId'   => 1,
+                'Name'      => 'Super Cool Item 1',
+            ),
+            array(
+                'OrderId'   => 1,
+                'Name'      => 'Super Cool Item 2',
+            ),
+            array(
+                'OrderId'   => 2,
+                'Name'      => 'Super Cool Item 1',
+            ),
+        );
+
+        $leftReader = new ArrayReader($leftData);
+        $rightReader = new ArrayReader($rightData);
+        $oneToManyReader = new OneToManyReader($leftReader, $rightReader, 'items', 'OrderId', 'OrderId');
+
+        $expected = array(
+            array(
+                'OrderId'   => 1,
+                'Price'     => 30,
+                'items'     => array(
+                    array(
+                        'OrderId'   => 1,
+                        'Name'      => 'Super Cool Item 1',
+                    ),
+                    array(
+                        'OrderId'   => 1,
+                        'Name'      => 'Super Cool Item 2',
+                    ),
+                ),
+            ),
+            array(
+                'OrderId'   => 2,
+                'Price'     => 15,
+                'items'     => array(
+                    array(
+                        'OrderId'   => 2,
+                        'Name'      => 'Super Cool Item 1',
+                    ),
+                )
+            ),
+        );
+
+        $i = 0;
+        foreach($oneToManyReader as $row) {
+            $this->assertEquals($row, $expected[$i++]);
+        }
+    }
+
+    public function testIfRightReaderIdFieldIsMissingLeftIsUsed()
+    {
+        $leftData = array(
+            array(
+                'OrderId'   => 1,
+                'Price'     => 30,
+            ),
+            array(
+                'OrderId'   => 2,
+                'Price'     => 15,
+            ),
+        );
+
+        $rightData = array(
+            array(
+                'OrderId'   => 1,
+                'Name'      => 'Super Cool Item 1',
+            ),
+            array(
+                'OrderId'   => 1,
+                'Name'      => 'Super Cool Item 2',
+            ),
+            array(
+                'OrderId'   => 2,
+                'Name'      => 'Super Cool Item 1',
+            ),
+        );
+
+        $leftReader = new ArrayReader($leftData);
+        $rightReader = new ArrayReader($rightData);
+        $oneToManyReader = new OneToManyReader($leftReader, $rightReader, 'items', 'OrderId');
+
+        $expected = array(
+            array(
+                'OrderId'   => 1,
+                'Price'     => 30,
+                'items'     => array(
+                    array(
+                        'OrderId'   => 1,
+                        'Name'      => 'Super Cool Item 1',
+                    ),
+                    array(
+                        'OrderId'   => 1,
+                        'Name'      => 'Super Cool Item 2',
+                    ),
+                ),
+            ),
+            array(
+                'OrderId'   => 2,
+                'Price'     => 15,
+                'items'     => array(
+                    array(
+                        'OrderId'   => 2,
+                        'Name'      => 'Super Cool Item 1',
+                    ),
+                )
+            ),
+        );
+
+        $i = 0;
+        foreach($oneToManyReader as $row) {
+            $this->assertEquals($row, $expected[$i++]);
+        }
+    }
+
+    public function testReaderThrowsExceptionIfNestKeyExistsInLeftReaderRow()
+    {
+        $leftData = array(
+            array(
+                'OrderId'   => 1,
+                'Price'     => 30,
+                'items'     => null,
+            ),
+        );
+
+        $rightData = array(
+            array(
+                'OrderId'   => 1,
+                'Name'      => 'Super Cool Item 1',
+            ),
+        );
+
+        $leftReader  = new ArrayReader($leftData);
+        $rightReader  = new ArrayReader($rightData);
+        $oneToManyReader  = new OneToManyReader($leftReader, $rightReader, 'items', 'OrderId');
+
+        $this->setExpectedException('Ddeboer\DataImport\Exception\ReaderException', 'Left Row: "0" Reader already contains a field named "items". Please choose a different nest key field');
+
+        $oneToManyReader->rewind();
+        $oneToManyReader->current();
+    }
+
+    public function testReaderThrowsExceptionIfIdFieldDoesNotExistInLeftRow()
+    {
+        $leftData = array(
+            array(
+                'Price'     => 30,
+            ),
+        );
+
+        $rightData = array(
+            array(
+                'Name'      => 'Super Cool Item 1',
+            ),
+        );
+
+        $leftReader = new ArrayReader($leftData);
+        $rightReader = new ArrayReader($rightData);
+        $oneToManyReader = new OneToManyReader($leftReader, $rightReader, 'items', 'OrderId');
+
+        $this->setExpectedException('Ddeboer\DataImport\Exception\ReaderException', 'Row: "0" has no field named "OrderId"');
+
+        $oneToManyReader->rewind();
+        $oneToManyReader->current();
+    }
+
+    public function testReaderThrowsExceptionIfIdFieldDoesNotExistInRightRow()
+    {
+        $leftData = array(
+            array(
+                'OrderId'   => 1,
+                'Price'     => 30,
+            ),
+        );
+
+        $rightData = array(
+            array(
+                'Name'      => 'Super Cool Item 1',
+            ),
+        );
+
+        $leftReader = new ArrayReader($leftData);
+        $rightReader = new ArrayReader($rightData);
+        $oneToManyReader = new OneToManyReader($leftReader, $rightReader, 'items', 'OrderId');
+
+        $this->setExpectedException('Ddeboer\DataImport\Exception\ReaderException', 'Row: "0" has no field named "OrderId"');
+
+        $oneToManyReader->rewind();
+        $oneToManyReader->current();
+    }
+
+    public function testGetKeysReturnsLeftReaderColumnsMergedWithNestKey()
+    {
+        $leftReader = new ArrayReader(array(array('col1' => 'data1',  'col2' => 'data2'), array('data3', 'data4')));
+        $rightReader = new ArrayReader(array());
+        $oneToManyReader = new OneToManyReader($leftReader, $rightReader, 'items', 'OrderId');
+
+        $this->assertSame(array('col1', 'col2', 'items'), $oneToManyReader->getFields());
+    }
+
+    public function testCountReturnsTheCountOfTheLeftReader()
+    {
+        $leftReader = new ArrayReader(array());
+        $rightReader = new ArrayReader(array());
+
+        $oneToManyReader = new OneToManyReader($leftReader, $rightReader, 'items', 'OrderId');
+        $this->assertEquals(0, $oneToManyReader->count());
+
+        $leftReader = new ArrayReader(array(array(), array(), array()));
+        $oneToManyReader = new OneToManyReader($leftReader, $rightReader, 'items', 'OrderId');
+        $this->assertEquals(3, $oneToManyReader->count());
+    }
+
+    /**
+     * This is probably a limitation - but it's not need for current implementation
+     * @dataProvider outOfOrderRowProvider
+     */
+    public function testOutOfOrderRowsInRightReaderAreNotNested($leftData, $rightData, $expected)
+    {
+        //var_dump($leftData);
+        //var_dump($rightData);
+        $leftReader = new ArrayReader($leftData);
+        $rightReader = new ArrayReader($rightData);
+        $oneToManyReader = new OneToManyReader($leftReader, $rightReader, 'items', 'OrderId');
+
+        $i = 0;
+        foreach($oneToManyReader as $row) {
+            $this->assertEquals($row, $expected[$i++]);
+        }
+    }
+
+    public function outOfOrderRowProvider()
+    {
+        return array(
+            'skip-first-right-row' => array(
+                'left' => array(
+                    array(
+                        'OrderId'   => 3,
+                        'Price'     => 30,
+                    ),
+                    array(
+                        'OrderId'   => 2,
+                        'Price'     => 15,
+                    ),
+                ),
+                'right' => array(
+                    array(
+                        'OrderId'   => 2,
+                        'Name'      => 'Super Cool Item 1',
+                    ),
+                    array(
+                        'OrderId'   => 1,
+                        'Name'      => 'Super Cool Item 1',
+                    ),
+                    array(
+                        'OrderId'   => 1,
+                        'Name'      => 'Super Cool Item 2',
+                    ),
+                ),
+                'expected' => array(
+                    array(
+                        'OrderId'   => 3,
+                        'Price'     => 30,
+                        'items'     => array()
+                    ),
+                    array(
+                        'OrderId'   => 2,
+                        'Price'     => 15,
+                        'items'     => array(
+                            array(
+                                'OrderId'   => 2,
+                                'Name'      => 'Super Cool Item 1',
+                            ),
+                        )
+                    ),
+                ),
+            ),
+            'skip-out-of-order' => array(
+                'left' => array(
+                    array(
+                        'OrderId'   => 1,
+                        'Price'     => 30,
+                    ),
+                    array(
+                        'OrderId'   => 2,
+                        'Price'     => 15,
+                    ),
+                ),
+                'right' => array(
+                    array(
+                        'OrderId'   => 0,
+                        'Name'      => 'Super Cool Item 1',
+                    ),
+                    array(
+                        'OrderId'   => 2,
+                        'Name'      => 'Super Cool Item 2',
+                    ),
+                    array(
+                        'OrderId'   => 1,
+                        'Name'      => 'Super Cool Item 3',
+                    ),
+                ),
+                'expected' => array(
+                    array(
+                        'OrderId'   => 1,
+                        'Price'     => 30,
+                        'items'     => array()
+                    ),
+                    array(
+                        'OrderId'   => 2,
+                        'Price'     => 15,
+                        'items'     => array(),
+                    ),
+                ),
+            ),
+        );
+    }
+}

vendor/ddeboer/data-import/tests/Reader/PdoReaderTest.php

@@ -0,0 +1,91 @@
+<?php
+
+namespace Ddeboer\DataImport\Tests\Reader;
+
+use Ddeboer\DataImport\Reader\PdoReader;
+// use Doctrine\DBAL\Configuration;
+// use Doctrine\DBAL\DriverManager;
+// use Doctrine\DBAL\Platforms\SqlitePlatform;
+
+class PdoReaderTest extends \PHPUnit_Framework_TestCase
+{
+	public function testGetFields()
+	{
+		$fields = $this->getReader()->getFields();
+		$this->assertInternalType('array', $fields);
+		$this->assertEquals(array('id', 'username', 'name'), $fields);
+	}
+
+	public function testCount()
+	{
+		$this->assertEquals(100, $this->getReader()->count());
+	}
+
+	public function testIterate()
+	{
+		$i=1;
+		foreach ($this->getReader() as $row) {
+			$this->assertInternalType('array', $row);
+			$this->assertEquals('user-'.$i, $row['username']);
+			$i++;
+		}
+	}
+
+	public function testReaderRewindWorksCorrectly()
+	{
+		$reader = $this->getReader();
+		foreach ($reader as $row) {
+		}
+
+		foreach ($reader as $row) {
+		}
+	}
+
+	public function getConnection()
+	{
+		$connection = new \PDO('sqlite::memory:');
+		// Set error mode = exception for easy debugging
+		$connection->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
+
+		// Build schema
+		$connection->query('CREATE TABLE pdo_group (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			name VARCHAR(45)
+		)');
+
+		$connection->query('CREATE TABLE pdo_user (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			username VARCHAR(32),
+			group_id INTEGER,
+			FOREIGN KEY(group_id) REFERENCES pdo_group(id)
+		)');
+		$connection->query('CREATE UNIQUE INDEX user_username ON pdo_user(username)');
+
+		return $connection;
+	}
+
+	protected function getReader()
+	{
+		$connection = $this->getConnection();
+
+		$group_insert = $connection->prepare('INSERT INTO pdo_group (name) VALUES (:name)');
+		$user_insert  = $connection->prepare('INSERT INTO pdo_user (username, group_id) VALUES (:username, :group)');
+
+		$counter = 1;
+		for ($i = 1; $i <= 10; $i++) {
+			$group_insert->execute(array(':name' => "name {$i}"));
+			$id = $connection->lastInsertId();
+
+			for ($j = 1; $j <= 10; $j++) {
+				$user_insert->execute(array(
+					':username'  => "user-{$counter}",
+					':group' => $id
+				));
+
+				$counter++;
+			}
+		}
+
+		return new PdoReader($connection, 'SELECT u.id, u.username, g.name FROM `pdo_user` u INNER JOIN `pdo_group` g ON u.group_id = g.id');
+	}
+}