GD\GherkinToDusk

Complexity

Total Complexity

36

Size/Duplication

Total Lines	285
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

81.82%

Importance

Changes	2
Bugs	0	Features	0

26 Methods

Rating	Name	Duplication	Size	Complexity
B	initializeFeature()	0	23	4
A	featureToBrowser()	0	8	1
A	featureToUnit()	0	9	1
A	getParser()	0	4	1
A	setParser()	0	4	1
A	isComponent()	0	4	1
A	setComponent()	0	4	1
A	getFeatureContent()	0	4	1
A	setFeatureContent()	0	4	1
A	loadFileContent()	0	5	1
A	passThroughParser()	0	4	1
A	getParsedFeature()	0	4	1
A	setParsedFeature()	0	4	1
A	breakIntoMethods()	0	4	1
A	iterateOverScenariosAndBuildUpClassMethods()	0	16	2
A	buildOutSteps()	0	11	2
A	buildDuskTestName()	0	7	2
A	getFullPathToFileAndFileName()	0	4	1
A	getDuskClassAndMethods()	0	4	1
A	setDuskClassAndMethods()	0	4	1
A	getDuskTestName()	0	4	1
A	setDuskTestName()	0	4	1
A	getWriteBrowserTest()	0	9	2
A	setWriteBrowserTest()	0	9	2
A	getWriteUnitTest()	0	9	2
A	setWriteUnitTest()	0	9	2

<?php

namespace GD;

use Behat\Gherkin\Gherkin;
use Behat\Gherkin\Keywords\CucumberKeywords;
use Behat\Gherkin\Lexer;
use Behat\Gherkin\Loader\GherkinFileLoader;
use Behat\Gherkin\Loader\YamlFileLoader;
use Behat\Gherkin\Parser;
use GD\Exceptions\MustSetFileNameAndPath;
use GD\Helpers\BuildOutContent;
use GD\Helpers\WriteBrowserFile;
use GD\Helpers\WritePHPUnitFile;
use Illuminate\Filesystem\Filesystem;
use Symfony\Component\Yaml\Yaml;

class GherkinToDusk extends BaseGherkinToDusk
{
    use BuildOutContent;

    protected $component = false;

    protected $string_contents = null;

    /**
     * Yml Content of a test yml
     * @var string
     */
    protected $feature_content;

    /**
     * @var \Behat\Gherkin\Node\FeatureNode
     */
    protected $parsed_feature;

    /**
     *
     */
    protected $dusk_class_and_methods;

    protected $dusk_test_name;

    /**
     * @var WritePHPUnitFile
     */
    protected $write_unit_test;

    /**
     * @var WriteBrowserFile
     */
    protected $write_browser_test;

    public function initializeFeature()
    {
        $this->loadFileContent();

        $this->buildDuskTestName();

        $this->passThroughParser();

        $this->breakIntoMethods();

        switch ($this->context) {
            case 'domain':
                $this->featureToUnit();
                break;
            case 'ui':
            case 'browser':
                $this->featureToBrowser();
                break;
            default:
                //more coming soon
                break;
        }
    }

    protected function featureToBrowser()
    {
        $this->getWriteBrowserTest()->writeTest(
            $this->getDestinationFolderRoot(),
            $this->getDuskTestName(),
            $this->getDuskClassAndMethods()
        );
    }

    protected function featureToUnit()
    {

        $this->getWriteUnitTest()->writeTest(
            $this->getDestinationFolderRoot(),
            $this->getDuskTestName(),
            $this->getDuskClassAndMethods()
        );
    }

    /**
     * @return Parser
     */
    public function getParser()
    {
        return $this->parser;
    }

    /**
     * @param Parser $parser
     */
    public function setParser($parser)
    {
        $this->parser = $parser;
    }

    /**
     * @return boolean
     */
    public function isComponent()
    {
        return $this->component;
    }

    /**
     * @param boolean $component
     */
    public function setComponent($component)
    {
        $this->component = $component;
    }

    /**
     * @return mixed
     */
    public function getFeatureContent()
    {
        return $this->feature_content;
    }

    /**
     * @param mixed $feature_content
     */
    public function setFeatureContent($feature_content)
    {
        $this->feature_content = $feature_content;
    }

