How to use asyncbox - 10 common examples

async function ensureUnlocked (driver) {
  // on Travis the device is sometimes not unlocked
  await retryInterval(10, 1000, async function () {
    if (!await driver.isLocked()) {
      return;
    }
    console.log(`\n\nDevice locked. Attempting to unlock`); // eslint-disable-line
    await driver.unlock();
    // trigger another iteration
    throw new Error(`The device is locked.`);
  });
}

it('should type a url in the text field', async function () {
          // in Travis this sometimes gets the wrong text
          let retries = process.env.CI ? 5 : 1;
          await retryInterval(retries, 100, async () => {
            let el = await driver.elementByClassName('XCUIElementTypeTextField');
            await el.clear();
            await el.type(text3);

            let text = await el.text();
            text.should.eql(text3);
          });
        });
        it('should be able to type into two text fields', async function () {

it('should (the device) be available for commands after reboot', async function () {
      // override default timeout since we need to wait for the device to reboot
      this.timeout(30000);
      let command = {
        type:   "reboot"
      };
      await device.runCommand(command);
      // sleep then connect to the device again
      await sleep(20000); // time required before an S4 running Android 5 is available
      availableDevices = await ADB.findAdbDevices();
      // just select the first device
      device = new ADB(CONNECTION_TYPES.USB, availableDevices[0]);
      await device.connect();
      // run a very basic command to confirm device is okay
      let commandString = "cd sdcard/ ; pwd";
      let expectedReturnString = "/sdcard";
      let checkCommand = { // set print to false so we get the data back as a string
        type: "shell"
      , string: commandString
      , print: false
      };
      let output = await device.runCommand(checkCommand);
      output.trim().should.equal(expectedReturnString);
    });
  });

it('should toggle wifi on real devices', async function () {
      await driver.createSession(defaultCaps);
      let isWifiOn = await driver.isWifiOn();
      if (isWifiOn) {
        await driver.setWifiState(0, false);
        await sleep(500);
        isWifiOn = await driver.isWifiOn();
        isWifiOn.should.be.false;
      } else {
        await driver.setWifiState(1, false);
        // enabling wifi takes time
        await sleep(2500);
        isWifiOn = await driver.isWifiOn();
        isWifiOn.should.be.true;
      }
    });
  });

it('should remove session if inner driver unexpectedly exits with no error', async function () {
        let [sessionId,] = (await appium.createSession(_.clone(BASE_CAPS))).value; // eslint-disable-line comma-spacing
        _.keys(appium.sessions).should.contain(sessionId);
        appium.sessions[sessionId].eventEmitter.emit('onUnexpectedShutdown');
        // let event loop spin so rejection is handled
        await sleep(1);
        _.keys(appium.sessions).should.not.contain(sessionId);
      });
    });

