Mark Nelson
49875e3a89
1. Added new step definitions to check if an element exists or does not exist in another. 2. Added new step definitions to check if an element is readonly or is not readonly. 3. Automated testing for MDLQA-1812 and MDLQA-1813. Added behat test for deleting groups/groupings with and without the 'moodle/course:changeidnumber' capability. 4. Automated MDLQA-2105. Added behat test for creating groups/groupings without the 'moodle/course:changeidnumber' capability. 5. Automated MDLQA-2238 and MDLQA-2335. Added behat test for updating groups/groupings with and without the 'moodle/course:changeidnumber' capability.
624 lines
27 KiB
PHP
624 lines
27 KiB
PHP
<?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/>.
|
|
|
|
/**
|
|
* General use steps definitions.
|
|
*
|
|
* @package core
|
|
* @category test
|
|
* @copyright 2012 David Monllaó
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
// NOTE: no MOODLE_INTERNAL test here, this file may be required by behat before including /config.php.
|
|
|
|
require_once(__DIR__ . '/../../behat/behat_base.php');
|
|
|
|
use Behat\Mink\Exception\ExpectationException as ExpectationException,
|
|
Behat\Mink\Exception\ElementNotFoundException as ElementNotFoundException,
|
|
Behat\Mink\Exception\DriverException as DriverException,
|
|
WebDriver\Exception\NoSuchElement as NoSuchElement,
|
|
WebDriver\Exception\StaleElementReference as StaleElementReference;
|
|
|
|
/**
|
|
* Cross component steps definitions.
|
|
*
|
|
* Basic web application definitions from MinkExtension and
|
|
* BehatchExtension. Definitions modified according to our needs
|
|
* when necessary and including only the ones we need to avoid
|
|
* overlapping and confusion.
|
|
*
|
|
* @package core
|
|
* @category test
|
|
* @copyright 2012 David Monllaó
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class behat_general extends behat_base {
|
|
|
|
/**
|
|
* Opens Moodle homepage.
|
|
*
|
|
* @Given /^I am on homepage$/
|
|
*/
|
|
public function i_am_on_homepage() {
|
|
$this->getSession()->visit($this->locate_path('/'));
|
|
}
|
|
|
|
/**
|
|
* Reloads the current page.
|
|
*
|
|
* @Given /^I reload the page$/
|
|
*/
|
|
public function reload() {
|
|
$this->getSession()->reload();
|
|
}
|
|
|
|
/**
|
|
* Follows the page redirection. Use this step after any action that shows a message and waits for a redirection
|
|
*
|
|
* @Given /^I wait to be redirected$/
|
|
*/
|
|
public function i_wait_to_be_redirected() {
|
|
|
|
// Xpath and processes based on core_renderer::redirect_message(), core_renderer::$metarefreshtag and
|
|
// moodle_page::$periodicrefreshdelay possible values.
|
|
if (!$metarefresh = $this->getSession()->getPage()->find('xpath', "//head/descendant::meta[@http-equiv='refresh']")) {
|
|
// We don't fail the scenario if no redirection with message is found to avoid race condition false failures.
|
|
return false;
|
|
}
|
|
|
|
// Wrapped in try & catch in case the redirection has already been executed.
|
|
try {
|
|
$content = $metarefresh->getAttribute('content');
|
|
} catch (NoSuchElement $e) {
|
|
return false;
|
|
} catch (StaleElementReference $e) {
|
|
return false;
|
|
}
|
|
|
|
// Getting the refresh time and the url if present.
|
|
if (strstr($content, 'url') != false) {
|
|
|
|
list($waittime, $url) = explode(';', $content);
|
|
|
|
// Cleaning the URL value.
|
|
$url = trim(substr($url, strpos($url, 'http')));
|
|
|
|
} else {
|
|
// Just wait then.
|
|
$waittime = $content;
|
|
}
|
|
|
|
|
|
// Wait until the URL change is executed.
|
|
if ($this->running_javascript()) {
|
|
$this->getSession()->wait($waittime * 1000, false);
|
|
|
|
} else if (!empty($url)) {
|
|
// We redirect directly as we can not wait for an automatic redirection.
|
|
$this->getSession()->getDriver()->getClient()->request('get', $url);
|
|
|
|
} else {
|
|
// Reload the page if no URL was provided.
|
|
$this->getSession()->getDriver()->reload();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Switches to the specified window. Useful when interacting with popup windows.
|
|
*
|
|
* @Given /^I switch to "(?P<window_name_string>(?:[^"]|\\")*)" window$/
|
|
* @param string $windowname
|
|
*/
|
|
public function switch_to_window($windowname) {
|
|
$this->getSession()->switchToWindow($windowname);
|
|
}
|
|
|
|
/**
|
|
* Switches to the main Moodle window. Useful when you finish interacting with popup windows.
|
|
*
|
|
* @Given /^I switch to the main window$/
|
|
*/
|
|
public function switch_to_the_main_window() {
|
|
$this->getSession()->switchToWindow();
|
|
}
|
|
|
|
/**
|
|
* Accepts the currently displayed alert dialog. This step does not work in all the browsers, consider it experimental.
|
|
* @Given /^I accept the currently displayed dialog$/
|
|
*/
|
|
public function accept_currently_displayed_alert_dialog() {
|
|
$this->getSession()->getDriver()->getWebDriverSession()->accept_alert();
|
|
}
|
|
|
|
/**
|
|
* Clicks link with specified id|title|alt|text.
|
|
*
|
|
* @When /^I follow "(?P<link_string>(?:[^"]|\\")*)"$/
|
|
* @throws ElementNotFoundException Thrown by behat_base::find
|
|
* @param string $link
|
|
*/
|
|
public function click_link($link) {
|
|
|
|
$linknode = $this->find_link($link);
|
|
$linknode->click();
|
|
}
|
|
|
|
/**
|
|
* Waits X seconds. Required after an action that requires data from an AJAX request.
|
|
*
|
|
* @Then /^I wait "(?P<seconds_number>\d+)" seconds$/
|
|
* @param int $seconds
|
|
*/
|
|
public function i_wait_seconds($seconds) {
|
|
|
|
if (!$this->running_javascript()) {
|
|
throw new DriverException('Waits are disabled in scenarios without Javascript support');
|
|
}
|
|
|
|
$this->getSession()->wait($seconds * 1000, false);
|
|
}
|
|
|
|
/**
|
|
* Waits until the page is completely loaded. This step is auto-executed after every step.
|
|
*
|
|
* @Given /^I wait until the page is ready$/
|
|
*/
|
|
public function wait_until_the_page_is_ready() {
|
|
|
|
if (!$this->running_javascript()) {
|
|
throw new DriverException('Waits are disabled in scenarios without Javascript support');
|
|
}
|
|
|
|
$this->getSession()->wait(self::TIMEOUT, '(document.readyState === "complete")');
|
|
}
|
|
|
|
/**
|
|
* Generic mouse over action. Mouse over a element of the specified type.
|
|
*
|
|
* @When /^I hover "(?P<element_string>(?:[^"]|\\")*)" "(?P<selector_string>[^"]*)"$/
|
|
* @param string $element Element we look for
|
|
* @param string $selectortype The type of what we look for
|
|
*/
|
|
public function i_hover($element, $selectortype) {
|
|
|
|
// Gets the node based on the requested selector type and locator.
|
|
$node = $this->get_selected_node($selectortype, $element);
|
|
$node->mouseOver();
|
|
}
|
|
|
|
/**
|
|
* Generic click action. Click on the element of the specified type.
|
|
*
|
|
* @When /^I click on "(?P<element_string>(?:[^"]|\\")*)" "(?P<selector_string>[^"]*)"$/
|
|
* @param string $element Element we look for
|
|
* @param string $selectortype The type of what we look for
|
|
*/
|
|
public function i_click_on($element, $selectortype) {
|
|
|
|
// Gets the node based on the requested selector type and locator.
|
|
$node = $this->get_selected_node($selectortype, $element);
|
|
$node->click();
|
|
}
|
|
|
|
/**
|
|
* Click on the element of the specified type which is located inside the second element.
|
|
*
|
|
* @When /^I click on "(?P<element_string>(?:[^"]|\\")*)" "(?P<selector_string>[^"]*)" in the "(?P<element_container_string>(?:[^"]|\\")*)" "(?P<text_selector_string>[^"]*)"$/
|
|
* @param string $element Element we look for
|
|
* @param string $selectortype The type of what we look for
|
|
* @param string $nodeelement Element we look in
|
|
* @param string $nodeselectortype The type of selector where we look in
|
|
*/
|
|
public function i_click_on_in_the($element, $selectortype, $nodeelement, $nodeselectortype) {
|
|
|
|
$node = $this->get_node_in_container($selectortype, $element, $nodeselectortype, $nodeelement);
|
|
$node->click();
|
|
}
|
|
|
|
/**
|
|
* Click on the specified element inside a table row containing the specified text.
|
|
*
|
|
* @Given /^I click on "(?P<element_string>(?:[^"]|\\")*)" "(?P<selector_string>(?:[^"]|\\")*)" in the "(?P<row_text_string>(?:[^"]|\\")*)" table row$/
|
|
* @throws ElementNotFoundException
|
|
* @param string $element Element we look for
|
|
* @param string $selectortype The type of what we look for
|
|
* @param string $tablerowtext The table row text
|
|
*/
|
|
public function i_click_on_in_the_table_row($element, $selectortype, $tablerowtext) {
|
|
|
|
// The table row container.
|
|
$nocontainerexception = new ElementNotFoundException($this->getSession(), '"' . $tablerowtext . '" row text ');
|
|
$tablerowtext = $this->getSession()->getSelectorsHandler()->xpathLiteral($tablerowtext);
|
|
$rownode = $this->find('xpath', "//tr[contains(., $tablerowtext)]", $nocontainerexception);
|
|
|
|
// Looking for the element DOM node inside the specified row.
|
|
list($selector, $locator) = $this->transform_selector($selectortype, $element);
|
|
$elementnode = $this->find($selector, $locator, false, $rownode);
|
|
$elementnode->click();
|
|
}
|
|
|
|
/**
|
|
* Drags and drops the specified element to the specified container. This step does not work in all the browsers, consider it experimental.
|
|
*
|
|
* The steps definitions calling this step as part of them should
|
|
* manage the wait times by themselves as the times and when the
|
|
* waits should be done depends on what is being dragged & dropper.
|
|
*
|
|
* @Given /^I drag "(?P<element_string>(?:[^"]|\\")*)" "(?P<selector1_string>(?:[^"]|\\")*)" and I drop it in "(?P<container_element_string>(?:[^"]|\\")*)" "(?P<selector2_string>(?:[^"]|\\")*)"$/
|
|
* @param string $element
|
|
* @param string $selectortype
|
|
* @param string $containerelement
|
|
* @param string $containerselectortype
|
|
*/
|
|
public function i_drag_and_i_drop_it_in($element, $selectortype, $containerelement, $containerselectortype) {
|
|
|
|
list($sourceselector, $sourcelocator) = $this->transform_selector($selectortype, $element);
|
|
$sourcexpath = $this->getSession()->getSelectorsHandler()->selectorToXpath($sourceselector, $sourcelocator);
|
|
|
|
list($containerselector, $containerlocator) = $this->transform_selector($containerselectortype, $containerelement);
|
|
$destinationxpath = $this->getSession()->getSelectorsHandler()->selectorToXpath($containerselector, $containerlocator);
|
|
|
|
$this->getSession()->getDriver()->dragTo($sourcexpath, $destinationxpath);
|
|
}
|
|
|
|
/**
|
|
* Checks, that page contains specified text. It also checks if the text is visible when running Javascript tests.
|
|
*
|
|
* @Then /^I should see "(?P<text_string>(?:[^"]|\\")*)"$/
|
|
* @throws ExpectationException
|
|
* @param string $text
|
|
*/
|
|
public function assert_page_contains_text($text) {
|
|
|
|
// Looking for all the matching nodes without any other descendant matching the
|
|
// same xpath (we are using contains(., ....).
|
|
$xpathliteral = $this->getSession()->getSelectorsHandler()->xpathLiteral($text);
|
|
$xpath = "/descendant-or-self::*[contains(., $xpathliteral)]" .
|
|
"[count(descendant::*[contains(., $xpathliteral)]) = 0]";
|
|
|
|
// Wait until it finds the text, otherwise custom exception.
|
|
try {
|
|
$nodes = $this->find_all('xpath', $xpath);
|
|
|
|
// We also check for the element visibility when running JS tests.
|
|
if ($this->running_javascript()) {
|
|
foreach ($nodes as $node) {
|
|
if ($node->isVisible()) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
throw new ExpectationException("'{$text}' text was found but was not visible", $this->getSession());
|
|
}
|
|
|
|
} catch (ElementNotFoundException $e) {
|
|
throw new ExpectationException('"' . $text . '" text was not found in the page', $this->getSession());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks, that page doesn't contain specified text. When running Javascript tests it also considers that texts may be hidden.
|
|
*
|
|
* @Then /^I should not see "(?P<text_string>(?:[^"]|\\")*)"$/
|
|
* @throws ExpectationException
|
|
* @param string $text
|
|
*/
|
|
public function assert_page_not_contains_text($text) {
|
|
|
|
// Delegating the process to assert_page_contains_text.
|
|
try {
|
|
$this->assert_page_contains_text($text);
|
|
} catch (ExpectationException $e) {
|
|
// It should not appear, so this is good.
|
|
return;
|
|
}
|
|
|
|
// If the page contains the text this is failing.
|
|
throw new ExpectationException('"' . $text . '" text was found in the page', $this->getSession());
|
|
}
|
|
|
|
/**
|
|
* Checks, that the specified element contains the specified text. When running Javascript tests it also considers that texts may be hidden.
|
|
*
|
|
* @Then /^I should see "(?P<text_string>(?:[^"]|\\")*)" in the "(?P<element_string>(?:[^"]|\\")*)" "(?P<text_selector_string>[^"]*)"$/
|
|
* @throws ElementNotFoundException
|
|
* @throws ExpectationException
|
|
* @param string $text
|
|
* @param string $element Element we look in.
|
|
* @param string $selectortype The type of element where we are looking in.
|
|
*/
|
|
public function assert_element_contains_text($text, $element, $selectortype) {
|
|
|
|
// Getting the container where the text should be found.
|
|
$container = $this->get_selected_node($selectortype, $element);
|
|
|
|
// Looking for all the matching nodes without any other descendant matching the
|
|
// same xpath (we are using contains(., ....).
|
|
$xpathliteral = $this->getSession()->getSelectorsHandler()->xpathLiteral($text);
|
|
$xpath = "/descendant-or-self::*[contains(., $xpathliteral)]" .
|
|
"[count(descendant::*[contains(., $xpathliteral)]) = 0]";
|
|
|
|
// Wait until it finds the text inside the container, otherwise custom exception.
|
|
try {
|
|
$nodes = $this->find_all('xpath', $xpath, false, $container);
|
|
|
|
// We also check for the element visibility when running JS tests.
|
|
if ($this->running_javascript()) {
|
|
foreach ($nodes as $node) {
|
|
if ($node->isVisible()) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
throw new ExpectationException("'{$text}' text was found in the {$element} element but was not visible", $this->getSession());
|
|
}
|
|
|
|
} catch (ElementNotFoundException $e) {
|
|
throw new ExpectationException('"' . $text . '" text was not found in the ' . $element . ' element', $this->getSession());
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Checks, that the specified element does not contain the specified text. When running Javascript tests it also considers that texts may be hidden.
|
|
*
|
|
* @Then /^I should not see "(?P<text_string>(?:[^"]|\\")*)" in the "(?P<element_string>(?:[^"]|\\")*)" "(?P<text_selector_string>[^"]*)"$/
|
|
* @throws ElementNotFoundException
|
|
* @throws ExpectationException
|
|
* @param string $text
|
|
* @param string $element Element we look in.
|
|
* @param string $selectortype The type of element where we are looking in.
|
|
*/
|
|
public function assert_element_not_contains_text($text, $element, $selectortype) {
|
|
|
|
// Delegating the process to assert_element_contains_text.
|
|
try {
|
|
$this->assert_element_contains_text($text, $element, $selectortype);
|
|
} catch (ExpectationException $e) {
|
|
// It should not appear, so this is good.
|
|
// We only catch ExpectationException as ElementNotFoundException
|
|
// will be thrown if the container does not exist.
|
|
return;
|
|
}
|
|
|
|
// If the element contains the text this is failing.
|
|
throw new ExpectationException('"' . $text . '" text was found in the ' . $element . ' element', $this->getSession());
|
|
}
|
|
|
|
/**
|
|
* Checks, that the first specified element appears before the second one.
|
|
*
|
|
* @Given /^"(?P<preceding_element_string>(?:[^"]|\\")*)" "(?P<selector1_string>(?:[^"]|\\")*)" should appear before "(?P<following_element_string>(?:[^"]|\\")*)" "(?P<selector2_string>(?:[^"]|\\")*)"$/
|
|
* @throws ExpectationException
|
|
* @param string $preelement The locator of the preceding element
|
|
* @param string $preselectortype The locator of the preceding element
|
|
* @param string $postelement The locator of the latest element
|
|
* @param string $postselectortype The selector type of the latest element
|
|
*/
|
|
public function should_appear_before($preelement, $preselectortype, $postelement, $postselectortype) {
|
|
|
|
// We allow postselectortype as a non-text based selector.
|
|
list($preselector, $prelocator) = $this->transform_selector($preselectortype, $preelement);
|
|
list($postselector, $postlocator) = $this->transform_selector($postselectortype, $postelement);
|
|
|
|
$prexpath = $this->find($preselector, $prelocator)->getXpath();
|
|
$postxpath = $this->find($postselector, $postlocator)->getXpath();
|
|
|
|
// Using following xpath axe to find it.
|
|
$msg = '"'.$preelement.'" "'.$preselectortype.'" does not appear before "'.$postelement.'" "'.$postselectortype.'"';
|
|
$xpath = $prexpath.'/following::*[contains(., '.$postxpath.')]';
|
|
if (!$this->getSession()->getDriver()->find($xpath)) {
|
|
throw new ExpectationException($msg, $this->getSession());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks, that the first specified element appears after the second one.
|
|
*
|
|
* @Given /^"(?P<following_element_string>(?:[^"]|\\")*)" "(?P<selector1_string>(?:[^"]|\\")*)" should appear after "(?P<preceding_element_string>(?:[^"]|\\")*)" "(?P<selector2_string>(?:[^"]|\\")*)"$/
|
|
* @throws ExpectationException
|
|
* @param string $postelement The locator of the latest element
|
|
* @param string $postselectortype The selector type of the latest element
|
|
* @param string $preelement The locator of the preceding element
|
|
* @param string $preselectortype The locator of the preceding element
|
|
*/
|
|
public function should_appear_after($postelement, $postselectortype, $preelement, $preselectortype) {
|
|
|
|
// We allow postselectortype as a non-text based selector.
|
|
list($postselector, $postlocator) = $this->transform_selector($postselectortype, $postelement);
|
|
list($preselector, $prelocator) = $this->transform_selector($preselectortype, $preelement);
|
|
|
|
$postxpath = $this->find($postselector, $postlocator)->getXpath();
|
|
$prexpath = $this->find($preselector, $prelocator)->getXpath();
|
|
|
|
// Using preceding xpath axe to find it.
|
|
$msg = '"'.$postelement.'" "'.$postselectortype.'" does not appear after "'.$preelement.'" "'.$preselectortype.'"';
|
|
$xpath = $postxpath.'/preceding::*[contains(., '.$prexpath.')]';
|
|
if (!$this->getSession()->getDriver()->find($xpath)) {
|
|
throw new ExpectationException($msg, $this->getSession());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks, that element of specified type is disabled.
|
|
*
|
|
* @Then /^the "(?P<element_string>(?:[^"]|\\")*)" "(?P<selector_string>[^"]*)" should be disabled$/
|
|
* @throws ExpectationException Thrown by behat_base::find
|
|
* @param string $element Element we look in
|
|
* @param string $selectortype The type of element where we are looking in.
|
|
*/
|
|
public function the_element_should_be_disabled($element, $selectortype) {
|
|
|
|
// Transforming from steps definitions selector/locator format to Mink format and getting the NodeElement.
|
|
$node = $this->get_selected_node($selectortype, $element);
|
|
|
|
if (!$node->hasAttribute('disabled')) {
|
|
throw new ExpectationException('The element "' . $element . '" is not disabled', $this->getSession());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks, that element of specified type is enabled.
|
|
*
|
|
* @Then /^the "(?P<element_string>(?:[^"]|\\")*)" "(?P<selector_string>[^"]*)" should be enabled$/
|
|
* @throws ExpectationException Thrown by behat_base::find
|
|
* @param string $element Element we look on
|
|
* @param string $selectortype The type of where we look
|
|
*/
|
|
public function the_element_should_be_enabled($element, $selectortype) {
|
|
|
|
// Transforming from steps definitions selector/locator format to mink format and getting the NodeElement.
|
|
$node = $this->get_selected_node($selectortype, $element);
|
|
|
|
if ($node->hasAttribute('disabled')) {
|
|
throw new ExpectationException('The element "' . $element . '" is not enabled', $this->getSession());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks the provided element and selector type are readonly on the current page.
|
|
*
|
|
* @Then /^the "(?P<element_string>(?:[^"]|\\")*)" "(?P<selector_string>[^"]*)" should be readonly$/
|
|
* @throws ExpectationException Thrown by behat_base::find
|
|
* @param string $element Element we look in
|
|
* @param string $selectortype The type of element where we are looking in.
|
|
*/
|
|
public function the_element_should_be_readonly($element, $selectortype) {
|
|
// Transforming from steps definitions selector/locator format to Mink format and getting the NodeElement.
|
|
$node = $this->get_selected_node($selectortype, $element);
|
|
|
|
if (!$node->hasAttribute('readonly')) {
|
|
throw new ExpectationException('The element "' . $element . '" is not readonly', $this->getSession());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks the provided element and selector type are not readonly on the current page.
|
|
*
|
|
* @Then /^the "(?P<element_string>(?:[^"]|\\")*)" "(?P<selector_string>[^"]*)" should not be readonly$/
|
|
* @throws ExpectationException Thrown by behat_base::find
|
|
* @param string $element Element we look in
|
|
* @param string $selectortype The type of element where we are looking in.
|
|
*/
|
|
public function the_element_should_not_be_readonly($element, $selectortype) {
|
|
// Transforming from steps definitions selector/locator format to Mink format and getting the NodeElement.
|
|
$node = $this->get_selected_node($selectortype, $element);
|
|
|
|
if ($node->hasAttribute('readonly')) {
|
|
throw new ExpectationException('The element "' . $element . '" is readonly', $this->getSession());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks the provided element and selector type exists in the current page.
|
|
*
|
|
* This step is for advanced users, use it if you don't find anything else suitable for what you need.
|
|
*
|
|
* @Then /^"(?P<element_string>(?:[^"]|\\")*)" "(?P<selector_string>[^"]*)" should exists$/
|
|
* @throws ElementNotFoundException Thrown by behat_base::find
|
|
* @param string $element The locator of the specified selector
|
|
* @param string $selectortype The selector type
|
|
*/
|
|
public function should_exists($element, $selectortype) {
|
|
|
|
// Getting Mink selector and locator.
|
|
list($selector, $locator) = $this->transform_selector($selectortype, $element);
|
|
|
|
// Will throw an ElementNotFoundException if it does not exist.
|
|
$this->find($selector, $locator);
|
|
}
|
|
|
|
/**
|
|
* Checks that the provided element and selector type not exists in the current page.
|
|
*
|
|
* This step is for advanced users, use it if you don't find anything else suitable for what you need.
|
|
*
|
|
* @Then /^"(?P<element_string>(?:[^"]|\\")*)" "(?P<selector_string>[^"]*)" should not exists$/
|
|
* @throws ExpectationException
|
|
* @param string $element The locator of the specified selector
|
|
* @param string $selectortype The selector type
|
|
*/
|
|
public function should_not_exists($element, $selectortype) {
|
|
|
|
try {
|
|
$this->should_exists($element, $selectortype);
|
|
throw new ExpectationException('The "' . $element . '" "' . $selectortype . '" exists in the current page', $this->getSession());
|
|
} catch (ElementNotFoundException $e) {
|
|
// It passes.
|
|
return;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This step triggers cron like a user would do going to admin/cron.php.
|
|
*
|
|
* @Given /^I trigger cron$/
|
|
*/
|
|
public function i_trigger_cron() {
|
|
$this->getSession()->visit($this->locate_path('/admin/cron.php'));
|
|
}
|
|
|
|
/**
|
|
* Checks that an element and selector type exists in another element and selector type on the current page.
|
|
*
|
|
* This step is for advanced users, use it if you don't find anything else suitable for what you need.
|
|
*
|
|
* @Then /^"(?P<element_string>(?:[^"]|\\")*)" "(?P<selector_string>[^"]*)" should exist in the "(?P<element2_string>(?:[^"]|\\")*)" "(?P<selector2_string>[^"]*)"$/
|
|
* @throws ElementNotFoundException Thrown by behat_base::find
|
|
* @param string $element The locator of the specified selector
|
|
* @param string $selectortype The selector type
|
|
* @param string $containerelement The container selector type
|
|
* @param string $containerselectortype The container locator
|
|
*/
|
|
public function should_exist_in_the($element, $selectortype, $containerelement, $containerselectortype) {
|
|
// Get the container node.
|
|
$containernode = $this->get_selected_node($containerselectortype, $containerelement);
|
|
|
|
list($selector, $locator) = $this->transform_selector($selectortype, $element);
|
|
|
|
// Specific exception giving info about where can't we find the element.
|
|
$locatorexceptionmsg = $element . '" in the "' . $containerelement. '" "' . $containerselectortype. '"';
|
|
$exception = new ElementNotFoundException($this->getSession(), $selectortype, null, $locatorexceptionmsg);
|
|
|
|
// Looks for the requested node inside the container node.
|
|
$this->find($selector, $locator, $exception, $containernode);
|
|
}
|
|
|
|
/**
|
|
* Checks that an element and selector type does not exist in another element and selector type on the current page.
|
|
*
|
|
* This step is for advanced users, use it if you don't find anything else suitable for what you need.
|
|
*
|
|
* @Then /^"(?P<element_string>(?:[^"]|\\")*)" "(?P<selector_string>[^"]*)" should not exist in the "(?P<element2_string>(?:[^"]|\\")*)" "(?P<selector2_string>[^"]*)"$/
|
|
* @throws ExpectationException
|
|
* @param string $element The locator of the specified selector
|
|
* @param string $selectortype The selector type
|
|
* @param string $containerelement The container selector type
|
|
* @param string $containerselectortype The container locator
|
|
*/
|
|
public function should_not_exist_in_the($element, $selectortype, $containerelement, $containerselectortype) {
|
|
try {
|
|
$this->should_exist_in_the($element, $selectortype, $containerelement, $containerselectortype);
|
|
throw new ExpectationException('The "' . $element . '" "' . $selectortype . '" exists in the "' .
|
|
$containerelement . '" "' . $containerselectortype . '"', $this->getSession());
|
|
} catch (ElementNotFoundException $e) {
|
|
// It passes.
|
|
return;
|
|
}
|
|
}
|
|
}
|