Server.js

/* global document:false */
/**
 * @module leadfoot/Server
 */
var keys = require('./keys');
var lang = require('dojo/lang');
var Promise = require('dojo/Promise');
var request = require('dojo/request');
var Session = require('./Session');
var statusCodes = require('./lib/statusCodes');
var urlUtil = require('url');
var util = require('./lib/util');
function isMsEdge(capabilities, minVersion, maxVersion) {
	if (capabilities.browserName !== 'MicrosoftEdge') {
		return false;
	}
	if (minVersion != null || maxVersion != null) {
		var version = parseFloat(capabilities.browserVersion);
		if (minVersion != null && version < minVersion) {
			return false;
		}
		if (maxVersion != null && version > maxVersion) {
			return false;
		}
	}
	return true;
}
function isMacSafari(capabilities) {
	return capabilities.browserName === 'safari' &&
		capabilities.platform === 'MAC' &&
		capabilities.platformName !== 'ios';
}
function isGeckodriver(capabilities) {
	return capabilities.browserName === 'firefox' &&
		parseFloat(capabilities.version) >= 49;
}
function isMacGeckodriver(capabilities) {
	return isGeckodriver(capabilities) && capabilities.platform === 'MAC';
}
/**
 * Creates a function that performs an HTTP request to a JsonWireProtocol endpoint.
 *
 * @param {string} method The HTTP method to fix.
 * @returns {Function}
 */
function createHttpRequest(method) {
	/**
	 * A function that performs an HTTP request to a JsonWireProtocol endpoint and normalises response status and
	 * data.
	 *
	 * @param {string} path
	 * The path-part of the JsonWireProtocol URL. May contain placeholders in the form `/\$\d/` that will be
	 * replaced by entries in the `pathParts` argument.
	 *
	 * @param {Object} requestData
	 * The payload for the request.
	 *
	 * @param {Array.<string>=} pathParts Optional placeholder values to inject into the path of the URL.
	 *
	 * @returns {Promise.<Object>}
	 */
	return function sendRequest(path, requestData, pathParts) {
		var url = this.url + path.replace(/\$(\d)/, function (_, index) {
			return encodeURIComponent(pathParts[index]);
		});
		var defaultRequestHeaders = {
			// At least FirefoxDriver on Selenium 2.40.0 will throw a NullPointerException when retrieving
			// session capabilities if an Accept header is not provided. (It is a good idea to provide one
			// anyway)
			'Accept': 'application/json,text/plain;q=0.9'
		};
		var kwArgs = lang.delegate(this.requestOptions, {
			followRedirects: false,
			handleAs: 'text',
			headers: lang.mixin({}, defaultRequestHeaders),
			method: method
		});
		if (requestData) {
			kwArgs.data = JSON.stringify(requestData);
			kwArgs.headers['Content-Type'] = 'application/json;charset=UTF-8';
			// At least ChromeDriver 2.9.248307 will not process request data if the length of the data is not
			// provided. (It is a good idea to provide one anyway)
			kwArgs.headers['Content-Length'] = Buffer.byteLength(kwArgs.data, 'utf8');
		}
		else {
			// At least Selenium 2.41.0 - 2.42.2 running as a grid hub will throw an exception and drop the current
			// session if a Content-Length header is not provided with a DELETE or POST request, regardless of whether
			// the request actually contains any request data.
			kwArgs.headers['Content-Length'] = 0;
		}
		var trace = {};
		Error.captureStackTrace(trace, sendRequest);
		return request(url, kwArgs).then(function handleResponse(response) {
			/*jshint maxcomplexity:24 */
			// The JsonWireProtocol specification prior to June 2013 stated that creating a new session should
			// perform a 3xx redirect to the session capabilities URL, instead of simply returning the returning
			// data about the session; as a result, we need to follow all redirects to get consistent data
			if (response.statusCode >= 300 && response.statusCode < 400 && response.getHeader('Location')) {
				var redirectUrl = response.getHeader('Location');
				// If redirectUrl isn't an absolute URL, resolve it based on the orignal URL used to create the session
				if (!/^\w+:/.test(redirectUrl)) {
					redirectUrl = urlUtil.resolve(url, redirectUrl);
				}
				return request(redirectUrl, {
					method: 'GET',
					headers: defaultRequestHeaders
				}).then(handleResponse);
			}
			var responseType = response.getHeader('Content-Type');
			var data;
			if (responseType && responseType.indexOf('application/json') === 0 && response.data) {
				data = JSON.parse(response.data);
			}
			// Some drivers will respond to a DELETE request with 204; in this case, we know the operation
			// completed successfully, so just create an expected response data structure for a successful
			// operation to avoid any special conditions elsewhere in the code caused by different HTTP return
			// values
			if (response.statusCode === 204) {
				data = {
					status: 0,
					sessionId: null,
					value: null
				};
			}
			else if (response.statusCode >= 400 || (data && data.status > 0)) {
				var error = new Error();
				// "The client should interpret a 404 Not Found response from the server as an "Unknown command"
				// response. All other 4xx and 5xx responses from the server that do not define a status field
				// should be interpreted as "Unknown error" responses."
				// - http://code.google.com/p/selenium/wiki/JsonWireProtocol#Response_Status_Codes
				if (!data) {
					data = {
						status: response.statusCode === 404 || response.statusCode === 501 ? 9 : 13,
						value: {
							message: response.text
						}
					};
				}
				// ios-driver 0.6.6-SNAPSHOT April 2014 incorrectly implements the specification: does not return
				// error data on the `value` key, and does not return the correct HTTP status for unknown commands
				else if (!data.value && ('message' in data)) {
					data = {
						status: response.statusCode === 404 || response.statusCode === 501 ||
							data.message.indexOf('cannot find command') > -1 ? 9 : 13,
						value: data
					};
				}
				// At least Appium April 2014 responds with the HTTP status Not Implemented but a Selenium
				// status UnknownError for commands that are not implemented; these errors are more properly
				// represented to end-users using the Selenium status UnknownCommand, so we make the appropriate
				// coercion here
				if (response.statusCode === 501 && data.status === 13) {
					data.status = 9;
				}
				// At least BrowserStack in May 2016 responds with HTTP 500 and a message value of "Invalid Command" for
				// at least some unknown commands. These errors are more properly represented to end-users using the
				// Selenium status UnknownCommand, so we make the appropriate coercion here
				if (response.statusCode === 500 && data.value && data.value.message === 'Invalid Command') {
					data.status = 9;
				}
				// At least FirefoxDriver 2.40.0 responds with HTTP status codes other than Not Implemented and a
				// Selenium status UnknownError for commands that are not implemented; however, it provides a
				// reliable indicator that the operation was unsupported by the type of the exception that was
				// thrown, so also coerce this back into an UnknownCommand response for end-user code
				if (data.status === 13 && data.value && data.value.class &&
					(data.value.class.indexOf('UnsupportedOperationException') > -1 ||
					data.value.class.indexOf('UnsupportedCommandException') > -1)
				) {
					data.status = 9;
				}
				// At least InternetExplorerDriver 2.41.0 & SafariDriver 2.41.0 respond with HTTP status codes
				// other than Not Implemented and a Selenium status UnknownError for commands that are not
				// implemented; like FirefoxDriver they provide a reliable indicator of unsupported commands
				if (response.statusCode === 500 && data.value && data.value.message &&
					(
						data.value.message.indexOf('Command not found') > -1 ||
						data.value.message.indexOf('Unknown command') > -1
					)
				) {
					data.status = 9;
				}
				// At least GhostDriver 1.1.0 incorrectly responds with HTTP 405 instead of HTTP 501 for
				// unimplemented commands
				if (response.statusCode === 405 && data.value && data.value.message &&
					data.value.message.indexOf('Invalid Command Method') > -1
				) {
					data.status = 9;
				}
				var statusText = statusCodes[data.status];
				if (statusText) {
					error.name = statusText[0];
					error.message = statusText[1];
				}
				if (data.value && data.value.message) {
					error.message = data.value.message;
				}
				if (data.value && data.value.screen) {
					data.value.screen = new Buffer(data.value.screen, 'base64');
				}
				error.status = data.status;
				error.detail = data.value;
				error.request = {
					url: url,
					method: method,
					data: requestData
				};
				error.response = response;
				var sanitizedUrl = (function () {
					var parsedUrl = urlUtil.parse(url);
					if (parsedUrl.auth) {
						parsedUrl.auth = '(redacted)';
					}
					return urlUtil.format(parsedUrl);
				})();
				error.message = '[' + method + ' ' + sanitizedUrl +
					(requestData ? ' / ' + JSON.stringify(requestData) : '') +
					'] ' + error.message;
				error.stack = error.message + util.trimStack(trace.stack);
				throw error;
			}
			return data;
		}).catch(function (error) {
			error.stack = error.message + util.trimStack(trace.stack);
			throw error;
		});
	};
}
/**
 * Returns the actual response value from the remote environment.
 *
 * @param {Object} response JsonWireProtocol response object.
 * @returns {any} The actual response value.
 */
