Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

namespace tool_generator\local\testscenario;

use behat_data_generators;

use Behat\Gherkin\Parser;

use Behat\Gherkin\Lexer;

use Behat\Gherkin\Keywords\ArrayKeywords;

use Behat\Gherkin\Node\StepNode;

/**

 * Tests for steprunner class.

 *

 * @package tool_generator

 * @copyright 2023 Ferran Recio <ferran@moodel.com>

 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 * @coversDefaultClass \tool_generator\local\testscenario\steprunner

 */

final class steprunner_test extends \advanced_testcase {

    public static function setUpBeforeClass(): void {

        parent::setUpBeforeClass();

        // Call the init method to include all behat libraries and attributes.

        $runner = new runner();

        $runner->init();

    }

    /**

     * Get a step node from a string.

     * @param string $step the step string.

     * @return StepNode the step node.

     */

    private function get_step(string $step): StepNode {

        $content = 'Feature: Test feature

            Scenario: Test scenario

            ' . $step . '

        ';

        $method = new \ReflectionMethod(runner::class, 'get_parser');

        $parser = $method->invoke(new runner());

        $feature = $parser->parse($content);

        $scenario = $feature->getScenarios()[0];

        $steps = $scenario->getSteps();

        return $steps[0];

    }

    /**

     * Get the list of valid behat steps for the tests.

     * @return array the valid steps details.

     */

    private function get_valid_steps(): array {

        $generator = new behat_data_generators();

        return [

            '/^the following "(?P<element_string>(?:[^"]|\\")*)" exist:$/' => (object) [

                'name' => 'the_following_entities_exist',

                'given' => '/^the following "(?P<element_string>(?:[^"]|\\")*)" exist:$/',

                'generator' => $generator,

            ],

            ':count :entitytype exist with the following data:' => (object) [

                'name' => 'the_following_repeated_entities_exist',

                'given' => ':count :entitytype exist with the following data:',

                'generator' => $generator,

            ],

            'the following :entitytype exists:' => (object) [

                'name' => 'the_following_entity_exists',

                'given' => 'the following :entitytype exists:',

                'generator' => $generator,

            ],

        ];

    }

    /**

     * Test for parse_feature.

     * @covers ::is_valid

     * @param string $step the step to validate.

     * @param bool $expected if the step is expected to be valid.

     * @dataProvider execute_steps_provider

     */

    public function test_is_valid(string $step, bool $expected): void {

        $validsteps = $this->get_valid_steps();

        $step = $this->get_step($step);

        $steprunner = new steprunner(null, $validsteps, $step);

        $this->assertEquals($expected, $steprunner->is_valid());

    }

    /**

     * Test for execute step.

     *

     * @covers ::is_executed

     * @covers ::execute

     * @param string $step the step to execute.

     * @param bool $expected if the step is expected to be executed.

     * @dataProvider execute_steps_provider

     */

    public function test_execute(string $step, bool $expected): void {

        global $DB;

        $this->resetAfterTest();

        $validsteps = $this->get_valid_steps();

        $step = $this->get_step($step);

        $steprunner = new steprunner(null, $validsteps, $step);

        $this->assertFalse($steprunner->is_executed());

        $result = $steprunner->execute();

        $this->assertEquals($expected, $result);

        $this->assertEquals($expected, $steprunner->is_executed());

        if ($expected) {

            // Validate everything is created.

            $this->assertEquals(

                1,

                $DB->count_records('course', ['shortname' => 'C1'])

            );

        }

    }

    /**

     * Data provider for test_execute.

     * @return array the data.

     */

    public static function execute_steps_provider(): array {

        return [

            'Following exists' => [

                'step' => 'Given the following "course" exists:

                    | fullname         | Course test |

                    | shortname        | C1          |

                    | category         | 0           |',

                'expected' => true,

            ],

            'Following exist' => [

                'step' => 'Given the following "course" exist:

                    | fullname         | shortname | category |

                    | Course test      | C1        | 0        |',

                'expected' => true,

            ],

            'Repeated entities' => [

                'step' => 'Given "1" "courses" exist with the following data:

                    | fullname    | Course test |

                    | shortname   | C[count]    |

                    | category    | 0           |

                    | numsections | 3           |',

                'expected' => true,

            ],

            'Invalid step' => [

                'step' => 'Given I click on "Tokens filter" "link"',

                'expected' => false,

            ],

        ];

    }

    /**

     * Test for execute step.

     * @covers ::is_executed

     * @covers ::execute

     * @covers ::get_error

     */

    public function test_execute_duplicated(): void {

        global $DB;

        $this->resetAfterTest();

        $validsteps = $this->get_valid_steps();

        $step = $this->get_step('Given the following "course" exists:

            | fullname         | Course test |

            | shortname        | C1          |

            | category         | 0           |');

        $steprunner = new steprunner(null, $validsteps, $step);

        $this->assertFalse($steprunner->is_executed());

        $result = $steprunner->execute();

        $this->assertTrue($result);

        $this->assertTrue($steprunner->is_executed());

        $this->assertEquals('', $steprunner->get_error());

        // Validate everything is created.

        $this->assertEquals(

            1,

            $DB->count_records('course', ['shortname' => 'C1'])

        );

        // Execute the same course creation.

        $steprunner = new steprunner(null, $validsteps, $step);

        $this->assertFalse($steprunner->is_executed());

        $result = $steprunner->execute();

        $this->assertFalse($result);

        $this->assertTrue($steprunner->is_executed());

        $this->assertEquals(get_string('shortnametaken', 'error', 'C1'), $steprunner->get_error());

    }

    /**

     * Test for parse_feature.

     * @covers ::get_text

     * @covers ::get_arguments_string

     */

    public function test_get_step_content(): void {

        $step = $this->get_step('Given the following "course" exists:

        | fullname    | Course test |

        | shortname   | C1          |

        | category    | 0           |

        | numsections | 3           |');

        $validsteps = $this->get_valid_steps();

        $steprunner = new steprunner(null, $validsteps, $step);

        $this->assertEquals(

            'the following "course" exists:',

            $steprunner->get_text()

        );

        $data = [

            '| fullname    | Course test |',

            '| shortname   | C1          |',

            '| category    | 0           |',

            '| numsections | 3           |',

        ];

        $arguments = explode("\n", $steprunner->get_arguments_string());

        $this->assertEquals(

            $data,

            $arguments

        );

    }

}