compat.js

  1. /**
  2.  * The compat module adds support for Intern 1.x functional testing APIs based on WD.js 0.2.2 to Leadfoot.
  3.  *
  4.  * @deprecated Use the standard Leadfoot APIs.
  5.  * @module leadfoot/compat
  6.  */
  8. var Command = require('./Command');
  9. var Promise = require('dojo/Promise');
  10. var pollUntil = require('./helpers/pollUntil');
  11. var strategies = require('./lib/strategies');
  12. var topic = require('dojo/topic');
  14. /**
  15.  * Deprecates `fromMethod` for `toMethod` and returns the correct call to `toMethod`.
  16.  *
  17.  * @private
  18.  * @param {string} fromMethod
  19.  * @param {string} toMethod
  20.  * @returns {Function}
  21.  */
  22. function deprecate(fromMethod, toMethod) {
  23. 	return function () {
  24. 		warn('Command#' + fromMethod, 'Command#' + toMethod);
  25. 		return this[toMethod].apply(this, arguments);
  26. 	};
  27. }
  29. /**
  30.  * Deprecates the element context signature of a method and returns a new command with the correct call to
  31.  * `toMethod` on the element.
  32.  *
  33.  * @private
  34.  * @param {string} fromMethod
  35.  * The name of the old method.
  36.  *
  37.  * @param {string=} toMethod
  38.  * The name of the replacement method on the element, if it is different than the name of the old method. If
  39.  * omitted, it is assumed that the method name
  40.  *
  41.  * @param {Function=} fn
  42.  * An optional function that will be invoked in lieu of a call to the original method if a non-element signature
  43.  * is used.
  44.  *
  45.  * @returns {Function}
  46.  */
  47. function deprecateElementSig(fromMethod, toMethod, fn) {
  48. 	return function (element) {
  49. 		if (element && element.elementId) {
  50. 			warn('Command#' + fromMethod + '(element)', 'Command#find then Command#' + fromMethod + ', or ' +
  51. 				'Command#find then Command#then(function (element) { return element.' +
  52. 				(toMethod || fromMethod) + '(); }');
  54. 			var args = Array.prototype.slice.call(arguments, 1);
  55. 			return new this.constructor(this, function () {
  56. 				return element[toMethod || fromMethod].apply(this, args);
  57. 			});
  58. 		}
  60. 		return fn ? fn.apply(this, arguments) : Command.prototype[fromMethod].apply(this, arguments);
  61. 	};
  62. }
  64. /**
  65.  * Deprecates the element context signature of a method as well as its non-element signature to go to `toMethod`.
  66.  *
  67.  * @private
  68.  * @param {string} fromMethod
  69.  * @param {string} toMethod
  70.  * @returns {Function}
  71.  */
  72. function deprecateElementAndStandardSig(fromMethod, toMethod) {
  73. 	return deprecateElementSig(fromMethod, toMethod, deprecate(fromMethod, toMethod));
  74. }
  76. /**
  77.  * Warns a user once that the method given by `name` is deprecated.
  78.  *
  79.  * @private
  80.  * @method
  81.  * @param {string} name The name of the old method.
  82.  * @param {string=} replacement Replacement instructions, if a direct replacement for the old method exists.
  83.  * @param {string=} extra Extra information about the deprecation.
  84.  */
  85. var warn = (function () {
  86. 	var warned = {};
  87. 	return function (name, replacement, extra) {
  88. 		if (warned[name]) {
  89. 			return;
  90. 		}
  92. 		warned[name] = true;
  93. 		topic.publish('/deprecated', name, replacement, extra);
  94. 	};
  95. })();
  97. var methods = {
  98. 	get sessionID() {
  99. 		warn('Command#sessionID', 'the Command#session.sessionId property');
  100. 		return this.session.sessionId;
  101. 	},
  102. 	status: function () {
  103. 		warn('Command#status');
  104. 		return new this.constructor(this, function () {
  105. 			return this.session.server.getStatus();
  106. 		});
  107. 	},
  108. 	init: function () {
  109. 		warn('Command#init');
  110. 		return this;
  111. 	},
  112. 	sessions: function () {
  113. 		warn('Command#sessions');
  114. 		return new this.constructor(this, function () {
  115. 			return this.session.server.getSessions();
  116. 		});
  117. 	},
  118. 	sessionCapabilities: function () {
  119. 		warn('Command#sessionCapabilities', 'the Command#session.capabilities property');
  120. 		return new this.constructor(this, function () {
  121. 			return this.session.capabilities;
  122. 		});
  123. 	},
  124. 	altSessionCapabilities: function () {
  125. 		warn('Command#altSessionCapabilities', 'the Command#session.capabilities property');
  126. 		return new this.constructor(this, function () {
  127. 			return this.session.capabilities;
  128. 		});
  129. 	},
  130. 	getSessionId: function () {
  131. 		warn('Command#getSessionId', 'the Command#session.sessionId property');
  132. 		return new this.constructor(this, function () {
  133. 			return this.session.sessionId;
  134. 		});
  135. 	},
  136. 	getSessionID: function () {
  137. 		warn('Command#getSessionID', 'the Command#session.sessionId property');
  138. 		return new this.constructor(this, function () {
  139. 			return this.session.sessionId;
  140. 		});
  141. 	},
  142. 	setAsyncScriptTimeout: deprecate('setAsyncScriptTimeout', 'setExecuteAsyncTimeout'),
  143. 	setWaitTimeout: deprecate('setWaitTimeout', 'setFindTimeout'),
  144. 	setImplicitWaitTimeout: deprecate('setImplicitWaitTimeout', 'setFindTimeout'),
  145. 	windowHandle: deprecate('windowHandle', 'getCurrentWindowHandle'),
  146. 	windowHandles: deprecate('windowHandles', 'getAllWindowHandles'),
  147. 	url: deprecate('url', 'getCurrentUrl'),
  148. 	forward: deprecate('forward', 'goForward'),
  149. 	back: deprecate('back', 'goBack'),
  150. 	safeExecute: deprecate('safeExecute', 'execute'),
  151. 	eval: function (code) {
  152. 		warn('Command#eval', 'Command#execute with a return call');
  153. 		return this.execute('return eval(arguments[0]);', [ code ]);
  154. 	},
  155. 	safeEval: function (code) {
  156. 		warn('Command#safeEval', 'Command#execute with a return call');
  157. 		return this.execute('return eval(arguments[0]);', [ code ]);
  158. 	},
  159. 	safeExecuteAsync: deprecate('safeExecuteAsync', 'executeAsync'),
  160. 	frame: deprecate('frame', 'switchToFrame'),
  161. 	window: deprecate('window', 'switchToWindow'),
  162. 	close: deprecate('close', 'closeCurrentWindow'),
  163. 	windowSize: deprecate('windowSize', 'setWindowSize'),
  164. 	setWindowSize: function () {
  165. 		var args = Array.prototype.slice.call(arguments, 0);
  167. 		if (args.length === 3 && typeof args[0] === 'number') {
  168. 			warn('Command#setWindowSize(width, height, handle)',
  169. 				'Command#setWindowSize(handle, width, height)');
  170. 			args.unshift(args.pop());
  171. 		}
  173. 		return Command.prototype.setWindowSize.apply(this, args);
  174. 	},
  175. 	setWindowPosition: function () {
  176. 		var args = Array.prototype.slice.call(arguments, 0);
  178. 		if (args.length === 3 && typeof args[0] === 'number') {
  179. 			warn('Command#setWindowPosition(x, y, handle)',
  180. 				'Command#setWindowPosition(handle, x, y)');
  181. 			args.unshift(args.pop());
  182. 		}
  184. 		return Command.prototype.setWindowPosition.apply(this, args);
  185. 	},
  186. 	maximize: deprecate('maximize', 'maximizeWindow'),
  187. 	allCookies: deprecate('allCookies', 'getCookies'),
  188. 	deleteAllCookies: deprecate('deleteAllCookies', 'clearCookies'),
  189. 	source: deprecate('source', 'getPageSource'),
  190. 	title: deprecate('title', 'getPageTitle'),
  191. 	element: deprecate('element', 'find'),
  192. 	elementByClassName: deprecate('elementByClassName', 'findByClassName'),
  193. 	elementByCssSelector: deprecate('elementByCssSelector', 'findByCssSelector'),
  194. 	elementById: deprecate('elementById', 'findById'),
  195. 	elementByName: deprecate('elementByName', 'findByName'),
  196. 	elementByLinkText: deprecate('elementByLinkText', 'findByLinkText'),
  197. 	elementByPartialLinkText: deprecate('elementByPartialLinkText', 'findByPartialLinkText'),
  198. 	elementByTagName: deprecate('elementByTagName', 'findByTagName'),
  199. 	elementByXPath: deprecate('elementByXPath', 'findByXpath'),
  200. 	elementByCss: deprecate('elementByCss', 'findByCssSelector'),
  201. 	elements: deprecate('elements', 'findAll'),
  202. 	elementsByClassName: deprecate('elementsByClassName', 'findAllByClassName'),
  203. 	elementsByCssSelector: deprecate('elementsByCssSelector', 'findAllByCssSelector'),
  204. 	elementsById: function (value) {
  205. 		warn('Command#elementsById', 'Command#findById');
  206. 		return this.findAll('id', value);
  207. 	},
  208. 	elementsByName: deprecate('elementsByName', 'findAllByName'),
  209. 	elementsByLinkText: deprecate('elementsByLinkText', 'findAllByLinkText'),
  210. 	elementsByPartialLinkText: deprecate('elementsByPartialLinkText', 'findAllByPartialLinkText'),
  211. 	elementsByTagName: deprecate('elementsByTagName', 'findAllByTagName'),
  212. 	elementsByXPath: deprecate('elementsByXPath', 'findAllByXpath'),
  213. 	elementsByCss: deprecate('elementsByCss', 'findAllByCssSelector'),
  214. 	elementOrNull: function (using, value) {
  215. 		warn('Command#elementOrNull', 'Command#find and Command#finally, or Command#findAll');
  216. 		return this.find(using, value).catch(function () {
  217. 			return null;
  218. 		});
  219. 	},
  220. 	elementIfExists: function (using, value) {
  221. 		warn('Command#elementIfExists', 'Command#find and Command#finally, or Command#findAll');
  222. 		return this.find(using, value).catch(function () {});
  223. 	},
  224. 	hasElement: function (using, value) {
  225. 		warn('Command#hasElement', 'Command#find and Command#then(exists, doesNotExist)');
  226. 		return this.find(using, value).then(function () {
  227. 			return true;
  228. 		}, function () {
  229. 			return false;
  230. 		});
  231. 	},
  232. 	active: deprecate('active', 'getActiveElement'),
  233. 	clickElement: deprecateElementAndStandardSig('clickElement', 'click'),
  234. 	submit: deprecateElementSig('submit'),
  235. 	text: function (element) {
  236. 		return new this.constructor(this, function () {
  237. 			if ((!element || element === 'body') && !this.context.length) {
  238. 				if (element === 'body') {
  239. 					warn('Command#text(\'body\')', 'Command#findByTagName(\'body\') then Command#getVisibleText');
  240. 				}
  241. 				else {
  242. 					warn('Command#text with no element', 'Command#findByTagName(\'body\') then Command#getVisibleText');
  243. 				}
  245. 				return this.session.findByTagName('body').then(function (body) {
  246. 					return body.getVisibleText();
  247. 				});
  248. 			}
  249. 			else if (element && element.elementId) {
  250. 				warn('Command#text(element)', 'Command#find then Command#getVisibleText, or ' +
  251. 					'Command#find then Command#then(function (element) { return element.getVisibleText(); }');
  252. 				return element.getVisibleText();
  253. 			}
  254. 			else {
  255. 				warn('Command#text', 'Command#getVisibleText');
  256. 				if (this.context.isSingle) {
  257. 					return this.context[0].getVisibleText();
  258. 				}
  259. 				else {
  260. 					return Promise.all(this.context.map(function (element) {
  261. 						return element.getVisibleText();
  262. 					}));
  263. 				}
  264. 			}
  265. 		});
  266. 	},
  268. 	// This method had a two-argument version according to the WD.js docs but they inexplicably swapped the first
  269. 	// and second arguments so it probably never would have worked properly in Intern
  270. 	textPresent: function (searchText, element) {
  271. 		warn('Command#textPresent', 'Command#getVisibleText and a promise helper');
  273. 		function test(text) {
  274. 			return text.indexOf(searchText) > -1;
  275. 		}
  277. 		if (element) {
  278. 			return new this.constructor(this, function () {
  279. 				return element.getVisibleText().then(test);
  280. 			});
  281. 		}
  283. 		return this.getVisibleText().then(test);
  284. 	},
  286. 	type: deprecateElementSig('type'),
  287. 	keys: deprecate('keys', 'pressKeys'),
  288. 	getTagName: deprecateElementSig('getTagName'),
  289. 	clear: deprecateElementAndStandardSig('clear', 'clearValue'),
  290. 	isSelected: deprecateElementSig('isSelected'),
  291. 	isEnabled: deprecateElementSig('isEnabled'),
  292. 	enabled: deprecateElementAndStandardSig('enabled', 'isEnabled'),
  293. 	getAttribute: deprecateElementSig('getAttribute'),
  294. 	getValue: function (element) {
  295. 		if (element && element.elementId) {
  296. 			warn('Command#getValue(element)', 'Command#find then Command#getProperty(\'value\'), or ' +
  297. 				'Command#find then Command#then(function (element) { ' +
  298. 				'return element.getProperty(\'value\'); }');
  300. 			return new this.constructor(this, function () {
  301. 				return element.getProperty('value');
  302. 			});
  303. 		}
  305. 		warn('Command#getValue', 'Command#find then Command#getProperty(\'value\')');
  306. 		return this.getProperty('value');
  307. 	},
  308. 	equalsElement: function (element, other) {
  309. 		if (other && other.elementId) {
  310. 			warn('Command#equalsElement(element, other)', 'element.equals(other)');
  311. 			return new this.constructor(this, function () {
  312. 				return element.equals(other);
  313. 			});
  314. 		}
  316. 		warn('Command#equalsElement', 'Command#equals');
  317. 		return this.equals(element);
  318. 	},
  319. 	isDisplayed: deprecateElementSig('isDisplayed'),
  320. 	displayed: deprecateElementAndStandardSig('displayed', 'isDisplayed'),
  321. 	getLocation: deprecateElementAndStandardSig('getLocation', 'getPosition'),
  322. 	getLocationInView: function () {
  323. 		warn(
  324. 			'Command#getLocationInView',
  325. 			'Command#getPosition',
  326. 			'This command is defined in the spec as internal and should never have been exposed to end users. ' +
  327. 			'The returned value of this command will be the same as Command#getPosition, which may not match ' +
  328. 			'prior behaviour.'
  329. 		);
  331. 		return this.getPosition.apply(this, arguments);
  332. 	},
  333. 	getSize: deprecateElementSig('getSize'),
  334. 	getComputedCss: deprecateElementAndStandardSig('getComputedCss', 'getComputedStyle'),
  335. 	getComputedCSS: deprecateElementAndStandardSig('getComputedCSS', 'getComputedStyle'),
  336. 	alertText: deprecate('alertText', 'getAlertText'),
  337. 	alertKeys: deprecate('alertKeys', 'typeInPrompt'),
  338. 	moveTo: deprecateElementAndStandardSig('moveTo', 'moveMouseTo'),
  339. 	click: function (button) {
  340. 		if (typeof button === 'number') {
  341. 			warn('Command#click(button)', 'Command#clickMouseButton(button)');
  342. 			return this.clickMouseButton(button);
  343. 		}
  345. 		return Command.prototype.click.apply(this, arguments);
  346. 	},
  347. 	buttonDown: deprecate('buttonDown', 'pressMouseButton'),
  348. 	buttonUp: deprecate('buttonUp', 'releaseMouseButton'),
  349. 	doubleclick: deprecate('doubleclick', 'doubleClick'),
  350. 	// TODO: There is no tap on elements
  351. 	tapElement: deprecateElementSig('tapElement', 'tap'),
  352. 	// TODO: There is no flick on elements
  353. 	flick: deprecate('flick', 'flickFinger'),
  354. 	setLocalStorageKey: deprecate('setLocalStorageKey', 'setLocalStorageItem'),
  355. 	getLocalStorageKey: deprecate('getLocalStorageKey', 'getLocalStorageItem'),
  356. 	removeLocalStorageKey: deprecate('removeLocalStorageKey', 'deleteLocalStorageItem'),
  357. 	log: deprecate('log', 'getLogsFor'),
  358. 	logTypes: deprecate('logTypes', 'getAvailableLogTypes'),
  359. 	newWindow: function (url, name) {
  360. 		warn('Command#newWindow', 'Command#execute');
  361. 		return this.execute('window.open(arguments[0], arguments[1]);', [ url, name ]);
  362. 	},
  363. 	windowName: function () {
  364. 		warn('Command#windowName', 'Command#execute');
  365. 		return this.execute('return window.name;');
  366. 	},
  367. 	setHTTPInactivityTimeout: function () {
  368. 		warn('Command#setHTTPInactivityTimeout');
  369. 		return this;
  370. 	},
  371. 	getPageIndex: function (element) {
  372. 		warn('Command#getPageIndex', null, 'This command is not part of any specification.');
  373. 		if (element && element.elementId) {
  374. 			return new this.constructor(this, function () {
  375. 				return element._get('pageIndex');
  376. 			});
  377. 		}
  379. 		return new this.constructor(this, function () {
  380. 			if (this.context.isSingle) {
  381. 				return this.context[0]._get('pageIndex');
  382. 			}
  383. 			else {
  384. 				return Promise.all(this.context.map(function (element) {
  385. 					return element._get('pageIndex');
  386. 				}));
  387. 			}
  388. 		});
  389. 	},
  390. 	uploadFile: function () {
  391. 		warn(
  392. 			'Command#uploadFile',
  393. 			'Command#type to type a file path into a file upload form control',
  394. 			'This command is not part of any specification. This command is a no-op.'
  395. 		);
  397. 		return this;
  398. 	},
  399. 	waitForCondition: function (expression, timeout, pollInterval) {
  400. 		timeout = timeout || 1000;
  401. 		pollInterval = pollInterval || 100;
  403. 		warn('Command#waitForCondition', 'Command#executeAsync or leadfoot/helpers/pollUntil');
  405. 		return this.then(pollUntil('return eval(arguments[0]) ? true : null;', [ expression ], timeout, pollInterval));
  406. 	},
  407. 	waitForConditionInBrowser: function (expression, timeout, pollInterval) {
  408. 		timeout = timeout || 1000;
  409. 		pollInterval = pollInterval || 100;
  411. 		warn('Command#waitForConditionInBrowser', 'Command#executeAsync or leadfoot/helpers/pollUntil');
  413. 		return this.then(pollUntil('return eval(arguments[0]) ? true : null;', [ expression ], timeout, pollInterval));
  414. 	},
  415. 	sauceJobUpdate: function () {
  416. 		warn(
  417. 			'Command#sauceJobUpdate',
  418. 			null,
  419. 			'This command is not part of any specification. This command is a no-op.'
  420. 		);
  422. 		return this;
  423. 	},
  424. 	sauceJobStatus: function () {
  425. 		warn(
  426. 			'Command#sauceJobStatus',
  427. 			null,
  428. 			'This command is not part of any specification. This command is a no-op.'
  429. 		);
  431. 		return this;
  432. 	},
  433. 	reset: function () {
  434. 		warn(
  435. 			'Command#reset',
  436. 			'a previously stored Command instance'
  437. 		);
  439. 		return this;
  440. 	},
  441. 	waitForElement: function (using, value, timeout) {
  442. 		warn(
  443. 			'Command#waitForElement',
  444. 			'Command#setFindTimeout and Command#find',
  445. 			'This command is implemented using implicit timeouts, which may not match the prior behaviour.'
  446. 		);
  448. 		// This is effectively what the WD.js code does, though there it's because the property is never validated,
  449. 		// so the end date becomes NaN; not an intentional design choice
  450. 		if (typeof timeout === 'undefined') {
  451. 			timeout = Infinity;
  452. 		}
  454. 		var command = this;
  455. 		return this.getFindTimeout().then(function (originalTimeout) {
  456. 			return command.setFindTimeout(timeout)
  457. 				.find(using, value)
  458. 				.then(function () {
  459. 					return command.setFindTimeout(originalTimeout).then(function () {
  460. 						return null;
  461. 					});
  462. 				}, function (error) {
  463. 					return command.setFindTimeout(originalTimeout).then(function () {
  464. 						throw error;
  465. 					});
  466. 				});
  467. 		});
  468. 	},
  469. 	waitForVisible: function (using, value, timeout) {
  470. 		warn(
  471. 			'Command#waitForVisible',
  472. 			null,
  473. 			'This command is partially implemented using implicit timeouts, which may not match the prior ' +
  474. 			'behaviour.'
  475. 		);
  477. 		// This is effectively what the WD.js code does, though there it's because the property is never validated,
  478. 		// so the end date becomes NaN; not an intentional design choice
  479. 		if (typeof timeout === 'undefined') {
  480. 			timeout = Infinity;
  481. 		}
  483. 		var startTime = Date.now();
  484. 		var command = this;
  485. 		return this.getFindTimeout().then(function (originalTimeout) {
  486. 			return command.setFindTimeout(timeout)
  487. 				.find(using, value)
  488. 				.then(function (element) {
  489. 					return pollUntil(/* istanbul ignore next */ function (element) {
  490. 						return element.offsetWidth && element.offsetHeight ? true : null;
  491. 					}, [ element ], timeout - (startTime - Date.now())).call(this);
  492. 				}).then(function (isVisible) {
  493. 					return command.setFindTimeout(originalTimeout).then(function () {
  494. 						if (!isVisible) {
  495. 							throw new Error('Element didn\'t become visible');
  496. 						}
  497. 					});
  498. 				}, function (error) {
  499. 					return command.setFindTimeout(originalTimeout).then(function () {
  500. 						throw error;
  501. 					});
  502. 				});
  503. 		});
  504. 	},
  505. 	isVisible: function () {
  506. 		warn(
  507. 			'Command#isVisible',
  508. 			'Command#isDisplayed',
  509. 			'This command is implemented using Command#isDisplayed, which may not match the prior behaviour.'
  510. 		);
  512. 		if (arguments.length === 2) {
  513. 			var using = arguments[0];
  514. 			var value = arguments[1];
  515. 			return this.find(using, value).isDisplayed().catch(function () {
  516. 				return false;
  517. 			});
  518. 		}
  519. 		else if (arguments.length === 1) {
  520. 			var element = arguments[0];
  521. 			if (element && element.elementId) {
  522. 				return new this.constructor(this, function () {
  523. 					return element.isDisplayed();
  524. 				});
  525. 			}
  526. 		}
  528. 		return new this.constructor(this, function () {
  529. 			if (this.context.isSingle) {
  530. 				return this.context[0].isDisplayed();
  531. 			}
  532. 			else {
  533. 				return Promise.all(this.context.map(function (element) {
  534. 					return element.isDisplayed();
  535. 				}));
  536. 			}
  537. 		});
  538. 	},
  539. 	otherwise: deprecate('otherwise', 'catch'),
  540. 	always: deprecate('always', 'finally'),
  541. 	wait: deprecate('wait', 'sleep')
  542. };
  544. strategies.suffixes.forEach(function (suffix, index) {
  545. 	function addStrategy(method, toMethod, suffix, wdSuffix, using) {
  546. 		methods[method + 'OrNull'] = function (value) {
  547. 			return this.elementOrNull(using, value);
  548. 		};
  550. 		methods[method + 'IfExists'] = function (value) {
  551. 			return this.elementIfExists(using, value);
  552. 		};
  554. 		methods['hasElementBy' + wdSuffix] = function (value) {
  555. 			return this.hasElement(using, value);
  556. 		};
  558. 		methods['waitForElementBy' + wdSuffix] = function (value, timeout) {
  559. 			return this.waitForElement(using, value, timeout);
  560. 		};
  562. 		methods['waitForVisibleBy' + wdSuffix] = function (value, timeout) {
  563. 			return this.waitForVisible(using, value, timeout);
  564. 		};
  565. 	}
  567. 	var wdSuffix = suffix === 'Xpath' ? 'XPath' : suffix;
  568. 	var method = 'elementBy' + wdSuffix;
  569. 	var toMethod = 'findBy' + suffix;
  570. 	var using = strategies[index];
  571. 	addStrategy(method, toMethod, suffix, wdSuffix, using);
  572. 	if (suffix === 'CssSelector') {
  573. 		addStrategy('elementByCss', toMethod, suffix, 'Css', using);
  574. 	}
  575. });
  577. module.exports = {
  578. 	/**
  579. 	 * Applies the methods from compat to a {@link module:leadfoot/Command} prototype or instance.
  580. 	 *
  581. 	 * @param {module:leadfoot/Command} prototype A {@link module:leadfoot/Command} prototype or instance.
  582. 	 */
  583. 	applyTo: function (prototype) {
  584. 		for (var key in methods) {
  585. 			Object.defineProperty(prototype, key, Object.getOwnPropertyDescriptor(methods, key));
  586. 		}
  587. 	}
  588. };