function returnValue(response) {
	return response.value;
}
/**
 * The Server class represents a remote HTTP server implementing the WebDriver wire protocol that can be used to
 * generate new remote control sessions.
 *
 * @constructor module:leadfoot/Server
 * @param {(Object|string)} url
 * The fully qualified URL to the JsonWireProtocol endpoint on the server. The default endpoint for a
 * JsonWireProtocol HTTP server is http://localhost:4444/wd/hub. You may also pass a parsed URL object which will
 * be converted to a string.
 * @param {{ proxy: string }=} options
 * Additional request options to be used for requests to the server.
 */
function Server(url, options) {
	if (typeof url === 'object') {
		url = Object.create(url);
		if (url.username || url.password || url.accessKey) {
			url.auth = encodeURIComponent(url.username) + ':' + encodeURIComponent(url.password || url.accessKey);
		}
	}
	this.url = urlUtil.format(url).replace(/\/*$/, '/');
	this.requestOptions = options || {};
}
/**
 * @lends module:leadfoot/Server#
 */
Server.prototype = {
	constructor: Server,
	/**
	 * An alternative session constructor. Defaults to the standard {@link module:leadfoot/Session} constructor if
	 * one is not provided.
	 *
	 * @type {module:leadfoot/Session}
	 * @default Session
	 */
	sessionConstructor: Session,
	/**
	 * Whether or not to perform capabilities testing and correction when creating a new Server.
	 * @type {boolean}
	 * @default
	 */
	fixSessionCapabilities: true,
	_get: createHttpRequest('GET'),
	_post: createHttpRequest('POST'),
	_delete: createHttpRequest('DELETE'),
	/**
	 * Gets the status of the remote server.
	 *
	 * @returns {Promise.<Object>} An object containing arbitrary properties describing the status of the remote
	 * server.
	 */
	getStatus: function () {
		return this._get('status').then(returnValue);
	},
	/**
	 * Creates a new remote control session on the remote server.
	 *
	 * @param {Capabilities} desiredCapabilities
	 * A hash map of desired capabilities of the remote environment. The server may return an environment that does
	 * not match all the desired capabilities if one is not available.
	 *
	 * @param {Capabilities=} requiredCapabilities
	 * A hash map of required capabilities of the remote environment. The server will not return an environment that
	 * does not match all the required capabilities if one is not available.
	 *
	 * @returns {Promise.<module:leadfoot/Session>}
	 */
	createSession: function (desiredCapabilities, requiredCapabilities) {
		var self = this;
		var fixSessionCapabilities = desiredCapabilities.fixSessionCapabilities !== false &&
			self.fixSessionCapabilities;
		// Don’t send `fixSessionCapabilities` to the server
		if ('fixSessionCapabilities' in desiredCapabilities) {
			desiredCapabilities = lang.mixin({}, desiredCapabilities);
			desiredCapabilities.fixSessionCapabilities = undefined;
		}
		return this._post('session', {
			desiredCapabilities: desiredCapabilities,
			requiredCapabilities: requiredCapabilities
		}).then(function (response) {
			var session = new self.sessionConstructor(response.sessionId, self, response.value);
			if (fixSessionCapabilities) {
				return self._fillCapabilities(session).catch(function (error) {
					// The session was started on the server, but we did not resolve the Promise yet. If a failure
					// occurs during capabilities filling, we should quit the session on the server too since the
					// caller will not be aware that it ever got that far and will have no access to the session to
					// quit itself.
					return session.quit().finally(function () {
						throw error;
					});
				});
			}
			else {
				return session;
			}
		});
	},
	_fillCapabilities: function (session) {
		/*jshint maxlen:140 */
		var capabilities = session.capabilities;
		function supported() { return true; }
		function unsupported() { return false; }
		function maybeSupported(error) { return error.name !== 'UnknownCommand'; }
		var broken = supported;
		var works = unsupported;
		/**
		 * Adds the capabilities listed in the `testedCapabilities` object to the hash of capabilities for
		 * the current session. If a tested capability value is a function, it is assumed that it still needs to
		 * be executed serially in order to resolve the correct value of that particular capability.
		 */
		function addCapabilities(testedCapabilities) {
			return new Promise(function (resolve, reject) {
				var keys = Object.keys(testedCapabilities);
				var i = 0;
				(function next() {
					var key = keys[i++];
					if (!key) {
						resolve();
						return;
					}
					var value = testedCapabilities[key];
					if (typeof value === 'function') {
						value().then(function (value) {
							capabilities[key] = value;
							next();
						}, reject);
					}
					else {
						capabilities[key] = value;
						next();
					}
				})();
			});
		}
		function get(page) {
			if (capabilities.supportsNavigationDataUris !== false) {
				return session.get('data:text/html;charset=utf-8,' + encodeURIComponent(page));
			}
			// Internet Explorer 9 and earlier, and Microsoft Edge build 10240 and earlier, hang when attempting to do
			// navigate after a `document.write` is performed to reset the tab content; we can still do some limited
			// testing in these browsers by using the initial browser URL page and injecting some content through
			// innerHTML, though it is unfortunately a quirks-mode file so testing is limited
			if (
				(capabilities.browserName === 'internet explorer' && parseFloat(capabilities.version) < 10) ||
				isMsEdge(capabilities) 
			) {
				// Edge driver doesn't provide an initialBrowserUrl
				var initialUrl = capabilities.browserName === 'internet explorer' ? capabilities.initialBrowserUrl :
					'about:blank';
				return session.get(initialUrl).then(function () {
					return session.execute('document.body.innerHTML = arguments[0];', [
						// The DOCTYPE does not apply, for obvious reasons, but also old IE will discard invisible
						// elements like `<script>` and `<style>` if they are the first elements injected with
						// `innerHTML`, so an extra text node is added before the rest of the content instead
						page.replace('<!DOCTYPE html>', 'x')
					]);
				});
			}
			return session.get('about:blank').then(function () {
				return session.execute('document.write(arguments[0]);', [ page ]);
			});
		}
		function discoverFeatures() {
			// jshint maxcomplexity:15
			var testedCapabilities = {};
			// At least SafariDriver 2.41.0 fails to allow stand-alone feature testing because it does not inject user
			// scripts for URLs that are not http/https
			if (isMacSafari(capabilities)) {
				return {
					nativeEvents: false,
					rotatable: false,
					locationContextEnabled: false,
					webStorageEnabled: false,
					applicationCacheEnabled: false,
					supportsNavigationDataUris: true,
					supportsCssTransforms: true,
					supportsExecuteAsync: true,
					mouseEnabled: true,
					touchEnabled: false,
					dynamicViewport: true,
					shortcutKey: keys.COMMAND
				};
			}
			// Firefox 49+ (via geckodriver) only supports W3C locator strategies
			if (isGeckodriver(capabilities)) {
				testedCapabilities.isWebDriver = true;
			}
			// At least MS Edge 14316 supports alerts but does not specify the capability
			if (isMsEdge(capabilities, 37.14316) && !('handlesAlerts' in capabilities)) {
				testedCapabilities.handlesAlerts = true;
			}
			// Appium iOS as of April 2014 supports rotation but does not specify the capability
			if (!('rotatable' in capabilities)) {
				testedCapabilities.rotatable = session.getOrientation().then(supported, unsupported);
			}
			// At least FirefoxDriver 2.40.0 and ios-driver 0.6.0 claim they support geolocation in their returned
			// capabilities map, when they do not
			if (capabilities.locationContextEnabled) {
				testedCapabilities.locationContextEnabled = session.getGeolocation()
					.then(supported, function (error) {
						return error.name !== 'UnknownCommand' &&
							error.message.indexOf('not mapped : GET_LOCATION') === -1;
					});
			}
			// At least FirefoxDriver 2.40.0 claims it supports web storage in the returned capabilities map, when
			// it does not
			if (capabilities.webStorageEnabled) {
				testedCapabilities.webStorageEnabled = session.getLocalStorageLength()
					.then(supported, maybeSupported);
			}
			// At least FirefoxDriver 2.40.0 claims it supports application cache in the returned capabilities map,
			// when it does not
			if (capabilities.applicationCacheEnabled) {
				testedCapabilities.applicationCacheEnabled = session.getApplicationCacheStatus()
					.then(supported, maybeSupported);
			}
			// IE11 will take screenshots, but it's very slow
			if (capabilities.browserName === 'internet explorer' && capabilities.version == '11') {
				testedCapabilities.takesScreenshot = true;
			}
			// At least Selendroid 0.9.0 will fail to take screenshots in certain device configurations, usually
			// emulators with hardware acceleration enabled
			else {
				testedCapabilities.takesScreenshot = session.takeScreenshot().then(supported, unsupported);
			}
			// At least ios-driver 0.6.6-SNAPSHOT April 2014 does not support execute_async
			testedCapabilities.supportsExecuteAsync = session.executeAsync('arguments[0](true);').catch(unsupported);
			// Some additional, currently-non-standard capabilities are needed in order to know about supported
			// features of a given platform
			if (!('mouseEnabled' in capabilities)) {
				// Using mouse services such as doubleclick will hang Firefox 49+ session on the Mac.
				if (isMacGeckodriver(capabilities)) {
					testedCapabilities.mouseEnabled = true;
				}
				else {
					testedCapabilities.mouseEnabled = function () {
						return session.doubleClick()
							.then(supported, maybeSupported);
					};
				}
			}
			// Don't check for touch support if the environment reports that no touchscreen is available
			if (capabilities.hasTouchScreen === false) {
				testedCapabilities.touchEnabled = false;
			}
			else if (!('touchEnabled' in capabilities)) {
				testedCapabilities.touchEnabled = session.doubleTap()
					.then(supported, maybeSupported);
			}
			// ChromeDriver 2.19 claims that it supports touch but it does not implement all of the touch endpoints
			// from JsonWireProtocol
			else if (capabilities.browserName === 'chrome') {
				testedCapabilities.touchEnabled = false;
			}
			if (!('dynamicViewport' in capabilities)) {
				testedCapabilities.dynamicViewport = session.getWindowSize().then(function (originalSize) {
					return session.setWindowSize(originalSize.width, originalSize.height);
				}).then(supported, unsupported);
			}
			// At least Internet Explorer 11 and earlier do not allow data URIs to be used for navigation
			testedCapabilities.supportsNavigationDataUris = function () {
				return get('<!DOCTYPE html><title>a</title>').then(function () {
					return session.getPageTitle();
				}).then(function (pageTitle) {
					return pageTitle === 'a';
				}).catch(unsupported);
			};
			testedCapabilities.supportsCssTransforms = function () {
				// It is not possible to test this since the feature tests runs in quirks-mode on IE<10, but we
				// know that IE9 supports CSS transforms
				if (capabilities.browserName === 'internet explorer' && parseFloat(capabilities.version) === 9) {
					return Promise.resolve(true);
				}
				/*jshint maxlen:240 */
				return get('<!DOCTYPE html><style>#a{width:8px;height:8px;-ms-transform:scale(0.5);-moz-transform:scale(0.5);-webkit-transform:scale(0.5);transform:scale(0.5);}</style><div id="a"></div>').then(function () {
					return session.execute(/* istanbul ignore next */ function () {
						var bbox = document.getElementById('a').getBoundingClientRect();
						return bbox.right - bbox.left === 4;
					});
				}).catch(unsupported);
			};
			testedCapabilities.shortcutKey = (function () {
				var platform = capabilities.platform.toLowerCase();
				if (platform.indexOf('mac') === 0) {
					return keys.COMMAND;
				}
				if (platform.indexOf('ios') === 0) {
					return null;
				}
				return keys.CONTROL;
			})();
			return Promise.all(testedCapabilities);
		}
		function discoverDefects() {
			var testedCapabilities = {};
			// At least SafariDriver 2.41.0 fails to allow stand-alone feature testing because it does not inject user
			// scripts for URLs that are not http/https
			if (isMacSafari(capabilities)) {
				return {
					brokenDeleteCookie: false,
					brokenExecuteElementReturn: false,
					brokenExecuteUndefinedReturn: false,
					brokenElementDisplayedOpacity: false,
					brokenElementDisplayedOffscreen: false,
					brokenSubmitElement: true,
					brokenWindowSwitch: true,
					brokenDoubleClick: false,
					brokenCssTransformedSize: true,
					fixedLogTypes: false,
					brokenHtmlTagName: false,
					brokenNullGetSpecAttribute: false,
					// SafariDriver-specific
					brokenActiveElement: true,
					brokenNavigation: true,
					brokenMouseEvents: true,
					brokenWindowPosition: true,
					brokenSendKeys: true,
					brokenExecuteForNonHttpUrl: true,
					// SafariDriver 2.41.0 cannot delete cookies, at all, ever
					brokenCookies: true
				};
			}
			// Internet Explorer 8 and earlier will simply crash the server if we attempt to return the parent
			// frame via script, so never even attempt to do so
			testedCapabilities.scriptedParentFrameCrashesBrowser =
				capabilities.browserName === 'internet explorer' && parseFloat(capabilities.version) < 9;
			// At least ChromeDriver 2.9 and MS Edge 10240 does not implement /element/active
			testedCapabilities.brokenActiveElement = session.getActiveElement().then(works, function (error) {
				return error.name === 'UnknownCommand';
			});
			// At least Selendroid 0.9.0 and MS Edge have broken cookie deletion.
			if (capabilities.browserName === 'selendroid') {
				// This test is very hard to get working properly in other environments so only test when Selendroid is
				// the browser
				testedCapabilities.brokenDeleteCookie = function () {
					return session.get('about:blank').then(function () {
						return session.clearCookies();
					}).then(function () {
						return session.setCookie({ name: 'foo', value: 'foo' });
					}).then(function () {
						return session.deleteCookie('foo');
					}).then(function () {
						return session.getCookies();
					}).then(function (cookies) {
						return cookies.length > 0;
					}).catch(function () {
						return true;
					}).then(function (isBroken) {
						return session.clearCookies().finally(function () {
							return isBroken();
						});
					});
				};
			}
			else if (isMsEdge(capabilities)) {
				testedCapabilities.brokenDeleteCookie = true;
			}
			// At least Firefox 49 + geckodriver can't POST empty data
			if (isGeckodriver(capabilities)) {
				testedCapabilities.brokenEmptyPost = true;
			}
			// At least MS Edge may return an 'element is obscured' error when trying to click on visible elements.
			if (isMsEdge(capabilities)) {
				testedCapabilities.brokenClick = true;
			}
			// At least Selendroid 0.9.0 incorrectly returns HTML tag names in uppercase, which is a violation
			// of the JsonWireProtocol spec
			testedCapabilities.brokenHtmlTagName = session.findByTagName('html').then(function (element) {
				return element.getTagName();
			}).then(function (tagName) {
				return tagName !== 'html';
			}).catch(broken);
			// At least ios-driver 0.6.6-SNAPSHOT incorrectly returns empty string instead of null for attributes
			// that do not exist
			testedCapabilities.brokenNullGetSpecAttribute = session.findByTagName('html').then(function (element) {
				return element.getSpecAttribute('nonexisting');
			}).then(function (value) {
				return value !== null;
			}).catch(broken);
			// At least MS Edge 10240 doesn't properly deserialize web elements passed as `execute` arguments
			testedCapabilities.brokenElementSerialization = function () {
				return get('<!DOCTYPE html><div id="a"></div>').then(function () {
					return session.findById('a')
				}).then(function (element) {
					return session.execute(function (element) {
						return element.getAttribute('id');
					}, [ element ]);
				}).then(function (attribute) {
					return attribute !== 'a';
				}).catch(broken);
			};
			// At least Selendroid 0.16.0 incorrectly returns `undefined` instead of `null` when an undefined
			// value is returned by an `execute` call
			testedCapabilities.brokenExecuteUndefinedReturn = session.execute(
				'return undefined;'
			).then(function (value) {
				return value !== null;
			}, broken);
			// At least Selendroid 0.9.0 always returns invalid element handles from JavaScript
			testedCapabilities.brokenExecuteElementReturn = function () {
				return get('<!DOCTYPE html><div id="a"></div>').then(function () {
					return session.execute('return document.getElementById("a");');
				}).then(function (element) {
					return element && element.getTagName();
				}).then(works, broken);
			};
			// At least Selendroid 0.9.0 treats fully transparent elements as displayed, but all others do not
			testedCapabilities.brokenElementDisplayedOpacity = function () {
				return get('<!DOCTYPE html><div id="a" style="opacity: .1;">a</div>').then(function () {
					// IE<9 do not support CSS opacity so should not be involved in this test
					return session.execute('var o = document.getElementById("a").style.opacity; return o && o.charAt(0) === "0";');
				}).then(function (supportsOpacity) {
					if (!supportsOpacity) {
						return works();
					}
					else {
						return session.execute('document.getElementById("a").style.opacity = "0";')
							.then(function () {
								return session.findById('a');
							})
							.then(function (element) {
								return element.isDisplayed();
							});
					}
				}).catch(broken);
			};
			// At least ChromeDriver 2.9 treats elements that are offscreen as displayed, but others do not
			testedCapabilities.brokenElementDisplayedOffscreen = function () {
				var pageText = '<!DOCTYPE html><div id="a" style="left: 0; position: absolute; top: -1000px;">a</div>';
				return get(pageText).then(function () {
					return session.findById('a');
				}).then(function (element) {
					return element.isDisplayed();
				}).catch(broken);
			};
			// At least MS Edge Driver 14316 doesn't support sending keys to a file input. See
			// https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/7194303/
			//
			// The existing feature test for this caused some browsers to hang, so just flag it for Edge for now.
			if (isMsEdge(capabilities, null, 38.14366)) {
				testedCapabilities.brokenFileSendKeys = true;
			}
			// testedCapabilities.brokenFileSendKeys = function () {
			// 	return get('<!DOCTYPE html><input type="file" id="i1">').then(function () {
			// 		var element;
			// 		return session.findById('i1')
			// 			.then(function (element) {
			// 				return element.type('./Server.js');
			// 			}).then(function () {
			// 				return session.execute(function () {
			// 					return document.getElementById('i1').value;
			// 				});
			// 			}).then(function (text) {
			// 				if (!/Server.js$/.test(text)) {
			// 					throw new Error('mismatch');
			// 				}
			// 			});
			// 	}).then(works, broken);
			// };
			// At least MS Edge Driver 14316 doesn't normalize whitespace properly when retrieving text. Text may
			// contain "\r\n" pairs rather than "\n", and there may be extraneous whitespace adjacent to "\r\n" pairs
			// and at the start and end of the text.
			testedCapabilities.brokenWhitespaceNormalization = function () {
				return get('<!DOCTYPE html><div id="d">This is\n<br>a test\n</div>').then(function () {
					return session.findById('d')
						.then(function (element) {
							return element.getVisibleText();
						}).then(function (text) {
							if (/\r\n/.test(text) || /\s+$/.test(text)) {
								throw new Error('invalid whitespace');
							}
						});
				}).then(works, broken);
			};
			// At least MS Edge Driver 14316 doesn't return elements' computed styles
			testedCapabilities.brokenComputedStyles = function () {
				var pageText = '<!DOCTYPE html><style>a { background: purple }</style><a id="a1">foo</a>';
				return get(pageText).then(function () {
					return session.findById('a1');
				}).then(function (element) {
					return element.getComputedStyle('background-color');
				}).then(function (value) {
					if (!value) {
						throw new Error('empty style');
					}
				}).then(works, broken);
			};
			// IE11 will hang during this check, although option selection does work with it
			if (capabilities.browserName !== 'internet explorer' && capabilities.version !== '11') {
				// At least MS Edge Driver 14316 doesn't allow selection option elements to be clicked.
				testedCapabilities.brokenOptionSelect = function () {
					return get(
						'<!DOCTYPE html><select id="d"><option id="o1" value="foo">foo</option>' +
						'<option id="o2" value="bar" selected>bar</option></select>'
					).then(function () {
						return session.findById('d');
					}).then(function (element) {
						return element.click();
					}).then(function () {
						return session.findById('o1');
					}).then(function (element) {
						return element.click();
					}).then(works, broken);
				};
			}
			// At least MS Edge driver 10240 doesn't support getting the page source
			testedCapabilities.brokenPageSource = session.getPageSource().then(works, broken);
			// IE11 will hang during this check if nativeEvents are enabled
			if (capabilities.browserName !== 'internet explorer' && capabilities.version !== '11') {
				testedCapabilities.brokenSubmitElement = true;
			}
			else {
				// There is inconsistency across all drivers as to whether or not submitting a form button should cause
				// the form button to be submitted along with the rest of the form; it seems most likely that tests
				// do want the specified button to act as though someone clicked it when it is submitted, so the
				// behaviour needs to be normalised
				testedCapabilities.brokenSubmitElement = function () {
					/*jshint maxlen:200 */
					return get(
						'<!DOCTYPE html><form method="get" action="about:blank">' +
						'<input id="a" type="submit" name="a" value="a"></form>'
					).then(function () {
						return session.findById('a');
					}).then(function (element) {
						return element.submit();
					}).then(function () {
						return session.getCurrentUrl();
					}).then(function (url) {
						return url.indexOf('a=a') === -1;
					}).catch(broken);
				};
			}
			// At least MS Edge 10586 becomes unresponsive after calling DELETE window, and window.close() requires user
			// interaction. This capability is distinct from brokenDeleteWindow as this capability indicates that there
			// is no way to close a Window.
			if (isMsEdge(capabilities, null, 25.10586)) {
				testedCapabilities.brokenWindowClose = true;
			}
			// At least MS Edge driver 10240 doesn't support window sizing commands
			testedCapabilities.brokenWindowSize = session.getWindowSize().then(works, broken);
			// At least Selendroid 0.9.0 has a bug where it catastrophically fails to retrieve available types;
			// they have tried to hardcode the available log types in this version so we can just return the
			// same hardcoded list ourselves.
			// At least InternetExplorerDriver 2.41.0 also fails to provide log types.
			// Firefox 49+ (via geckodriver) doesn't support retrieving logs or log types, and may hang the session.
			if (isMacGeckodriver(capabilities)) {
				testedCapabilities.fixedLogTypes = [];
			}
			else {
				testedCapabilities.fixedLogTypes = session.getAvailableLogTypes().then(unsupported, function (error) {
					if (capabilities.browserName === 'selendroid' && !error.response.text.length) {
						return [ 'logcat' ];
					}
					return [];
				});
			}
			// At least Microsoft Edge 10240 doesn't support timeout values of 0.
			testedCapabilities.brokenZeroTimeout = session.setTimeout('implicit', 0).then(works, broken);
			// At least ios-driver 0.6.6-SNAPSHOT April 2014 corrupts its internal state when performing window
			// switches and gets permanently stuck; we cannot feature detect, so platform sniffing it is
			if (capabilities.browserName === 'Safari' && capabilities.platformName === 'IOS') {
				testedCapabilities.brokenWindowSwitch = true;
			}
			else {
				testedCapabilities.brokenWindowSwitch = session.getCurrentWindowHandle().then(function (handle) {
					return session.switchToWindow(handle);
				}).then(works, broken);
			}
			// At least selendroid 0.12.0-SNAPSHOT doesn't support switching to the parent frame
			if (capabilities.browserName === 'android' && capabilities.deviceName === 'Android Emulator') {
				testedCapabilities.brokenParentFrameSwitch = true;
			}
			else {
				testedCapabilities.brokenParentFrameSwitch = session.switchToParentFrame().then(works, broken);
			}
			var scrollTestUrl = '<!DOCTYPE html><div id="a" style="margin: 3000px;"></div>';
			// ios-driver 0.6.6-SNAPSHOT April 2014 calculates position based on a bogus origin and does not
			// account for scrolling
			testedCapabilities.brokenElementPosition = function () {
				return get(scrollTestUrl).then(function () {
					return session.findById('a');
				}).then(function (element) {
					return element.getPosition();
				}).then(function (position) {
					return position.x !== 3000 || position.y !== 3000;
				}).catch(broken);
			};
			// At least ios-driver 0.6.6-SNAPSHOT April 2014 will never complete a refresh call
			testedCapabilities.brokenRefresh = function () {
				return session.get('about:blank?1').then(function () {
					return new Promise(function (resolve, reject, progress, setCanceler) {
						function cleanup() {
							clearTimeout(timer);
							refresh.cancel();
						}
						setCanceler(cleanup);
						var refresh = session.refresh().then(function () {
							cleanup();
							resolve(false);
						}, function () {
							cleanup();
							resolve(true);
						});
						var timer = setTimeout(function () {
							cleanup();
						}, 2000);
					});
				}).catch(broken);
			};
			if (isGeckodriver(capabilities)) {
				// At least geckodriver 0.11 and Firefox 49 don't implement mouse control, so everything will need to be
				// simulated.
				testedCapabilities.brokenMouseEvents = true;
			}
			else if (capabilities.mouseEnabled) {
				// At least IE 10 and 11 on SauceLabs don't fire native mouse events consistently even though they
				// support moveMouseTo
				testedCapabilities.brokenMouseEvents = function () {
					return get(
						'<!DOCTYPE html><div id="foo">foo</div>' +
						'<script>window.counter = 0; var d = document; d.onmousemove = function () { window.counter++; };</script>'
					).then(function () {
						return session.findById('foo');
					}).then(function (element) {
						return session.moveMouseTo(element, 20, 20);
					}).then(function () {
						return util.sleep(100);
					}).then(function () {
						return session.execute('return window.counter;');
					}).then(
						function (counter) {
							return counter > 0 ? works() : broken();
						},
						broken
					);
				};
				// At least ChromeDriver 2.12 through 2.19 will throw an error if mouse movement relative to the <html>
				// element is attempted
				testedCapabilities.brokenHtmlMouseMove = function () {
					return get('<!DOCTYPE html><html></html>').then(function () {
						return session.findByTagName('html').then(function (element) {
							return session.moveMouseTo(element, 0, 0);
						});
					}).then(works, broken);
				};
				// At least ChromeDriver 2.9.248307 does not correctly emit the entire sequence of events that would
				// normally occur during a double-click
				testedCapabilities.brokenDoubleClick = function retry() {
					/*jshint maxlen:200 */
					// InternetExplorerDriver is not buggy, but IE9 in quirks-mode is; since we cannot do feature
					// tests in standards-mode in IE<10, force the value to false since it is not broken in this
					// browser
					if (capabilities.browserName === 'internet explorer' && capabilities.version === '9') {
						return Promise.resolve(false);
					}
					return get('<!DOCTYPE html><script>window.counter = 0; var d = document; d.onclick = d.onmousedown = d.onmouseup = function () { window.counter++; };</script>').then(function () {
						return session.findByTagName('html');
					}).then(function (element) {
						return session.moveMouseTo(element);
					}).then(function () {
						return util.sleep(100);
					}).then(function () {
						return session.doubleClick();
					}).then(function () {
						return session.execute('return window.counter;');
					}).then(function (counter) {
						// InternetExplorerDriver 2.41.0 has a race condition that makes this test sometimes fail
						/* istanbul ignore if: inconsistent race condition */
						if (counter === 0) {
							return retry();
						}
						return counter !== 6;
					}).catch(broken);
				};
			}
			if (capabilities.touchEnabled) {
				// At least Selendroid 0.9.0 fails to perform a long tap due to an INJECT_EVENTS permission failure
				testedCapabilities.brokenLongTap = session.findByTagName('body').then(function (element) {
					return session.longTap(element);
				}).then(works, broken);
				// At least ios-driver 0.6.6-SNAPSHOT April 2014 claims to support touch press/move/release but
				// actually fails when you try to use the commands
				testedCapabilities.brokenMoveFinger = session.pressFinger(0, 0).then(works, function (error) {
					return error.name === 'UnknownCommand' || error.message.indexOf('need to specify the JS') > -1;
				});
				// Touch scroll in ios-driver 0.6.6-SNAPSHOT is broken, does not scroll at all;
				// in selendroid 0.9.0 it ignores the element argument
				testedCapabilities.brokenTouchScroll = function () {
					return get(scrollTestUrl).then(function () {
						return session.touchScroll(0, 20);
					}).then(function () {
						return session.execute('return window.scrollY !== 20;');
					}).then(function (isBroken) {
						if (isBroken) {
							return true;
						}
						return session.findById('a').then(function (element) {
							return session.touchScroll(element, 0, 0);
						}).then(function () {
							return session.execute('return window.scrollY !== 3000;');
						});
					})
					.catch(broken);
				};
				// Touch flick in ios-driver 0.6.6-SNAPSHOT is broken, does not scroll at all except in very
				// broken ways if very tiny speeds are provided and the flick goes in the wrong direction
				testedCapabilities.brokenFlickFinger = function () {
					return get(scrollTestUrl).then(function () {
						return session.flickFinger(0, 400);
					}).then(function () {
						return session.execute('return window.scrollY === 0;');
					})
					.catch(broken);
				};
			}
			if (capabilities.supportsCssTransforms) {
				testedCapabilities.brokenCssTransformedSize = function () {
					/*jshint maxlen:240 */
					return get('<!DOCTYPE html><style>#a{width:8px;height:8px;-ms-transform:scale(0.5);-moz-transform:scale(0.5);-webkit-transform:scale(0.5);transform:scale(0.5);}</style><div id="a"></div>').then(function () {
						return session.execute('return document.getElementById("a");').then(function (element) {
							return element.getSize();
						}).then(function (dimensions) {
							return dimensions.width !== 4 || dimensions.height !== 4;
						});
					}).catch(broken);
				};
			}
			return Promise.all(testedCapabilities);
		}
		function discoverServerFeatures() {
			var testedCapabilities = {};
			/* jshint maxlen:300 */
			// Check that the remote server will accept file uploads. There is a secondary test in discoverDefects that
			// checks whether the server allows typing into file inputs.
			testedCapabilities.remoteFiles = function () {
				return session._post('file', {
					file: 'UEsDBAoAAAAAAD0etkYAAAAAAAAAAAAAAAAIABwAdGVzdC50eHRVVAkAA2WnXlVlp15VdXgLAAEE8gMAAATyAwAAUEsBAh4DCgAAAAAAPR62RgAAAAAAAAAAAAAAAAgAGAAAAAAAAAAAAKSBAAAAAHRlc3QudHh0VVQFAANlp15VdXgLAAEE8gMAAATyAwAAUEsFBgAAAAABAAEATgAAAEIAAAAAAA=='
				}).then(function (filename) {
					return filename && filename.indexOf('test.txt') > -1;
				}).catch(unsupported);
			};
			// The window sizing commands in the W3C standard don't use window handles, but they do under the
			// JsonWireProtocol. By default, Session assumes handles are used. When the result of this check is added to
			// capabilities, Session will take it into account.
			testedCapabilities.implicitWindowHandles = session.getWindowSize().then(unsupported, function (error) {
				return error.name === 'UnknownCommand';
			});
			// At least SafariDriver 2.41.0 fails to allow stand-alone feature testing because it does not inject user
			// scripts for URLs that are not http/https
			if (!isMacSafari(capabilities)) {
				// At least MS Edge 14316 returns immediately from a click request immediately rather than waiting for
				// default action to occur.
				if (isMsEdge(capabilities)) {
					testedCapabilities.returnsFromClickImmediately = true;
				}
				else {
					testedCapabilities.returnsFromClickImmediately = function () {
						function assertSelected(expected) {
							return function (actual) {
								if (expected !== actual) {
									throw new Error('unexpected selection state');
								}
							};
						}
						return get(
							'<!DOCTYPE html><input type="checkbox" id="c">'
						).then(function () {
							return session.findById('c');
						}).then(function (element) {
							return element.click().then(function () {
								return element.isSelected();
							}).then(assertSelected(true))
							.then(function () {
								return element.click().then(function () {
									return element.isSelected();
								});
							}).then(assertSelected(false))
							.then(function () {
								return element.click().then(function () {
									return element.isSelected();
								});
							}).then(assertSelected(true));
						}).then(works, broken);
					};
				}
			}
			// The W3C WebDriver standard does not support the session-level /keys command, but JsonWireProtocol does.
			if (isGeckodriver(capabilities)) {
				testedCapabilities.supportsKeysCommand = false;
			}
			else {
				testedCapabilities.supportsKeysCommand = session._post('keys', { value: [ 'a' ] }).then(supported,
					unsupported);
			}
			return Promise.all(testedCapabilities);
		}
		if (capabilities._filled) {
			return Promise.resolve(session);
		}
		// At least geckodriver 0.11 and Firefox 49+ may hang when getting 'about:blank' in the first request
		var promise = isGeckodriver(capabilities) ? Promise.resolve(session) : session.get('about:blank');
		return promise
			.then(discoverServerFeatures)
			.then(addCapabilities)
			.then(discoverFeatures)
			.then(addCapabilities)
			.then(function () {
				return session.get('about:blank');
			})
			.then(discoverDefects)
			.then(addCapabilities)
			.then(function () {
				Object.defineProperty(capabilities, '_filled', {
					value: true,
					configurable: true
				});
				return session.get('about:blank').finally(function () {
					return session;
				});
			});
	},
	/**
	 * Gets a list of all currently active remote control sessions on this server.
	 *
	 * @returns {Promise.<Object[]>}
	 */
	getSessions: function () {
		return this._get('sessions').then(function (sessions) {
			// At least BrowserStack is now returning an array for the sessions response
			if (sessions && !Array.isArray(sessions)) {
				sessions = returnValue(sessions);
			}
			// At least ChromeDriver 2.19 uses the wrong keys
			// https://code.google.com/p/chromedriver/issues/detail?id=1229
			sessions.forEach(function (session) {
				if (session.sessionId && !session.id) {
					session.id = session.sessionId;
				}
			});
			return sessions;
		});
	},
	/**
	 * Gets information on the capabilities of a given session from the server. The list of capabilities returned
	 * by this command will not include any of the extra session capabilities detected by Leadfoot and may be
	 * inaccurate.
	 *
	 * @param {string} sessionId
	 * @returns {Promise.<Object>}
	 */
	getSessionCapabilities: function (sessionId) {
		return this._get('session/$0', null, [ sessionId ]).then(returnValue);
	},
	/**
	 * Terminates a session on the server.
	 *
	 * @param {string} sessionId
	 * @returns {Promise.<void>}
	 */
	deleteSession: function (sessionId) {
		return this._delete('session/$0', null, [ sessionId ]).then(returnValue);
	}
};
module.exports = Server;