Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use checkLifecycle method in Puppeteer

Best JavaScript code snippet using puppeteer

crosspagechannel_test.js

Source:crosspagechannel_test.js

1/**2 * @license3 * Copyright The Closure Library Authors.4 * SPDX-License-Identifier: Apache-2.05 */6goog.module('goog.net.xpc.CrossPageChannelTest');7goog.setTestOnly('goog.net.xpc.CrossPageChannelTest');8const CfgFields = goog.require('goog.net.xpc.CfgFields');9const ChannelStates = goog.require('goog.net.xpc.ChannelStates');10const CrossPageChannel = goog.require('goog.net.xpc.CrossPageChannel');11const CrossPageChannelRole = goog.require('goog.net.xpc.CrossPageChannelRole');12const Disposable = goog.require('goog.Disposable');13const GoogPromise = goog.require('goog.Promise');14const Level = goog.require('goog.log.Level');15const PropertyReplacer = goog.require('goog.testing.PropertyReplacer');16const Resolver = goog.require('goog.promise.Resolver');17const TagName = goog.require('goog.dom.TagName');18const TestCase = goog.require('goog.testing.TestCase');19const Timer = goog.require('goog.Timer');20const TransportTypes = goog.require('goog.net.xpc.TransportTypes');21const Uri = goog.require('goog.Uri');22const browser = goog.require('goog.labs.userAgent.browser');23const dispose = goog.require('goog.dispose');24const dom = goog.require('goog.dom');25const log = goog.require('goog.log');26const object = goog.require('goog.object');27const testSuite = goog.require('goog.testing.testSuite');28const xpc = goog.require('goog.net.xpc');29/** @suppress {extraRequire} Needed for G_testRunner.log() */30goog.require('goog.testing.jsunit');31// Set this to false when working on this test.  It needs to be true for32// automated testing, as some browsers (eg IE8) choke on the large numbers of33// iframes this test would otherwise leave active.34/** @const */35const CLEAN_UP_IFRAMES = true;36/** @const */37const IFRAME_LOAD_WAIT_MS = 1000;38const stubs = new PropertyReplacer();39let uniqueId = 0;40let driver;41let accessCheckPromise = null;42testSuite({43  setUpPage() {44    // This test is insanely slow on IE8 and Safari for some reason.45    TestCase.getActiveTestCase().promiseTimeout = 40 * 1000;46    // Show debug log47    const debugDiv = dom.getElement('debugDiv');48    const logger = log.getLogger('goog.net.xpc');49    log.setLevel(logger, Level.ALL);50    log.addHandler(logger, function(logRecord) {51      const msgElm = dom.createDom(TagName.DIV);52      msgElm.innerHTML = logRecord.getMessage();53      dom.appendChild(debugDiv, msgElm);54    });55    accessCheckPromise = new GoogPromise(function(resolve, reject) {56      const accessCheckIframes = [];57      accessCheckIframes.push(58          create1x1Iframe('nonexistent', 'testdata/i_am_non_existent.html'));59      window.setTimeout(function() {60        accessCheckIframes.push(61            create1x1Iframe('existent', 'testdata/access_checker.html'));62      }, 10);63      // Called from testdata/access_checker.html64      window['sameDomainIframeAccessComplete'] = function() {65        for (let i = 0; i < accessCheckIframes.length; i++) {66          document.body.removeChild(accessCheckIframes[i]);67        }68        resolve();69      };70    });71  },72  setUp() {73    driver = new Driver();74    // Expose driver on the window object, since inner_peer.html uses it to75    // communicate.76    window['driver'] = driver;77    // Ensure that the access check is complete before starting each test.78    return accessCheckPromise;79  },80  tearDown() {81    stubs.reset();82    driver.dispose();83  },84  testCreateIframeSpecifyId() {85    driver.createPeerIframe('new_iframe');86    return Timer.promise(IFRAME_LOAD_WAIT_MS).then(function() {87      driver.checkPeerIframe();88    });89  },90  testCreateIframeRandomId() {91    driver.createPeerIframe();92    return Timer.promise(IFRAME_LOAD_WAIT_MS).then(function() {93      driver.checkPeerIframe();94    });95  },96  testGetRole() {97    const cfg = {};98    cfg[CfgFields.ROLE] = CrossPageChannelRole.OUTER;99    const channel = new CrossPageChannel(cfg);100    // If the configured role is ignored, this will cause the dynamicly101    // determined role to become INNER.102    /** @suppress {visibility} suppression added to enable type checking */103    channel.peerWindowObject_ = window.parent;104    assertEquals(105        'Channel should use role from the config.', CrossPageChannelRole.OUTER,106        channel.getRole());107    channel.dispose();108  },109  // The following batch of tests:110  // * Establishes a peer iframe111  // * Connects an XPC channel between the frames112  // * From the connection callback in each frame, sends an 'echo' request, and113  //   expects a 'response' response.114  // * Reconnects the inner frame, sends an 'echo', expects a 'response'.115  // * Optionally, reconnects the outer frame, sends an 'echo', expects a116  //   'response'.117  // * Optionally, reconnects the inner frame, but first reconfigures it to the118  //   alternate protocol version, simulating an inner frame navigation that119  //   picks up a new/old version.120  //121  // Every valid combination of protocol versions is tested, with both single122  // and double ended handshakes.  Two timing scenarios are tested per123  // combination, which is what the 'reverse' parameter distinguishes.124  //125  // Where single sided handshake is in use, reconnection by the outer frame is126  // not supported, and therefore is not tested.127  //128  // The only known issue migrating to V2 is that once two V2 peers have129  // connected, replacing either peer with a V1 peer will not work.  Upgrading130  // V1 peers to v2 is supported, as is replacing the only v2 peer in a131  // connection with a v1.132  testLifeCycle_v1_v1() {133    return checkLifeCycle(134        false /* oneSidedHandshake */, 1 /* innerProtocolVersion */,135        1 /* outerProtocolVersion */, true /* outerFrameReconnectSupported */,136        true /* innerFrameMigrationSupported */, false /* reverse */);137  },138  testLifeCycle_v1_v1_rev() {139    return checkLifeCycle(140        false /* oneSidedHandshake */, 1 /* innerProtocolVersion */,141        1 /* outerProtocolVersion */, true /* outerFrameReconnectSupported */,142        true /* innerFrameMigrationSupported */, true /* reverse */);143  },144  testLifeCycle_v1_v1_onesided() {145    return checkLifeCycle(146        true /* oneSidedHandshake */, 1 /* innerProtocolVersion */,147        1 /* outerProtocolVersion */, false /* outerFrameReconnectSupported */,148        true /* innerFrameMigrationSupported */, false /* reverse */);149  },150  testLifeCycle_v1_v1_onesided_rev() {151    return checkLifeCycle(152        true /* oneSidedHandshake */, 1 /* innerProtocolVersion */,153        1 /* outerProtocolVersion */, false /* outerFrameReconnectSupported */,154        true /* innerFrameMigrationSupported */, true /* reverse */);155  },156  testLifeCycle_v1_v2() {157    return checkLifeCycle(158        false /* oneSidedHandshake */, 1 /* innerProtocolVersion */,159        2 /* outerProtocolVersion */, true /* outerFrameReconnectSupported */,160        true /* innerFrameMigrationSupported */, false /* reverse */);161  },162  testLifeCycle_v1_v2_rev() {163    return checkLifeCycle(164        false /* oneSidedHandshake */, 1 /* innerProtocolVersion */,165        2 /* outerProtocolVersion */, true /* outerFrameReconnectSupported */,166        true /* innerFrameMigrationSupported */, true /* reverse */);167  },168  testLifeCycle_v1_v2_onesided() {169    return checkLifeCycle(170        true /* oneSidedHandshake */, 1 /* innerProtocolVersion */,171        2 /* outerProtocolVersion */, false /* outerFrameReconnectSupported */,172        true /* innerFrameMigrationSupported */, false /* reverse */);173  },174  testLifeCycle_v1_v2_onesided_rev() {175    return checkLifeCycle(176        true /* oneSidedHandshake */, 1 /* innerProtocolVersion */,177        2 /* outerProtocolVersion */, false /* outerFrameReconnectSupported */,178        true /* innerFrameMigrationSupported */, true /* reverse */);179  },180  testLifeCycle_v2_v1() {181    return checkLifeCycle(182        false /* oneSidedHandshake */, 2 /* innerProtocolVersion */,183        1 /* outerProtocolVersion */, true /* outerFrameReconnectSupported */,184        true /* innerFrameMigrationSupported */, false /* reverse */);185  },186  testLifeCycle_v2_v1_rev() {187    return checkLifeCycle(188        false /* oneSidedHandshake */, 2 /* innerProtocolVersion */,189        1 /* outerProtocolVersion */, true /* outerFrameReconnectSupported */,190        true /* innerFrameMigrationSupported */, true /* reverse */);191  },192  testLifeCycle_v2_v1_onesided() {193    return checkLifeCycle(194        true /* oneSidedHandshake */, 2 /* innerProtocolVersion */,195        1 /* outerProtocolVersion */, false /* outerFrameReconnectSupported */,196        true /* innerFrameMigrationSupported */, false /* reverse */);197  },198  testLifeCycle_v2_v1_onesided_rev() {199    return checkLifeCycle(200        true /* oneSidedHandshake */, 2 /* innerProtocolVersion */,201        1 /* outerProtocolVersion */, false /* outerFrameReconnectSupported */,202        true /* innerFrameMigrationSupported */, true /* reverse */);203  },204  testLifeCycle_v2_v2() {205    // Test flakes on IE 10+ and Chrome: see b/22873770 and b/18595666.206    if ((browser.isIE() && browser.isVersionOrHigher(10)) ||207        browser.isChrome()) {208      return;209    }210    return checkLifeCycle(211        false /* oneSidedHandshake */, 2 /* innerProtocolVersion */,212        2 /* outerProtocolVersion */, true /* outerFrameReconnectSupported */,213        false /* innerFrameMigrationSupported */, false /* reverse */);214  },215  testLifeCycle_v2_v2_rev() {216    return checkLifeCycle(217        false /* oneSidedHandshake */, 2 /* innerProtocolVersion */,218        2 /* outerProtocolVersion */, true /* outerFrameReconnectSupported */,219        false /* innerFrameMigrationSupported */, true /* reverse */);220  },221  testLifeCycle_v2_v2_onesided() {222    return checkLifeCycle(223        true /* oneSidedHandshake */, 2 /* innerProtocolVersion */,224        2 /* outerProtocolVersion */, false /* outerFrameReconnectSupported */,225        false /* innerFrameMigrationSupported */, false /* reverse */);226  },227  testLifeCycle_v2_v2_onesided_rev() {228    return checkLifeCycle(229        true /* oneSidedHandshake */, 2 /* innerProtocolVersion */,230        2 /* outerProtocolVersion */, false /* outerFrameReconnectSupported */,231        false /* innerFrameMigrationSupported */, true /* reverse */);232  },233  // testConnectMismatchedNames have been flaky on IEs.234  // Flakiness is tracked in http://b/18595666235  // For now, not running these tests on IE.236  testConnectMismatchedNames_v1_v1() {237    if (browser.isIE()) {238      return;239    }240    return checkConnectMismatchedNames(241        1 /* innerProtocolVersion */, 1 /* outerProtocolVersion */,242        false /* reverse */);243  },244  testConnectMismatchedNames_v1_v1_rev() {245    if (browser.isIE()) {246      return;247    }248    return checkConnectMismatchedNames(249        1 /* innerProtocolVersion */, 1 /* outerProtocolVersion */,250        true /* reverse */);251  },252  testConnectMismatchedNames_v1_v2() {253    if (browser.isIE()) {254      return;255    }256    return checkConnectMismatchedNames(257        1 /* innerProtocolVersion */, 2 /* outerProtocolVersion */,258        false /* reverse */);259  },260  testConnectMismatchedNames_v1_v2_rev() {261    if (browser.isIE()) {262      return;263    }264    return checkConnectMismatchedNames(265        1 /* innerProtocolVersion */, 2 /* outerProtocolVersion */,266        true /* reverse */);267  },268  testConnectMismatchedNames_v2_v1() {269    if (browser.isIE()) {270      return;271    }272    return checkConnectMismatchedNames(273        2 /* innerProtocolVersion */, 1 /* outerProtocolVersion */,274        false /* reverse */);275  },276  testConnectMismatchedNames_v2_v1_rev() {277    if (browser.isIE()) {278      return;279    }280    return checkConnectMismatchedNames(281        2 /* innerProtocolVersion */, 1 /* outerProtocolVersion */,282        true /* reverse */);283  },284  testConnectMismatchedNames_v2_v2() {285    if (browser.isIE()) {286      return;287    }288    return checkConnectMismatchedNames(289        2 /* innerProtocolVersion */, 2 /* outerProtocolVersion */,290        false /* reverse */);291  },292  testConnectMismatchedNames_v2_v2_rev() {293    if (browser.isIE()) {294      return;295    }296    return checkConnectMismatchedNames(297        2 /* innerProtocolVersion */, 2 /* outerProtocolVersion */,298        true /* reverse */);299  },300  /** @suppress {checkTypes} suppression added to enable type checking */301  testEscapeServiceName() {302    /** @suppress {visibility} suppression added to enable type checking */303    const escape = CrossPageChannel.prototype.escapeServiceName_;304    assertEquals(305        'Shouldn\'t escape alphanumeric name', 'fooBar123',306        escape('fooBar123'));307    assertEquals(308        'Shouldn\'t escape most non-alphanumeric characters',309        '`~!@#$^&*()_-=+ []{}\'";,<.>/?\\',310        escape('`~!@#$^&*()_-=+ []{}\'";,<.>/?\\'));311    assertEquals(312        'Should escape %, |, and :', 'foo%3ABar%7C123%25',313        escape('foo:Bar|123%'));314    assertEquals('Should escape tp', '%25tp', escape('tp'));315    assertEquals('Should escape %tp', '%25%25tp', escape('%tp'));316    assertEquals('Should not escape stp', 'stp', escape('stp'));317    assertEquals('Should not escape s%tp', 's%25tp', escape('s%tp'));318  },319  testSameDomainCheck_noMessageOrigin() {320    const channel = new CrossPageChannel(321        object.create(CfgFields.PEER_HOSTNAME, 'http://foo.com'));322    assertTrue(channel.isMessageOriginAcceptable(undefined));323  },324  testSameDomainCheck_noPeerHostname() {325    const channel = new CrossPageChannel({});326    assertTrue(channel.isMessageOriginAcceptable('http://foo.com'));327  },328  testSameDomainCheck_unconfigured() {329    const channel = new CrossPageChannel({});330    assertTrue(channel.isMessageOriginAcceptable(undefined));331  },332  testSameDomainCheck_originsMatch() {333    const channel = new CrossPageChannel(334        object.create(CfgFields.PEER_HOSTNAME, 'http://foo.com'));335    assertTrue(channel.isMessageOriginAcceptable('http://foo.com'));336  },337  testSameDomainCheck_originsMismatch() {338    const channel = new CrossPageChannel(339        object.create(CfgFields.PEER_HOSTNAME, 'http://foo.com'));340    assertFalse(channel.isMessageOriginAcceptable('http://nasty.com'));341  },342  /** @suppress {checkTypes} suppression added to enable type checking */343  testUnescapeServiceName() {344    /** @suppress {visibility} suppression added to enable type checking */345    const unescape = CrossPageChannel.prototype.unescapeServiceName_;346    assertEquals(347        'Shouldn\'t modify alphanumeric name', 'fooBar123',348        unescape('fooBar123'));349    assertEquals(350        'Shouldn\'t modify most non-alphanumeric characters',351        '`~!@#$^&*()_-=+ []{}\'";,<.>/?\\',352        unescape('`~!@#$^&*()_-=+ []{}\'";,<.>/?\\'));353    assertEquals(354        'Should unescape URL-escapes', 'foo:Bar|123%',355        unescape('foo%3ABar%7C123%25'));356    assertEquals('Should unescape tp', 'tp', unescape('%25tp'));357    assertEquals('Should unescape %tp', '%tp', unescape('%25%25tp'));358    assertEquals('Should not escape stp', 'stp', unescape('stp'));359    assertEquals('Should not escape s%tp', 's%tp', unescape('s%25tp'));360  },361  async testDisposeImmediate() {362    // Given363    driver.createPeerIframe(364        'new_iframe',365        /* oneSidedHandshake= */ false,366        /* innerProtocolVersion= */ 2,367        /* outerProtocolVersion= */ 2,368        /* opt_randomChannelNames= */ true);369    assertEquals(driver.getChannel().state_, ChannelStates.NOT_CONNECTED);370    assertNull(driver.getChannel().transport_);371    // When372    driver.getChannel().dispose();373    // Then374    assertTrue(driver.getChannel().isDisposed());375    // Let any errors caused by erroneous retries happen.376    await Timer.promise(2000);377  },378  async testDisposeBeforePeerNotification() {379    // Given380    driver.createPeerIframe(381        'new_iframe',382        /* oneSidedHandshake= */ false,383        /* innerProtocolVersion= */ 2,384        /* outerProtocolVersion= */ 2,385        /* opt_randomChannelNames= */ true);386    await driver.connectAndWaitForPeer();387    assertEquals(driver.getChannel().state_, ChannelStates.NOT_CONNECTED);388    const transport = driver.getChannel().transport_;389    // When390    driver.getChannel().dispose();391    // Then392    assertNull(driver.getChannel().transport_);393    assertTrue(driver.getChannel().isDisposed());394    assertTrue(transport.isDisposed());395    // Let any errors caused by erroneous retries happen.396    await Timer.promise(2000);397  },398});399/**400 * @param {string} iframeId401 * @param {string} src402 * @return {!HTMLIFrameElement}403 */404function create1x1Iframe(iframeId, src) {405  const iframeAccessChecker = dom.createElement(TagName.IFRAME);406  iframeAccessChecker.id = iframeAccessChecker.name = iframeId;407  iframeAccessChecker.style.width = iframeAccessChecker.style.height = '1px';408  iframeAccessChecker.src = src;409  document.body.insertBefore(iframeAccessChecker, document.body.firstChild);410  return iframeAccessChecker;411}412/**413 * @param {boolean} oneSidedHandshake,414 * @param {number} innerProtocolVersion415 * @param {number} outerProtocolVersion416 * @param {boolean} outerFrameReconnectSupported417 * @param {boolean} innerFrameMigrationSupported418 * @param {boolean} reverse419 * @return {!GoogPromise<undefined>}420 */421function checkLifeCycle(422    oneSidedHandshake, innerProtocolVersion, outerProtocolVersion,423    outerFrameReconnectSupported, innerFrameMigrationSupported, reverse) {424  driver.createPeerIframe(425      'new_iframe', oneSidedHandshake, innerProtocolVersion,426      outerProtocolVersion);427  return driver.connect(428      true /* fullLifeCycleTest */, outerFrameReconnectSupported,429      innerFrameMigrationSupported, reverse);430}431/**432 * @param {number} innerProtocolVersion433 * @param {number} outerProtocolVersion434 * @param {boolean} reverse435 * @return {!GoogPromise<undefined>}436 */437function checkConnectMismatchedNames(438    innerProtocolVersion, outerProtocolVersion, reverse) {439  driver.createPeerIframe(440      'new_iframe', false /* oneSidedHandshake */, innerProtocolVersion,441      outerProtocolVersion, true /* opt_randomChannelNames */);442  return driver.connect(443      false /* fullLifeCycleTest */, false /* outerFrameReconnectSupported */,444      false /* innerFrameMigrationSupported */, reverse /* reverse */);445}446/**447 * Driver for the tests for CrossPageChannel.448 * @unrestricted449 */450const Driver = class extends Disposable {451  constructor() {452    super();453    /**454     * The peer iframe.455     * @type {!Element}456     * @private457     * @suppress {checkTypes} suppression added to enable type checking458     */459    this.iframe_ = null;460    /**461     * The channel to use.462     * @type {?CrossPageChannel}463     * @private464     */465    this.channel_ = null;466    /**467     * Outer frame configuration object.468     * @type {?Object}469     * @private470     */471    this.outerFrameCfg_ = null;472    /**473     * The initial name of the outer channel.474     * @type {?string}475     * @private476     */477    this.initialOuterChannelName_ = null;478    /**479     * Inner frame configuration object.480     * @type {?Object}481     * @private482     */483    this.innerFrameCfg_ = null;484    /**485     * The contents of the payload of the 'echo' request sent by the inner486     * frame.487     * @type {?string}488     * @private489     */490    this.innerFrameEchoPayload_ = null;491    /**492     * The contents of the payload of the 'echo' request sent by the outer493     * frame.494     * @type {?string}495     * @private496     */497    this.outerFrameEchoPayload_ = null;498    /**499     * A resolver which fires its promise when the inner frame receives an echo.500     * @type {!Resolver}501     * @private502     */503    this.innerFrameResponseReceived_ = GoogPromise.withResolver();504    /**505     * A resolver which fires its promise when the outer frame receives an echo.506     * @type {!Resolver}507     * @private508     */509    this.outerFrameResponseReceived_ = GoogPromise.withResolver();510  }511  /** @override */512  disposeInternal() {513    // Required to make this test perform acceptably (and pass) on slow514    // browsers, esp IE8.515    if (CLEAN_UP_IFRAMES) {516      dom.removeNode(this.iframe_);517      delete this.iframe_;518    }519    dispose(this.channel_);520    this.innerFrameResponseReceived_.promise.cancel();521    this.outerFrameResponseReceived_.promise.cancel();522    super.disposeInternal();523  }524  /**525   * Returns the child peer's window object.526   * @return {!Window} Child peer's window.527   * @private528   * @suppress {strictMissingProperties} suppression added to enable type529   * checking530   */531  getInnerPeer_() {532    return this.iframe_.contentWindow;533  }534  /**535   * Sets up the configuration objects for the inner and outer frames.536   * @param {string=} opt_iframeId If present, the ID of the iframe to use,537   *     otherwise, tells the channel to generate an iframe ID.538   * @param {boolean=} opt_oneSidedHandshake Whether the one sided handshake539   *     config option should be set.540   * @param {string=} opt_channelName The name of the channel to use, or null541   *     to generate one.542   * @param {number=} opt_innerProtocolVersion The native transport protocol543   *     version used in the inner iframe.544   * @param {number=} opt_outerProtocolVersion The native transport protocol545   *     version used in the outer iframe.546   * @param {boolean=} opt_randomChannelNames Whether the different ends of the547   *     channel should be allowed to pick differing, random names.548   * @return {string} The name of the created channel.549   * @private550   * @suppress {missingReturn} suppression added to enable type checking551   */552  setConfiguration_(553      opt_iframeId, opt_oneSidedHandshake, opt_channelName,554      opt_innerProtocolVersion, opt_outerProtocolVersion,555      opt_randomChannelNames) {556    const cfg = {};557    if (opt_iframeId) {558      cfg[CfgFields.IFRAME_ID] = opt_iframeId;559    }560    cfg[CfgFields.PEER_URI] = 'testdata/inner_peer.html';561    if (!opt_randomChannelNames) {562      const channelName = opt_channelName || 'test_channel' + uniqueId++;563      cfg[CfgFields.CHANNEL_NAME] = channelName;564    }565    cfg[CfgFields.LOCAL_POLL_URI] = 'does-not-exist.html';566    cfg[CfgFields.PEER_POLL_URI] = 'does-not-exist.html';567    cfg[CfgFields.ONE_SIDED_HANDSHAKE] = !!opt_oneSidedHandshake;568    cfg[CfgFields.NATIVE_TRANSPORT_PROTOCOL_VERSION] = opt_outerProtocolVersion;569    function resolveUri(fieldName) {570      cfg[fieldName] =571          Uri.resolve(window.location.href, cfg[fieldName]).toString();572    }573    resolveUri(CfgFields.PEER_URI);574    resolveUri(CfgFields.LOCAL_POLL_URI);575    resolveUri(CfgFields.PEER_POLL_URI);576    this.outerFrameCfg_ = cfg;577    this.innerFrameCfg_ = object.clone(cfg);578    this.innerFrameCfg_[CfgFields.NATIVE_TRANSPORT_PROTOCOL_VERSION] =579        opt_innerProtocolVersion;580  }581  /**582   * Creates an outer frame channel object.583   * @return {string}584   * @private585   * @suppress {checkTypes} suppression added to enable type checking586   */587  createChannel_() {588    if (this.channel_) {589      this.channel_.dispose();590    }591    this.channel_ = new CrossPageChannel(this.outerFrameCfg_);592    this.channel_.registerService('echo', goog.bind(this.echoHandler_, this));593    this.channel_.registerService(594        'response', goog.bind(this.responseHandler_, this));595    return this.channel_.name;596  }597  /**598   * Checks the names of the inner and outer frames meet expectations.599   * @private600   * @suppress {undefinedVars} suppression added to enable type checking601   */602  checkChannelNames_() {603    const outerName = this.channel_.name;604    /**605     * @suppress {missingProperties} suppression added to enable type checking606     */607    const innerName = this.getInnerPeer_().channel.name;608    const configName = this.innerFrameCfg_[CfgFields.CHANNEL_NAME] || null;609    // The outer channel never changes its name.610    assertEquals(this.initialOuterChannelName_, outerName);611    // The name should be as configured, if it was configured.612    if (configName) {613      assertEquals(configName, innerName);614    }615    // The names of both ends of the channel should match.616    assertEquals(innerName, outerName);617    G_testRunner.log('Channel name: ' + innerName);618  }619  /**620   * Returns the configuration of the xpc.621   * @return {?Object} The configuration of the xpc.622   */623  getInnerFrameConfiguration() {624    return this.innerFrameCfg_;625  }626  /**627   * Creates the peer iframe.628   * @param {string=} opt_iframeId If present, the ID of the iframe to create,629   *     otherwise, generates an iframe ID.630   * @param {boolean=} opt_oneSidedHandshake Whether a one sided handshake is631   *     specified.632   * @param {number=} opt_innerProtocolVersion The native transport protocol633   *     version used in the inner iframe.634   * @param {number=} opt_outerProtocolVersion The native transport protocol635   *     version used in the outer iframe.636   * @param {boolean=} opt_randomChannelNames Whether the ends of the channel637   *     should be allowed to pick differing, random names.638   * @return {!Array<string>} The id of the created iframe and the name of the639   *     created channel.640   * @suppress {missingReturn} suppression added to enable type checking641   */642  createPeerIframe(643      opt_iframeId, opt_oneSidedHandshake, opt_innerProtocolVersion,644      opt_outerProtocolVersion, opt_randomChannelNames) {645    let expectedIframeId;646    if (opt_iframeId) {647      expectedIframeId = opt_iframeId = opt_iframeId + uniqueId++;648    } else {649      // Have createPeerIframe() generate an ID650      stubs.set(xpc, 'getRandomString', function(length) {651        return '' + length;652      });653      expectedIframeId = 'xpcpeer4';654    }655    assertNull(656        'element[id=' + expectedIframeId + '] exists',657        dom.getElement(expectedIframeId));658    this.setConfiguration_(659        opt_iframeId, opt_oneSidedHandshake, undefined /* opt_channelName */,660        opt_innerProtocolVersion, opt_outerProtocolVersion,661        opt_randomChannelNames);662    const channelName = this.createChannel_();663    this.initialOuterChannelName_ = channelName;664    this.iframe_ = this.channel_.createPeerIframe(document.body);665    assertEquals(expectedIframeId, this.iframe_.id);666  }667  /**668   * Checks if the peer iframe has been created.669   */670  checkPeerIframe() {671    assertNotNull(this.iframe_);672    const peer = this.getInnerPeer_();673    assertNotNull(peer);674    assertNotNull(peer.document);675  }676  /**677   * Starts the connection. The connection happens asynchronously.678   * @param {boolean} fullLifeCycleTest679   * @param {boolean} outerFrameReconnectSupported680   * @param {boolean} innerFrameMigrationSupported681   * @param {boolean} reverse682   * @return {!GoogPromise<undefined>}683   * @suppress {checkTypes} suppression added to enable type checking684   */685  connect(686      fullLifeCycleTest, outerFrameReconnectSupported,687      innerFrameMigrationSupported, reverse) {688    if (!this.isTransportTestable_()) {689      return;690    }691    // Set the criteria for the initial handshake portion of the test.692    this.reinitializePromises_();693    this.innerFrameResponseReceived_.promise.then(694        this.checkChannelNames_, null, this);695    if (fullLifeCycleTest) {696      this.innerFrameResponseReceived_.promise.then(goog.bind(697          this.testReconnects_, this, outerFrameReconnectSupported,698          innerFrameMigrationSupported));699    }700    this.continueConnect_(reverse);701    return this.innerFrameResponseReceived_.promise;702  }703  /**704   * @param {boolean} reverse705   * @private706   * @suppress {missingProperties} suppression added to enable type checking707   */708  continueConnect_(reverse) {709    // Wait until the peer is fully established.  Establishment is sometimes710    // very slow indeed, especially on virtual machines, so a fixed timeout is711    // not suitable.  This wait is required because we want to take precise712    // control of the channel startup timing, and shouldn't be needed in713    // production use, where the inner frame's channel is typically not started714    // by a DOM call as it is here.715    if (!this.getInnerPeer_() || !this.getInnerPeer_().instantiateChannel) {716      window.setTimeout(goog.bind(this.continueConnect_, this, reverse), 100);717      return;718    }719    const connectFromOuterFrame = goog.bind(720        this.channel_.connect, this.channel_,721        goog.bind(this.outerFrameConnected_, this));722    const innerConfig = this.innerFrameCfg_;723    /**724     * @suppress {missingProperties} suppression added to enable type checking725     */726    const connectFromInnerFrame = goog.bind(727        this.getInnerPeer_().instantiateChannel, this.getInnerPeer_(),728        innerConfig);729    // Take control of the timing and reverse of each frame's first SETUP call.730    // If these happen to fire right on top of each other, that tends to mask731    // problems that reliably occur when there is a short delay.732    window.setTimeout(connectFromOuterFrame, reverse ? 1 : 10);733    window.setTimeout(connectFromInnerFrame, reverse ? 10 : 1);734  }735  /**736   * Called by the outer frame connection callback.737   * @private738   */739  outerFrameConnected_() {740    const payload = this.outerFrameEchoPayload_ = xpc.getRandomString(10);741    this.channel_.send('echo', payload);742  }743  /**744   * Called by the inner frame connection callback in inner_peer.html.745   * @suppress {missingProperties} suppression added to enable type checking746   */747  innerFrameConnected() {748    const payload = this.innerFrameEchoPayload_ = xpc.getRandomString(10);749    this.getInnerPeer_().sendEcho(payload);750  }751  /**752   * The handler function for incoming echo requests.753   * @param {string} payload The message payload.754   * @private755   * @suppress {strictMissingProperties} suppression added to enable type756   * checking757   */758  echoHandler_(payload) {759    assertTrue('outer frame should be connected', this.channel_.isConnected());760    const peer = this.getInnerPeer_();761    assertTrue('child should be connected', peer.isConnected());762    this.channel_.send('response', payload);763  }764  /**765   * The handler function for incoming echo responses.766   * @param {string} payload The message payload.767   * @private768   * @suppress {strictMissingProperties} suppression added to enable type769   * checking770   */771  responseHandler_(payload) {772    assertTrue('outer frame should be connected', this.channel_.isConnected());773    const peer = this.getInnerPeer_();774    assertTrue('child should be connected', peer.isConnected());775    assertEquals(this.outerFrameEchoPayload_, payload);776    this.outerFrameResponseReceived_.resolve(true);777  }778  /**779   * The handler function for incoming echo replies. Called from780   * inner_peer.html.781   * @param {string} payload The message payload.782   * @suppress {strictMissingProperties} suppression added to enable type783   * checking784   */785  innerFrameGotResponse(payload) {786    assertTrue('outer frame should be connected', this.channel_.isConnected());787    const peer = this.getInnerPeer_();788    assertTrue('child should be connected', peer.isConnected());789    assertEquals(this.innerFrameEchoPayload_, payload);790    this.innerFrameResponseReceived_.resolve(true);791  }792  /**793   * The second phase of the standard test, where reconnections of both the794   * inner and outer frames are performed.795   * @param {boolean} outerFrameReconnectSupported Whether outer frame796   *     reconnects are supported, and should be tested.797   * @param {boolean} innerFrameMigrationSupported798   * @private799   */800  testReconnects_(outerFrameReconnectSupported, innerFrameMigrationSupported) {801    G_testRunner.log('Performing inner frame reconnect');802    this.reinitializePromises_();803    this.innerFrameResponseReceived_.promise.then(804        this.checkChannelNames_, null, this);805    if (outerFrameReconnectSupported) {806      this.innerFrameResponseReceived_.promise.then(goog.bind(807          this.performOuterFrameReconnect_, this,808          innerFrameMigrationSupported));809    } else if (innerFrameMigrationSupported) {810      this.innerFrameResponseReceived_.promise.then(811          this.migrateInnerFrame_, null, this);812    }813    this.performInnerFrameReconnect_();814  }815  /**816   * Initializes the promise resolvers and clears the echo payloads, ready for817   * another sub-test.818   * @private819   */820  reinitializePromises_() {821    this.innerFrameEchoPayload_ = null;822    this.outerFrameEchoPayload_ = null;823    this.innerFrameResponseReceived_.promise.cancel();824    this.innerFrameResponseReceived_ = GoogPromise.withResolver();825    this.outerFrameResponseReceived_.promise.cancel();826    this.outerFrameResponseReceived_ = GoogPromise.withResolver();827  }828  /**829   * Get the inner frame to reconnect, and repeat the echo test.830   * @private831   * @suppress {missingProperties} suppression added to enable type checking832   */833  performInnerFrameReconnect_() {834    const peer = this.getInnerPeer_();835    peer.instantiateChannel(this.innerFrameCfg_);836  }837  /**838   * Get the outer frame to reconnect, and repeat the echo test.839   * @private840   */841  performOuterFrameReconnect_(innerFrameMigrationSupported) {842    G_testRunner.log('Closing channel');843    this.channel_.close();844    // If there is another channel still open, the native transport's global845    // postMessage listener will still be active.  This will mean that messages846    // being sent to the now-closed channel will still be received and847    // delivered, such as transport service traffic from its previous848    // correspondent in the other frame.  Ensure these messages don't cause849    // exceptions.850    try {851      this.channel_.xpcDeliver(xpc.TRANSPORT_SERVICE, 'payload');852    } catch (e) {853      fail('Should not throw exception');854    }855    G_testRunner.log('Reconnecting outer frame');856    this.reinitializePromises_();857    this.innerFrameResponseReceived_.promise.then(858        this.checkChannelNames_, null, this);859    if (innerFrameMigrationSupported) {860      this.outerFrameResponseReceived_.promise.then(861          this.migrateInnerFrame_, null, this);862    }863    this.channel_.connect(goog.bind(this.outerFrameConnected_, this));864  }865  /**866   * Migrate the inner frame to the alternate protocol version and reconnect it.867   * @private868   */869  migrateInnerFrame_() {870    G_testRunner.log('Migrating inner frame');871    this.reinitializePromises_();872    const innerFrameProtoVersion =873        this.innerFrameCfg_[CfgFields.NATIVE_TRANSPORT_PROTOCOL_VERSION];874    this.innerFrameResponseReceived_.promise.then(875        this.checkChannelNames_, null, this);876    this.innerFrameCfg_[CfgFields.NATIVE_TRANSPORT_PROTOCOL_VERSION] =877        innerFrameProtoVersion == 1 ? 2 : 1;878    this.performInnerFrameReconnect_();879  }880  /**881   * Determines if the transport type for the channel is testable.882   * Some transports are misusing global state or making other883   * assumptions that cause connections to fail.884   * @return {boolean} Whether the transport is testable.885   * @private886   */887  isTransportTestable_() {888    let testable = false;889    /** @suppress {visibility} suppression added to enable type checking */890    const transportType = this.channel_.determineTransportType_();891    switch (transportType) {892      case TransportTypes.NATIVE_MESSAGING:893      case TransportTypes.DIRECT:894        testable = true;895        break;896    }897    return testable;898  }899  /** @return {?CrossPageChannel} */900  getChannel() {901    return this.channel_;902  }903  /**904   * Begin, but don't finish, connection to a peer.905   *906   * @return {!Promise<undefined>} A timing hook for the unstable period between907   *     the creation of the peer and the connection notification from that908   * peer.909   */910  connectAndWaitForPeer() {911    this.channel_.connect();912    // Set a listener for when the peer exists.913    return new Promise(914        /** @suppress {visibility} suppression added to enable type checking */915        (res) => this.channel_.peerWindowDeferred_.addCallback(res));916  }...

