selenium: `async`/`await` breaks the control flow

Well, the good news is I already have the code for disabling the control flow completed, I just haven’t pushed it (hoping this week). So you could tell users if they want to use async, disable the control flow (there’s no need for it if you’re using async)

@jleyba

is there any specific date already for the release 4.0 since this is causing our tests to fail.

FYI 3.0 has been pushed to npm, so you can disable the promise manager now.

The promise manager has been removed from the code base (5650b96185df72ee074f3c660ef5efd227b2739a).

This will be included in the 4.0 release (which won’t go out until Node releases their next LTS later this month).

It’s a timing issue with how the control flow tracks individual turns of the js event loop (which dictates when actions are linked). With your initial example, that first promise just needs to be asynchronously resolved - reproduces with native promises. I really want to sweep this under the rug, but given the control flow isn’t going anywhere for a while, I’ll see if I can track it down.

'use strict';

const assert = require('assert');
const {promise} = require('selenium-webdriver');
const flow = promise.controlFlow();

describe('timing issues', function() {
  function runInFlow(fn) {
    return flow.execute(() => {
      return promise.fulfilled(fn());
    });
  }

  function runTest(seedFn) {
    let value = '';
    return new Promise(resolve => {
      flow.once('idle', resolve);

      runInFlow(() => {
        value += 'a';

        return seedFn().then(() => {
          value += 'b';

          runInFlow(() => {
            value += 'c';
            return promise.delayed(500).then(() => {
              value += 'd';
            });
          });
        })
        .then(_ => value += 'e');
      });

      runInFlow(_ => value += 'f');

    // e before df b/c native promises won't wait for unlinked control flow result.
    }).then(() => assert.equal(value, 'abcedf'));
  }

  function test(seedFn) {
    it(seedFn + '', () => runTest(seedFn));
  }

  test(() => Promise.resolve());
  test(() => Promise.resolve(new Promise(r => r())));
  test(() => new Promise(r => r()));
  test(() => new Promise(r => r(Promise.resolve())));
  test(() => new Promise(r => r(new Promise(r => r()))));
  test(() => new Promise(r => setTimeout(() => r(), 10)));
});

$ mocha promise_test.js 


  timing issues
    ✓ () => Promise.resolve() (513ms)
    ✓ () => Promise.resolve(new Promise(r => r())) (506ms)
    ✓ () => new Promise(r => r()) (507ms)
    1) () => new Promise(r => r(Promise.resolve()))
    2) () => new Promise(r => r(new Promise(r => r())))
    3) () => new Promise(r => setTimeout(() => r(), 10))


  3 passing (3s)
  3 failing

  1) timing issues () => new Promise(r => r(Promise.resolve())):

      AssertionError: 'abcefd' == 'abcedf'
      + expected - actual

      -abcefd
      +abcedf

      at Promise.then (promise_test.js:38:26)

  2) timing issues () => new Promise(r => r(new Promise(r => r()))):

      AssertionError: 'abcefd' == 'abcedf'
      + expected - actual

      -abcefd
      +abcedf

      at Promise.then (promise_test.js:38:26)

  3) timing issues () => new Promise(r => setTimeout(() => r(), 10)):

      AssertionError: 'abcefd' == 'abcedf'
      + expected - actual

      -abcefd
      +abcedf

      at Promise.then (promise_test.js:38:26)

Your example is working as intended. The control flow synchronizes actions within “frames”, which are tied to the JavaScript event loop (as best as the control flow can). Will comment further using your code sample:

runInFlow(() => {
  // Frame 1: this is the initial frame.
  // The control flow will synchronize tasks and callbacks attached to managed
  // promises. The control flow is not able to track native promises.

  val = 1;
  return new Promise((resolve) => {
    resolve(webdriver.promise.fulfilled(7));
  }).then((seven) => {

    // This is a callback on a native promise and runs in its own turn of the JS event loop.
    // Since it is from a native promise, the control flow does not know it was chained from
    // frame 1, so the control flow creates an independent task queue. All tasks and managed
    // promise callbacks within this frame will be synchronized with each other, but not against
    // Frame 1.
    //
    // Return the promise result of this task to make every synchronize.
    runInFlow(() => {
      return webdriver.promise.delayed(1000).then(() => {
        val = seven;
      });
    }, 'set outer');
  });
}, 'set inner');

// This task is scheduled in Frame 1, so it will not execute until "set inner" completes.
runInFlow(() => {
  console.log('RESULT: val = ' + val); // 1, should be 7
}, 'log');

Same with your first example, add an await/return to link everything up:

describe('async function + control flow', function() {
  var val;
  var seven;
  it('should wait for this it() to finish', async function() {
    val = 1;
    seven = await webdriver.promise.fulfilled(7);
    await controlFlow.execute(() => {
      return webdriver.promise.delayed(1000).then(() => {
        val = seven;
    }));
  });

  it('should have waited for setter in previous it()', function() {
    expect(val).toBe(7); // <<------ This fails
  });
});