WebInterface,

RemoteInterface,

MultiSessionInterface,

SessionSnapshot,

ScreenshotSaver,

PageSourceSaver,

ElementLocator,

ConflictsWithModule,

RequiresPackage

{

protected $requiredFields = ['browser', 'url'];

protected $config = [

'protocol' => 'http',

'host' => '127.0.0.1',

'port' => '4444',

'path' => '/wd/hub',

'start' => true,

'restart' => false,

'wait' => 0,

'clear_cookies' => true,

'window_size' => false,

'capabilities' => [],

'connection_timeout' => null,

'request_timeout' => null,

'pageload_timeout' => null,

'http_proxy' => null,

'http_proxy_port' => null,

'ssl_proxy' => null,

'ssl_proxy_port' => null,

'debug_log_entries' => 15,

'log_js_errors' => false

];

protected $wdHost;

protected $capabilities;

protected $connectionTimeoutInMs;

protected $requestTimeoutInMs;

protected $test;

protected $sessions = [];

protected $sessionSnapshots = [];

protected $httpProxy;

protected $httpProxyPort;

protected $sslProxy;

protected $sslProxyPort;

/**

public $webDriver;

/**

protected $baseElement;

public function _requires()

{

return ['Facebook\WebDriver\Remote\RemoteWebDriver' => '"facebook/webdriver": "^1.0.1"'];

}

public function _initialize()

{

$this->wdHost = sprintf('%s://%s:%s%s', $this->config['protocol'], $this->config['host'], $this->config['port'], $this->config['path']);

$this->capabilities = $this->config['capabilities'];

$this->capabilities[WebDriverCapabilityType::BROWSER_NAME] = $this->config['browser'];

if ($proxy = $this->getProxy()) {

$this->capabilities[WebDriverCapabilityType::PROXY] = $proxy;

}

$this->connectionTimeoutInMs = $this->config['connection_timeout'] * 1000;

$this->requestTimeoutInMs = $this->config['request_timeout'] * 1000;

$this->loadFirefoxProfile();

}

/**

public function _capabilities(\Closure $capabilityFunction)

{

$this->capabilities = $capabilityFunction($this->capabilities);

}

public function _conflicts()

{

return 'Codeception\Lib\Interfaces\Web';

}

public function _before(TestInterface $test)

{

if (!isset($this->webDriver) && $this->config['start']) {

$this->_initializeSession();

}

$this->setBaseElement();

if (method_exists($this->webDriver, 'getCapabilities')) {

$browser = $this->webDriver->getCapabilities()->getBrowserName();

$capabilities = $this->webDriver->getCapabilities()->toArray();

} else {

//Used with facebook/php-webdriver <1.3.0 (usually on PHP 5.4)

$browser = $this->config['browser'];

$capabilities = $this->config['capabilities'];

}

$test->getMetadata()->setCurrent([

'browser' => $browser,

'capabilities' => $capabilities,

]);

}

/**

public function _restart($config = [])

{

$this->webDriver->quit();

if (!empty($config)) {

$this->_reconfigure($config);

}

$this->_initializeSession();

}

protected function onReconfigure()

{

$this->_initialize();

}

protected function loadFirefoxProfile()

{

if (!array_key_exists('firefox_profile', $this->config['capabilities'])) {

return;

}

$firefox_profile = $this->config['capabilities']['firefox_profile'];

if (file_exists($firefox_profile) === false) {

throw new ModuleConfigException(

__CLASS__,

"Firefox profile does not exist under given path " . $firefox_profile

);

}

// Set firefox profile as capability

$this->capabilities['firefox_profile'] = file_get_contents($firefox_profile);

}

protected function initialWindowSize()

{

if ($this->config['window_size'] == 'maximize') {

$this->maximizeWindow();

return;

}

$size = explode('x', $this->config['window_size']);

if (count($size) == 2) {

$this->resizeWindow(intval($size[0]), intval($size[1]));

}

}

public function _after(TestInterface $test)

{

if ($this->config['restart']) {

$this->stopAllSessions();

return;

}

if ($this->config['clear_cookies'] && isset($this->webDriver)) {

$this->webDriver->manage()->deleteAllCookies();

}

}

public function _failed(TestInterface $test, $fail)

{

$this->debugWebDriverLogs($test);

$filename = preg_replace('~\W~', '.', Descriptor::getTestSignatureUnique($test));

$outputDir = codecept_output_dir();

$this->_saveScreenshot($report = $outputDir . mb_strcut($filename, 0, 245, 'utf-8') . '.fail.png');

$test->getMetadata()->addReport('png', $report);

$this->_savePageSource($report = $outputDir . mb_strcut($filename, 0, 244, 'utf-8') . '.fail.html');

$test->getMetadata()->addReport('html', $report);

$this->debug("Screenshot and page source were saved into '$outputDir' dir");

}

/**

public function debugWebDriverLogs(TestInterface $test = null)

{

if (!isset($this->webDriver)) {

$this->debug('WebDriver::debugWebDriverLogs method has been called when webDriver is not set');

return;

}

try {

// Dump out latest Selenium logs

$logs = $this->webDriver->manage()->getAvailableLogTypes();

foreach ($logs as $logType) {

$logEntries = array_slice(

$this->webDriver->manage()->getLog($logType),

-$this->config['debug_log_entries']

);

if (empty($logEntries)) {

$this->debugSection("Selenium {$logType} Logs", " EMPTY ");

continue;

}

$this->debugSection("Selenium {$logType} Logs", "\n" . $this->formatLogEntries($logEntries));

if ($logType === 'browser' && $this->config['log_js_errors']

&& ($test instanceof ScenarioDriven)

) {

$this->logJSErrors($test, $logEntries);

}

}

} catch (\Exception $e) {

$this->debug('Unable to retrieve Selenium logs : ' . $e->getMessage());

}

}

/**

protected function formatLogEntries(array $logEntries)

{

$formattedLogs = '';

foreach ($logEntries as $logEntry) {

// Timestamp is in milliseconds, but date() requires seconds.

$time = date('H:i:s', $logEntry['timestamp'] / 1000) .

// Append the milliseconds to the end of the time string

'.' . ($logEntry['timestamp'] % 1000);

$formattedLogs .= "{$time} {$logEntry['level']} - {$logEntry['message']}\n";

}

return $formattedLogs;

}

/**

protected function logJSErrors(ScenarioDriven $test, array $browserLogEntries)

{

foreach ($browserLogEntries as $logEntry) {

if (true === isset($logEntry['level'])

&& true === isset($logEntry['message'])

&& $this->isJSError($logEntry['level'], $logEntry['message'])

) {

// Timestamp is in milliseconds, but date() requires seconds.

$time = date('H:i:s', $logEntry['timestamp'] / 1000) .

// Append the milliseconds to the end of the time string

'.' . ($logEntry['timestamp'] % 1000);

$test->getScenario()->comment("{$time} {$logEntry['level']} - {$logEntry['message']}");

}

}

}

/**

protected function isJSError($logEntryLevel, $message)

{

return

(

($this->isPhantom() && $logEntryLevel != 'INFO') // phantomjs logs errors as "WARNING"

|| $logEntryLevel === 'SEVERE' // other browsers log errors as "SEVERE"

)

&& strpos($message, 'ERR_PROXY_CONNECTION_FAILED') === false; // ignore blackhole proxy

}

public function _afterSuite()

{

// this is just to make sure webDriver is cleared after suite

$this->stopAllSessions();

}

protected function stopAllSessions()

{

foreach ($this->sessions as $session) {

$this->_closeSession($session);

}

$this->webDriver = null;

$this->baseElement = null;

}

public function amOnSubdomain($subdomain)

{

$url = $this->config['url'];

$url = preg_replace('~(https?:\/\/)(.*\.)(.*\.)~', "$1$3", $url); // removing current subdomain

$url = preg_replace('~(https?:\/\/)(.*)~', "$1$subdomain.$2", $url); // inserting new

$this->_reconfigure(['url' => $url]);

}

/**

public function _getUrl()

{

if (!isset($this->config['url'])) {

throw new ModuleConfigException(

__CLASS__,

"Module connection failure. The URL for client can't bre retrieved"

);

}

return $this->config['url'];

}

protected function getProxy()

{

$proxyConfig = [];

if ($this->config['http_proxy']) {

$proxyConfig['httpProxy'] = $this->config['http_proxy'];

if ($this->config['http_proxy_port']) {

$proxyConfig['httpProxy'] .= ':' . $this->config['http_proxy_port'];

}

}

if ($this->config['ssl_proxy']) {

$proxyConfig['sslProxy'] = $this->config['ssl_proxy'];

if ($this->config['ssl_proxy_port']) {

$proxyConfig['sslProxy'] .= ':' . $this->config['ssl_proxy_port'];

}

}

if (!empty($proxyConfig)) {

$proxyConfig['proxyType'] = 'manual';

return $proxyConfig;

}

return null;

}

/**

public function _getCurrentUri()

{

$url = $this->webDriver->getCurrentURL();

if ($url == 'about:blank') {

throw new ModuleException($this, 'Current url is blank, no page was opened');

}

return Uri::retrieveUri($url);

}

public function _saveScreenshot($filename)

{

if (!isset($this->webDriver)) {

$this->debug('WebDriver::_saveScreenshot method has been called when webDriver is not set');

return;

}

try {

$this->webDriver->takeScreenshot($filename);

} catch (\Exception $e) {

$this->debug('Unable to retrieve screenshot from Selenium : ' . $e->getMessage());

}

}

public function _findElements($locator)

{

return $this->match($this->webDriver, $locator);

}

/**

public function _savePageSource($filename)

{

if (!isset($this->webDriver)) {

$this->debug('WebDriver::_savePageSource method has been called when webDriver is not set');

return;

}

try {

file_put_contents($filename, $this->webDriver->getPageSource());

} catch (\Exception $e) {

$this->debug('Unable to retrieve source page from Selenium : ' . $e->getMessage());

}

}

/**

public function makeScreenshot($name = null)

{

if (empty($name)) {

$name = uniqid(date("Y-m-d_H-i-s_"));

}

$debugDir = codecept_log_dir() . 'debug';

if (!is_dir($debugDir)) {

mkdir($debugDir, 0777);

}

$screenName = $debugDir . DIRECTORY_SEPARATOR . $name . '.png';

$this->_saveScreenshot($screenName);

$this->debug("Screenshot saved to $screenName");

}

/**

public function resizeWindow($width, $height)

{

$this->webDriver->manage()->window()->setSize(new WebDriverDimension($width, $height));

}

public function seeCookie($cookie, array $params = [])

{

$cookies = $this->filterCookies($this->webDriver->manage()->getCookies(), $params);

$cookies = array_map(

function ($c) {

return $c['name'];

},

$cookies

);

$this->debugSection('Cookies', json_encode($this->getCookiesAsArray($this->webDriver->manage()->getCookies())));

$this->assertContains($cookie, $cookies);

}

public function dontSeeCookie($cookie, array $params = [])

{

$cookies = $this->filterCookies($this->webDriver->manage()->getCookies(), $params);

$cookies = array_map(

function ($c) {

return $c['name'];

},

$cookies

);

$this->debugSection('Cookies', json_encode($this->getCookiesAsArray($this->webDriver->manage()->getCookies())));

$this->assertNotContains($cookie, $cookies);

}

public function setCookie($cookie, $value, array $params = [])

{

$params['name'] = $cookie;

$params['value'] = $value;

if (isset($params['expires'])) { // PhpBrowser compatibility

$params['expiry'] = $params['expires'];

}

if (!isset($params['domain'])) {

$urlParts = parse_url($this->config['url']);

if (isset($urlParts['host'])) {

$params['domain'] = $urlParts['host'];

}

}

$this->webDriver->manage()->addCookie($params);

$this->debugSection('Cookies', json_encode($this->getCookiesAsArray($this->webDriver->manage()->getCookies())));

}

public function resetCookie($cookie, array $params = [])

{

$this->webDriver->manage()->deleteCookieNamed($cookie);

$this->debugSection('Cookies', json_encode($this->getCookiesAsArray($this->webDriver->manage()->getCookies())));

}

public function grabCookie($cookie, array $params = [])

{

$params['name'] = $cookie;

$cookies = $this->filterCookies($this->webDriver->manage()->getCookies(), $params);

if (empty($cookies)) {

return null;

}

$cookie = reset($cookies);

return $cookie['value'];

}

/**

public function grabPageSource()

{

// Make sure that some page was opened.

$this->_getCurrentUri();

return $this->webDriver->getPageSource();

}

/**

protected function getCookiesAsArray(array $cookies)

{

return array_map(

function (Cookie $cookie) {

return $cookie->toArray();

},

$cookies

);

}

protected function filterCookies($cookies, $params = [])

{

foreach (['domain', 'path', 'name'] as $filter) {

if (!isset($params[$filter])) {

continue;

}

$cookies = array_filter(

$cookies,

function ($item) use ($filter, $params) {

return $item[$filter] == $params[$filter];

}

);

}

return $cookies;

}

public function amOnUrl($url)

{

$host = Uri::retrieveHost($url);

$this->_reconfigure(['url' => $host]);

$this->debugSection('Host', $host);

$this->webDriver->get($url);

}

public function amOnPage($page)

{

$url = Uri::appendPath($this->config['url'], $page);

$this->debugSection('GET', $url);

$this->webDriver->get($url);

}

public function see($text, $selector = null)

{

if (!$selector) {

return $this->assertPageContains($text);

}

$this->enableImplicitWait();

$nodes = $this->matchVisible($selector);

$this->disableImplicitWait();

$this->assertNodesContain($text, $nodes, $selector);

}

public function dontSee($text, $selector = null)

{

if (!$selector) {

return $this->assertPageNotContains($text);

}

$nodes = $this->matchVisible($selector);

$this->assertNodesNotContain($text, $nodes, $selector);

}

public function seeInSource($raw)

{

$this->assertPageSourceContains($raw);

}

public function dontSeeInSource($raw)

{

$this->assertPageSourceNotContains($raw);

}

/**

public function seeInPageSource($text)

{

$this->assertThat(

$this->webDriver->getPageSource(),

new PageConstraint($text, $this->_getCurrentUri()),

''

);

}

/**

public function dontSeeInPageSource($text)

{

$this->assertThatItsNot(

$this->webDriver->getPageSource(),

new PageConstraint($text, $this->_getCurrentUri()),

''

);

}

public function click($link, $context = null)

{

$page = $this->webDriver;

if ($context) {

$page = $this->matchFirstOrFail($this->webDriver, $context);

}

$el = $this->_findClickable($page, $link);

if (!$el) { // check one more time if this was a CSS selector we didn't match

try {

$els = $this->match($page, $link);

} catch (MalformedLocatorException $e) {

throw new ElementNotFound("name=$link", "'$link' is invalid CSS and XPath selector and Link or Button");

}

$el = reset($els);

}

if (!$el) {

throw new ElementNotFound($link, 'Link or Button or CSS or XPath');

}

$el->click();

}

/**

public function _findClickable($page, $link)

{

if (is_array($link) or ($link instanceof WebDriverBy)) {