    private function loadFileContent()
    {
        $this->feature_content =
            $this->getFilesystem()->get($this->getFullPathToFileAndFileName());
    }

    private function passThroughParser()
    {
        $this->parsed_feature = $this->getParser()->parse($this->feature_content);
    }

    /**
     * @return \Behat\Gherkin\Node\FeatureNode
     */
    public function getParsedFeature()
    {
        return $this->parsed_feature;
    }

    /**
     * @param \Behat\Gherkin\Node\FeatureNode $parsed_feature
     */
    public function setParsedFeature($parsed_feature)
    {
        $this->parsed_feature = $parsed_feature;
    }

    private function breakIntoMethods()
    {
        $this->iterateOverScenariosAndBuildUpClassMethods();
    }

    private function iterateOverScenariosAndBuildUpClassMethods()
    {
        /** @var  $feature \Behat\Gherkin\Node\ScenarioNode */
        foreach ($this->parsed_feature->getScenarios() as $scenario_index => $scenario) {
            $parent_method_name = ucfirst(camel_case($scenario->getTitle()));

            $parent_method_name_camelized_and_prefix_test = sprintf('test%s', $parent_method_name);

            $this->dusk_class_and_methods[$scenario_index] = [
                'parent' => $parent_method_name_camelized_and_prefix_test,
                'parent_content' => $this->getParentLevelContent($parent_method_name_camelized_and_prefix_test)
            ];

            $this->buildOutSteps($scenario, $scenario_index);
        }
    }

    /**
     * @param $scenario \Behat\Gherkin\Node\ScenarioNode
     */
    protected function buildOutSteps($scenario, $scenario_index)
    {
        foreach ($scenario->getSteps() as $step_index => $step) {
            $method_name = camel_case(sprintf("%s %s", $step->getKeyword(), $step->getText()));
            $step_method_name_camalized = camel_case(sprintf("%s %s", $step->getKeyword(), $step->getText()));
            $this->dusk_class_and_methods[$scenario_index]['steps'][$step_index]['name'] =
                $method_name;
            $this->dusk_class_and_methods[$scenario_index]['steps'][$step_index] =
                $this->getStepLevelContent($step_method_name_camalized);
        }
    }

    private function buildDuskTestName()
    {
        if (!$this->dusk_test_name) {
            $name = $this->getFilesystem()->name($this->getFullPathToFileAndFileName());
            $this->dusk_test_name = ucfirst(camel_case($name) . 'Test');
        }
    }

    private function getFullPathToFileAndFileName()
    {
        return getcwd() . DIRECTORY_SEPARATOR . $this->getPathToFeature();
    }

    /**
     * @return mixed
     */
    public function getDuskClassAndMethods()
    {
        return $this->dusk_class_and_methods;
    }

    /**
     * @param mixed $dusk_class_and_methods
     */
    public function setDuskClassAndMethods($dusk_class_and_methods)
    {
        $this->dusk_class_and_methods = $dusk_class_and_methods;
    }

    /**
     * @return mixed
     */
    public function getDuskTestName()
    {
        return $this->dusk_test_name;
    }

    /**
     * @param mixed $dusk_test_name
     */
    public function setDuskTestName($dusk_test_name)
    {
        $this->dusk_test_name = $dusk_test_name;
    }

    public function getWriteBrowserTest()
    {

        if (!$this->write_browser_test) {
            $this->setWriteBrowserTest();
        }

        return $this->write_browser_test;
    }

    /**
     * @param null $write_browser_test
     * @return GherkinToDusk
     * @internal param WritePHPUnitFile $write_unit_test
     */
    public function setWriteBrowserTest($write_browser_test = null)
    {
        if (!$write_browser_test) {
            $write_browser_test = new WriteBrowserFile();
        }

        $this->write_browser_test = $write_browser_test;
        return $this;
    }

    public function getWriteUnitTest()
    {

        if (!$this->write_unit_test) {
            $this->setWriteUnitTest();
        }

        return $this->write_unit_test;
    }

    /**
     * @param WritePHPUnitFile $write_unit_test
     * @return GherkinToDusk
     */
    public function setWriteUnitTest($write_unit_test = null)
    {
        if (!$write_unit_test) {
            $write_unit_test = new WritePHPUnitFile();
        }

        $this->write_unit_test = $write_unit_test;
        return $this;
    }
}