NavigatorWatcher.js

Source:NavigatorWatcher.js

...85  _checkLifecycleComplete() {86    // We expect navigation to commit.87    if (this._frame._loaderId === this._initialLoaderId && !this._hasSameDocumentNavigation)88      return;89    if (!checkLifecycle(this._frame, this._expectedLifecycle))90      return;91    this._lifecycleCompleteCallback();92    /**93     * @param {!Puppeteer.Frame} frame94     * @param {!Array<string>} expectedLifecycle95     * @return {boolean}96     */97    function checkLifecycle(frame, expectedLifecycle) {98      for (const event of expectedLifecycle) {99        if (!frame._lifecycleEvents.has(event))100          return false;101      }102      for (const child of frame.childFrames()) {103        if (!checkLifecycle(child, expectedLifecycle))104          return false;105      }106      return true;107    }108  }109  cancel() {110    this._cleanup();111  }112  _cleanup() {113    helper.removeEventListeners(this._eventListeners);114    this._lifecycleCompleteCallback(new Error('Navigation failed'));115    clearTimeout(this._maximumTimer);116  }117}...

Using AI Code Generation

1const puppeteer = require('puppeteer');2const { checkLifecycle } = require('puppeteer-lifecycle');3(async () => {4  const browser = await puppeteer.launch({ headless: false });5  const page = await browser.newPage();6  await checkLifecycle(page, 'networkidle0', 10000);7  await page.screenshot({ path: 'example.png' });8  await browser.close();9})();10### checkLifecycle(page, lifecycle, timeout)

Using AI Code Generation

1const puppeteer = require('puppeteer');2const browser = await puppeteer.launch({headless: false});3const page = await browser.newPage();4await page.screenshot({path: 'example.png'});5await browser.close();6To get more help on the Puppeteer API, check out the [Puppeteer API documentation](

Using AI Code Generation

1const puppeteer = require('puppeteer');2const browser = await puppeteer.launch();3const page = await browser.newPage();4await page.checkLifecycle();5await browser.close();6### page.checkLifecycle()7### page.checkLifecycle(options)8MIT © [Nathan Sobo](

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.