await retryInterval(startupRetries, startupRetryInterval, async () => {
        this.logEvent('wdaStartAttempted');
        if (retryCount > 0) {
          log.info(`Retrying WDA startup (${retryCount + 1} of ${startupRetries})`);
        }
        try {
          // on xcode 10 installd will often try to access the app from its staging
          // directory before fully moving it there, and fail. Retrying once
          // immediately helps
          const retries = this.xcodeVersion.major >= 10 ? 2 : 1;
          this.cachedWdaStatus = await retry(retries, this.wda.launch.bind(this.wda), sessionId, realDevice);
        } catch (err) {
          this.logEvent('wdaStartFailed');
          retryCount++;
          let errorMsg = `Unable to launch WebDriverAgent because of xcodebuild failure: ${err.message}`;
          if (this.isRealDevice()) {
            errorMsg += `. Make sure you follow the tutorial at ${WDA_REAL_DEV_TUTORIAL_URL}. ` +
                        `Try to remove the WebDriverAgentRunner application from the device if it is installed ` +
                        `and reboot the device.`;
          }
          await quitAndUninstall(errorMsg);
        }

        this.proxyReqRes = this.wda.proxyReqRes.bind(this.wda);
        this.jwpProxyActive = true;

        let originalStacktrace = null;

} catch (ign) {}
  }

  if (CLOUD) {
    // on cloud tests, we want to set the `name` capability
    if (!caps.name) {
      caps.name = process.env.SAUCE_JOB_NAME || process.env.TRAVIS_JOB_NUMBER || 'unnamed';
    }
  }

  // Create a WD driver
  const host = getHost();
  const port = getPort();
  logger.debug(`Starting session on ${host}:${port}`);
  driver = await wd.promiseChainRemote(host, port);
  await retry(INIT_RETRIES, driver.init.bind(driver), caps);

  // In Travis, there is sometimes a popup
  if (CI && !CLOUD) {
    const startArgs = _.pick(caps, ['appPackage', 'appActivity', 'appWaitPackage', 'appWaitActivity', 'intentAction', 'intentCategory', 'intentFlags', 'optionalIntentArguments', 'dontStopAppOnReset', 'sessionId', 'id']);
    for (const btnId of ['android:id/button1', 'android:id/aerr_wait']) {
      let alertFound = false;
      await retryInterval(ALERT_CHECK_RETRIES, ALERT_CHECK_INTERVAL, async function () {
        let btn;
        try {
          btn = await driver.elementById(btnId);
          alertFound = true;
        } catch (ign) {
          // no element found, so just finish
          return;
        }
        logger.warn('*******************************************************');

before(async function () {
    sim = await getExistingSim(DEVICE_NAME, PLATFORM_VERSION);
    if (!sim) {
      const udid = await createDevice(SIM_NAME, DEVICE_NAME, PLATFORM_VERSION);
      sim = await getSimulator(udid);
      simCreated = true;
    }
    // on certain system, particularly Xcode 11 on Travis, starting the sim fails
    await retry(4, async function () {
      try {
        await sim.run({
          startupTimeout: 60000,
        });
      } catch (err) {
        await sim.shutdown();
        throw err;
      }
    });

    const port = await startHttpServer();
    address = `http://localhost:${port}`;
  });
  after(async function () {

systemCallMethods.waitForEmulatorReady = async function waitForEmulatorReady (timeoutMs = 20000) {
  try {
    await waitForCondition(async () => {
      try {
        if (!(await this.shell(['getprop', 'init.svc.bootanim'])).includes('stopped')) {
          return false;
        }
        // Sometimes the package manager service might still being initialized
        // on slow systems even after emulator booting is completed.
        // The usual output of `pm get-install-location` command looks like `0[auto]`
        return /\d+\[\w+\]/.test(await this.shell(['pm', 'get-install-location']));
      } catch (err) {
        log.debug(`Waiting for emulator startup. Intermediate error: ${err.message}`);
        return false;
      }
    }, {
      waitMs: timeoutMs,
      intervalMs: 3000,
    });

try {
      const args = [...this.executable.defaultArgs, ...cmd];
      log.debug(`Running '${this.executable.path} ${quote(args)}'`);
      let {stdout} = await exec(this.executable.path, args, opts);
      // sometimes ADB prints out weird stdout warnings that we don't want
      // to include in any of the response data, so let's strip it out
      stdout = stdout.replace(LINKER_WARNING_REGEXP, '').trim();
      return stdout;
    } catch (e) {
      const errText = `${e.message}, ${e.stdout}, ${e.stderr}`;
      const protocolFaultError = PROTOCOL_FAULT_ERROR_REGEXP.test(errText);
      const deviceNotFoundError = DEVICE_NOT_FOUND_ERROR_REGEXP.test(errText);
      const deviceConnectingError = DEVICE_CONNECTING_ERROR_REGEXP.test(errText);
      if (protocolFaultError || deviceNotFoundError || deviceConnectingError) {
        log.info(`Error sending command, reconnecting device and retrying: ${cmd}`);
        await sleep(1000);
        await this.getDevicesWithRetry();

        // try again one time
        if (adbRetried) {
          adbRetried = true;
          return await execFunc();
        }
      }

      if (e.code === 0 && e.stdout) {
        return e.stdout.replace(LINKER_WARNING_REGEXP, '').trim();
      }

      if (_.isNull(e.code)) {
        e.message = `Error executing adbExec. Original error: '${e.message}'. ` +
          `Try to increase the ${opts.timeout}ms adb execution timeout represented by '${opts.timeoutCapName}' capability`;