DefaultPipelineContext

Complexity

Total Complexity

13

Size/Duplication

Total Lines	128
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	14

<?php
{
    private $workingTable = 'book';
    private $workingFile;
    private $pipeline;
    private $output;
    private $connection;

    /**
     * @Given a file named :name with:
     */
    public function aFileNamedWith($name, PyStringNode $content)
    {
        $this->workingFile = $this->createFileFromStringNode($name, $content);
    }

    /**
     * @Given I create csv to console pipeline using :transformer transformer
     */
    public function iCreateCsvToConsolePipelineUsingTransformer($transformer)
    {
        return $this->pipeline = new DefaultPipeline(
            $this->createCsvExtractor(),
            $this->createTransformer($transformer),
            new ConsoleLoader(
                new Table($this->output = new BufferedOutput())
            )
        );
    }

    /**
     * @Given I create csv to database pipeline
     */
    public function iCreateCsvToDatabasePipeline()
    {
        return $this->pipeline = new DefaultPipeline(
            $this->createCsvExtractor(),
            $this->createTransformer('callable'),
            new DbalLoader(
                $this->getConnection(),
                $this->workingTable
            )
        );
    }

    /**
     * @Given I process it
     */
    public function iProcessIt()
    {
        $this->pipeline->process();
    }

    /**
     * @Then I should see in console:
     */
    public function iShouldSeeInConsole(PyStringNode $expected)
    {
        $expected = $this->stringNodeToString($expected);
        $actual = trim($this->output->fetch());

        PHPUnit_Framework_Assert::assertEquals($expected, $actual);
    }

    /**
     * @Then I should see in database:
     */
    public function iShouldSeeInDatabase(TableNode $table)
    {
        $actual = $this->getConnection()
            ->createQueryBuilder()
            ->select('*')
            ->from($this->workingTable)
            ->execute()
            ->fetchAll()
        ;

        foreach ($table->getHash() as $key => $expected) {
            PHPUnit_Framework_Assert::assertEquals($expected, $actual[$key]);
        }
    }

    private function createCsvExtractor()
    {
        return new CsvExtractor(new \SplFileObject($this->workingFile));
    }

    private function createTransformer($type)
    {
        switch ($type) {
            case 'callable':
                return new CallbackTransformer(function ($data) {
                    return [
                        'isbn' => $data[0],
                        'title' => $data[1],
                        'author' => $data[2],
                    ];
                });

            case 'chain':
                return new TransformerChain([
                    new CallbackTransformer(function ($data) {
                        unset($data[0]);

                        return $data;
                    }),
                    new CallbackTransformer(function ($data) {
                        return [
                            'title' => $data[1],
                            'author' => $data[2],
                        ];
                    }),
                ]);
        }

        throw new PendingException(sprintf('Implement %s transformer creator.', $type));
    }

    private function getConnection()
    {
        if (null === $this->connection) {
            $this->connection = DriverManager::getConnection(['url' => 'sqlite:///:memory:']);
            $this->connection->exec(sprintf('CREATE TABLE %s(isbn, title, author)', $this->workingTable));
        }

        return $this->connection;
    }
}