selenium-webdriver 2.43.5 → 2.44.0

package/lib/webdriver/stacktrace.js

@@ -353,7 +353,9 @@ webdriver.stacktrace.V8_LOCATION_PATTERN_ = ' (?:\\((.*)\\)|(.*))';
  * @private {!RegExp}
  * @const
  */
-webdriver.stacktrace.V8_STACK_FRAME_REGEXP_ = new RegExp('^    at' +
+webdriver.stacktrace.V8_STACK_FRAME_REGEXP_ = new RegExp('^\\s+at' +
+    // Prevent intersections with IE10 stack frame regex.
+    '(?! (?:Anonymous function|Global code|eval code) )' +
     '(?:' + webdriver.stacktrace.V8_FUNCTION_CALL_PATTERN_ + ')?' +
     webdriver.stacktrace.V8_LOCATION_PATTERN_ + '$');
 
@@ -591,6 +593,18 @@ webdriver.stacktrace.format = function(error) {
   var stack = webdriver.stacktrace.getStack_(error);
   var frames = webdriver.stacktrace.parse_(stack);
 
+  // If the original stack is in an unexpected format, our formatted stack
+  // trace will be a bunch of "    at <anonymous>" lines. If this is the case,
+  // just return the error unmodified to avoid losing information. This is
+  // necessary since the user may have defined a custom stack formatter in
+  // V8 via Error.prepareStackTrace. See issue 7994.
+  var isAnonymousFrame = function(frame) {
+    return frame.toString() === '    at <anonymous>';
+  };
+  if (frames.length && goog.array.every(frames, isAnonymousFrame)) {
+    return error;
+  }
+
   // Older versions of IE simply return [object Error] for toString(), so
   // only use that as a last resort.
   var errorStr = '';

package/lib/webdriver/test/promise_flow_test.js

@@ -183,7 +183,7 @@ function testAddChild_withSubframes() {
   assertArrayEquals([task1, frame1], root.children_);
   assertArrayEquals([task2, task3], frame1.children_);
 
-  frame1.lockFrame();
+  frame1.isLocked_ = true;
   var task4 = createTask('task4'), task5 = createTask('task5');
   root.addChild(task4);
   root.addChild(task5);
@@ -199,9 +199,9 @@ function testAddChild_withSubframes() {
   root.addChild(frame2);
   root.addChild(frame3);
   root.addChild(task6);
-  frame3.lockFrame();
+  frame3.isLocked_ = true;
   root.addChild(task7);
-  frame2.lockFrame();
+  frame2.isLocked_ = true;
   root.addChild(task8);
 
   assertArrayEquals([task1, frame1, task4, task5, frame2, task8],
@@ -218,11 +218,11 @@ function testAddChild_insertingFramesIntoAnActiveFrame() {
       task1 = createTask('task1');
 
   root.addChild(task1);
-  root.isActive_ = true;
+  root.isLocked_ = true;
   root.addChild(frame2);
-  frame2.lockFrame();
+  frame2.isLocked_ = true;
   root.addChild(frame3);
-  frame3.lockFrame();
+  frame3.isLocked_ = true;
 
   assertArrayEquals([frame2, frame3, task1], root.children_);
 }
@@ -248,9 +248,9 @@ function testResolveFrame() {
   assertArrayEquals([frame3], frame2.children_);
   assertArrayEquals([frame2], frame1.children_);
 
-  frame1.fulfill = callbackHelper();
-  frame2.fulfill = callbackHelper();
-  frame3.fulfill = callbackHelper();
+  frame1.close = callbackHelper();
+  frame2.close = callbackHelper();
+  frame3.close = callbackHelper();
 
   var obj = {
     activeFrame_: frame2,
@@ -260,9 +260,9 @@ function testResolveFrame() {
   };
   webdriver.promise.ControlFlow.prototype.resolveFrame_.call(obj, frame3);
   assertEquals(1, obj.trimHistory_.getCallCount());
-  frame3.fulfill.assertCalled('frame 3 not resolved');
-  frame2.fulfill.assertNotCalled('frame 2 should not be resolved yet');
-  frame1.fulfill.assertNotCalled('frame 1 should not be resolved yet');
+  frame3.close.assertCalled('frame 3 not resolved');
+  frame2.close.assertNotCalled('frame 2 should not be resolved yet');
+  frame1.close.assertNotCalled('frame 1 should not be resolved yet');
   assertNull(frame3.getParent());
   assertArrayEquals([], frame2.children_);
   assertArrayEquals([frame2], frame1.children_);
@@ -270,8 +270,8 @@ function testResolveFrame() {
 
   webdriver.promise.ControlFlow.prototype.resolveFrame_.call(obj, frame2);
   assertEquals(2, obj.trimHistory_.getCallCount());
-  frame2.fulfill.assertCalled('frame 2 not resolved');
-  frame1.fulfill.assertNotCalled('frame 1 should not be resolved yet');
+  frame2.close.assertCalled('frame 2 not resolved');
+  frame1.close.assertNotCalled('frame 1 should not be resolved yet');
   assertNull(frame2.getParent());
   assertArrayEquals([], frame1.children_);
   assertEquals(frame1, obj.activeFrame_);
@@ -279,7 +279,7 @@ function testResolveFrame() {
   obj.commenceShutdown_.assertNotCalled();
   webdriver.promise.ControlFlow.prototype.resolveFrame_.call(obj, frame1);
   assertEquals(3, obj.trimHistory_.getCallCount());
-  frame1.fulfill.assertCalled('frame 1 not resolved');
+  frame1.close.assertCalled('frame 1 not resolved');
   obj.commenceShutdown_.assertCalled();
   assertNull(frame1.getParent());
   assertNull(obj.activeFrame_);
@@ -302,10 +302,10 @@ function testGetNextTask() {
       task8 = createTask('task8');
 
   flow.commenceShutdown_ = callbackHelper();
-  root.fulfill = callbackHelper();
-  frame1.fulfill = callbackHelper();
-  frame2.fulfill = callbackHelper();
-  frame3.fulfill = callbackHelper();
+  root.close = callbackHelper();
+  frame1.close = callbackHelper();
+  frame2.close = callbackHelper();
+  frame3.close = callbackHelper();
 
   root.addChild(task1);
   root.addChild(frame1);
@@ -314,7 +314,7 @@ function testGetNextTask() {
   assertArrayEquals([task1, frame1], root.children_);
   assertArrayEquals([task2, task3], frame1.children_);
 
-  frame1.lockFrame();
+  frame1.isLocked_ = true;
   root.addChild(task4);
   root.addChild(task5);
   assertArrayEquals([task1, frame1, task4, task5], root.children_);
@@ -324,9 +324,9 @@ function testGetNextTask() {
   root.addChild(frame2);
   root.addChild(frame3);
   root.addChild(task6);
-  frame3.lockFrame();
+  frame3.isLocked_ = true;
   root.addChild(task7);
-  frame2.lockFrame();
+  frame2.isLocked_ = true;
   root.addChild(task8);
 
   assertArrayEquals([task1, frame1, task4, task5, frame2, task8],
@@ -335,88 +335,79 @@ function testGetNextTask() {
   assertArrayEquals([frame3, task7], frame2.children_);
   assertArrayEquals([task6], frame3.children_);
 
-  assertEquals(root, task1.getParent());
   assertEquals(task1, flow.getNextTask_());
-  assertNull(task1.getParent());
   assertEquals(root, flow.activeFrame_);
-  root.fulfill.assertNotCalled();
-  frame1.fulfill.assertNotCalled();
-  frame2.fulfill.assertNotCalled();
-  frame3.fulfill.assertNotCalled();
+  root.close.assertNotCalled();
+  frame1.close.assertNotCalled();
+  frame2.close.assertNotCalled();
+  frame3.close.assertNotCalled();
 
   assertEquals(task2, flow.getNextTask_());
-  assertNull(task2.getParent());
   assertEquals(frame1, flow.activeFrame_);
-  root.fulfill.assertNotCalled();
-  frame1.fulfill.assertNotCalled();
-  frame2.fulfill.assertNotCalled();
-  frame3.fulfill.assertNotCalled();
+  root.close.assertNotCalled();
+  frame1.close.assertNotCalled();
+  frame2.close.assertNotCalled();
+  frame3.close.assertNotCalled();
 
   assertEquals(task3, flow.getNextTask_());
-  assertNull(task3.getParent());
   assertEquals(frame1, flow.activeFrame_);
-  root.fulfill.assertNotCalled();
-  frame1.fulfill.assertNotCalled();
-  frame2.fulfill.assertNotCalled();
-  frame3.fulfill.assertNotCalled();
+  root.close.assertNotCalled();
+  frame1.close.assertNotCalled();
+  frame2.close.assertNotCalled();
+  frame3.close.assertNotCalled();
 
   assertNull(flow.getNextTask_());
   assertNull(frame1.getParent());
   assertEquals(root, flow.activeFrame_);
-  root.fulfill.assertNotCalled();
-  frame1.fulfill.assertCalled();
-  frame2.fulfill.assertNotCalled();
-  frame3.fulfill.assertNotCalled();
+  root.close.assertNotCalled();
+  frame1.close.assertCalled();
+  frame2.close.assertNotCalled();
+  frame3.close.assertNotCalled();
 
   assertEquals(task4, flow.getNextTask_());
-  assertNull(task4.getParent());
   assertEquals(root, flow.activeFrame_);
-  root.fulfill.assertNotCalled();
-  frame2.fulfill.assertNotCalled();
-  frame3.fulfill.assertNotCalled();
+  root.close.assertNotCalled();
+  frame2.close.assertNotCalled();
+  frame3.close.assertNotCalled();
 
   assertEquals(task5, flow.getNextTask_());
-  assertNull(task5.getParent());
   assertEquals(root, flow.activeFrame_);
-  root.fulfill.assertNotCalled();
-  frame2.fulfill.assertNotCalled();
-  frame3.fulfill.assertNotCalled();
+  root.close.assertNotCalled();
+  frame2.close.assertNotCalled();
+  frame3.close.assertNotCalled();
 
   assertEquals(task6, flow.getNextTask_());
-  assertNull(task6.getParent());
   assertEquals(frame3, flow.activeFrame_);
-  root.fulfill.assertNotCalled();
-  frame2.fulfill.assertNotCalled();
-  frame3.fulfill.assertNotCalled();
+  root.close.assertNotCalled();
+  frame2.close.assertNotCalled();
+  frame3.close.assertNotCalled();
 
   assertNull(flow.getNextTask_());
   assertNull(frame3.getParent());
   assertEquals(frame2, flow.activeFrame_);
-  root.fulfill.assertNotCalled();
-  frame2.fulfill.assertNotCalled();
-  frame3.fulfill.assertCalled('frame3 should have been resolved');
+  root.close.assertNotCalled();
+  frame2.close.assertNotCalled();
+  frame3.close.assertCalled('frame3 should have been resolved');
 
   assertEquals(task7, flow.getNextTask_());
-  assertNull(task7.getParent());
   assertEquals(frame2, flow.activeFrame_);
-  root.fulfill.assertNotCalled();
-  frame2.fulfill.assertNotCalled();
+  root.close.assertNotCalled();
+  frame2.close.assertNotCalled();
 
   assertNull(flow.getNextTask_());
   assertNull(frame2.getParent());
   assertEquals(root, flow.activeFrame_);
-  root.fulfill.assertNotCalled();
-  frame2.fulfill.assertCalled('frame2 should have been resolved');
+  root.close.assertNotCalled();
+  frame2.close.assertCalled('frame2 should have been resolved');
 
   assertEquals(task8, flow.getNextTask_());
-  assertNull(task8.getParent());
   assertEquals(root, flow.activeFrame_);
-  root.fulfill.assertNotCalled();
+  root.close.assertNotCalled();
 
   flow.commenceShutdown_.assertNotCalled();
   assertNull(flow.getNextTask_());
   assertNull(flow.activeFrame_);
-  root.fulfill.assertCalled('Root should have been resolved');
+  root.close.assertCalled('Root should have been resolved');
   flow.commenceShutdown_.assertCalled();
 }
 
@@ -504,14 +495,15 @@ function testAbortFrame_unhandledAbortionsBubbleUp() {
   assertNull(flow.activeFrame_);
   flow.abortNow_.assertCalled();
 
-  function installResolveHelper(promise) {
-    var reject = promise.reject;
-    var pair = callbackPair(promise.fulfill, function(e) {
+  function installResolveHelper(frame) {
+    var abort = goog.bind(frame.abort, frame);
+    var close = goog.bind(frame.close, frame);
+    var pair = callbackPair(close, function(e) {
       assertIsStubError(e);
-      reject(e);
+      abort(e);
     });
-    promise.fulfill = pair.callback;
-    promise.reject = pair.errback;
+    frame.close = pair.callback;
+    frame.abort = pair.errback;
     return pair;
   }
 }
@@ -667,6 +659,7 @@ function testRunInNewFrame_doesNotReturnUntilScheduledFrameResolved() {
   pair.assertNeither('active frame still not resolved yet');
 
   assertNull(flow.getNextTask_());
+  clock.tick();
   pair.assertCallback();
   assertEquals(root, flow.activeFrame_);
   assertEquals(task2, flow.getNextTask_());
@@ -693,9 +686,11 @@ function testRunInNewFrame_doesNotReturnUntilScheduledFrameResolved_nested() {
   assertEquals('task3', flow.getNextTask_().getDescription());
   assertEquals('task4', flow.getNextTask_().getDescription());
   assertNull(flow.getNextTask_());
+  clock.tick();
   pair1.assertNeither();
   pair2.assertCallback();
   assertNull(flow.getNextTask_());
+  clock.tick();
   pair1.assertCallback();
 
   assertEquals(root, flow.activeFrame_);
@@ -1372,6 +1367,7 @@ function testWaiting_aConditionThatReturnsATaskResult() {
   clock.tick(100);  // Advance clock for next polling pass.
   assertEquals(1, count);
   turnEventLoop();
+  clock.tick();
   assertEquals(2, count);
   turnEventLoop();
   assertFlowHistory(
@@ -1381,6 +1377,7 @@ function testWaiting_aConditionThatReturnsATaskResult() {
   clock.tick(100);  // Advance clock for next polling pass.
   assertEquals(2, count);
   turnEventLoop();
+  clock.tick();
   assertEquals(3, count);
   turnEventLoop();
   assertFlowHistory(
@@ -1502,7 +1499,7 @@ function testWaiting_pollingLoopWaitsForAllScheduledTasksInCondition() {
   scheduleWait(function() {
     scheduleAction('increment count', function() { ++count; });
     return count >= 3;
-  }, 300, 'counting to 3');
+  }, 350, 'counting to 3');
   schedule('post wait');
 
   turnEventLoop();
@@ -1515,6 +1512,7 @@ function testWaiting_pollingLoopWaitsForAllScheduledTasksInCondition() {
   clock.tick(100);  // Advance clock for next polling pass.
   assertEquals(1, count);
   turnEventLoop();
+  clock.tick();
   assertEquals(2, count);
 
   clock.tick(100);  // Advance clock for next polling pass.
@@ -1799,8 +1797,12 @@ function testEventLoopWaitsOnPendingPromiseRejections_multipleRejections() {
 }
 
 function testCancelsPromiseReturnedByCallbackIfFrameFails_promiseCallback() {
-  var chainPair = callbackPair(null, assertIsStubError);
-  var deferredPair = callbackPair(null, assertIsStubError);
+  var isCancellationError = function(e) {
+    assertEquals('CancellationError: Error: ouch', e.toString());
+  };
+
+  var chainPair = callbackPair(null, isCancellationError);
+  var deferredPair = callbackPair(null, isCancellationError);
 
   var d = new webdriver.promise.Deferred();
   d.then(deferredPair.callback, deferredPair.errback);
@@ -1820,8 +1822,12 @@ function testCancelsPromiseReturnedByCallbackIfFrameFails_promiseCallback() {
 }
 
 function testCancelsPromiseReturnedByCallbackIfFrameFails_taskCallback() {
-  var chainPair = callbackPair(null, assertIsStubError);
-  var deferredPair = callbackPair(null, assertIsStubError);
+  var isCancellationError = function(e) {
+    assertEquals('CancellationError: Error: ouch', e.toString());
+  };
+
+  var chainPair = callbackPair(null, isCancellationError);
+  var deferredPair = callbackPair(null, isCancellationError);
 
   var d = new webdriver.promise.Deferred();
   d.then(deferredPair.callback, deferredPair.errback);

package/lib/webdriver/test/promise_test.js

@@ -341,7 +341,10 @@ function testWhen_WaitsForValueToBeResolvedBeforeInvokingCallback() {
 
 
 function testWhen_canCancelReturnedPromise() {
-  var callbacks = callbackPair(null, assertIsStubError);
+  var callbacks = callbackPair(null, function(e) {
+    assertTrue(e instanceof webdriver.promise.CancellationError);
+    assertEquals('just because', e.message);
+  });
 
   var promiseLike = {
     then: function(cb, eb) {
@@ -354,7 +357,7 @@ function testWhen_canCancelReturnedPromise() {
       callbacks.callback, callbacks.errback);
 
   assertTrue(promise.isPending());
-  promise.cancel(STUB_ERROR);
+  promise.cancel('just because');
   callbacks.assertErrback();
 
   // The following should have no effect.
@@ -1044,84 +1047,47 @@ function testCheckedNodeCall_functionThrowsAndReturns() {
 
 
 function testCancel_passesTheCancellationReasonToReject() {
-  var pair = callbackPair(null, assertIsStubError);
-  var d = new webdriver.promise.Deferred();
-  d.then(pair.callback, pair.errback);
-  d.cancel(STUB_ERROR);
-  pair.assertErrback();
-}
-
-
-function testCancel_invokesTheCancellerFunctionIfOneWasProvided() {
-  var pair = callbackPair(null, assertIsStubError);
-  var callback = callbackHelper();
-  var d = new webdriver.promise.Deferred(callback);
-  d.then(pair.callback, pair.errback);
-  d.cancel(STUB_ERROR);
-  pair.assertErrback();
-  callback.assertCalled();
-}
-
-
-function testCancel_canChangeRejectionReasonWithTruthyCancellerReturnValue() {
-  var pair = callbackPair(null, assertIsStubError);
-  var callback = callbackHelper(function() {
-    return STUB_ERROR;
+  var pair = callbackPair(null, function(e) {
+    assertTrue(e instanceof webdriver.promise.CancellationError);
+    assertEquals('because i said so', e.message);
   });
-  var d = new webdriver.promise.Deferred(callback);
+  var d = new webdriver.promise.Deferred();
   d.then(pair.callback, pair.errback);
-  d.cancel();
+  d.cancel('because i said so');
   pair.assertErrback();
-  callback.assertCalled();
 }
 
 
 function testCancel_canCancelADeferredFromAChainedPromise() {
-  var pair1 = callbackPair(null, assertIsStubError),
-      pair2 = callbackPair();
+  var pair1 = callbackPair(null, function(e) {
+    assertTrue(e instanceof webdriver.promise.CancellationError);
+    assertEquals('because i said so', e.message);
+  });
+  var pair2 = callbackPair();
 
   var d = new webdriver.promise.Deferred();
   var p = d.then(pair1.callback, pair1.errback);
   p.then(pair2.callback, pair2.errback);
 
-  p.cancel(STUB_ERROR);
+  p.cancel('because i said so');
   pair1.assertErrback('The first errback should have fired.');
   pair2.assertCallback();
 }
 
 
 function testCancel_canCancelATimeout() {
-  var pair = callbackPair(null, assertIsStubError);
+  var pair = callbackPair(null, function(e) {
+    assertTrue(e instanceof webdriver.promise.CancellationError);
+  });
   var p = webdriver.promise.delayed(250).
       then(pair.callback, pair.errback);
-  p.cancel(STUB_ERROR);
+  p.cancel();
   pair.assertErrback();
   clock.tick(250);  // Just to make sure nothing happens.
   pair.assertErrback();
 }
 
 
-function testCancel_cannotCancelACheckedNodeCall() {
-  var d = webdriver.promise.checkedNodeCall(goog.nullFunction);
-  assertThrows(d.cancel);
-}
-
-
-function testCancel_cancellerFunctionExplicityResolvesPromise() {
-  var pair = callbackPair(goog.partial(assertEquals, 123));
-  var canceller;
-  var d = new webdriver.promise.Deferred(
-      canceller = callbackHelper(function(e) {
-        assertIsStubError(e);
-        d.fulfill(123);
-      }));
-  d.then(pair.callback, pair.errback);
-  d.cancel(STUB_ERROR);
-  canceller.assertCalled();
-  pair.assertCallback();
-}
-
-
 function testCancel_cancelIsANoopOnceAPromiseHasBeenFulfilled() {
   var p = webdriver.promise.fulfilled(123);
   p.cancel();
@@ -1151,12 +1117,6 @@ function testCancel_noopCancelTriggeredOnCallbackOfResolvedPromise() {
 }
 
 
-function testCancel_cancellerCanForbidCancellation() {
-  var d = new webdriver.promise.Deferred(throwStubError);
-  assertThrows(d.cancel);
-}
-
-
 function testCallbackRegistersAnotherListener_callbacksConfiguredPreResolve() {
   var messages = [];
   var d = new webdriver.promise.Deferred();
@@ -1239,11 +1199,11 @@ function testResolvedReturnsInputValueIfItIsAPromise() {
 
 function testADeferredsParentControlFlowIsActiveForCallbacks() {
   var flow = new webdriver.promise.ControlFlow();
-  var d = new webdriver.promise.Deferred(null, flow);
+  var d = new webdriver.promise.Deferred(flow);
   d.fulfill();
 
   var flow2 = new webdriver.promise.ControlFlow();
-  var d2 = new webdriver.promise.Deferred(null, flow2);
+  var d2 = new webdriver.promise.Deferred(flow2);
   d2.fulfill();
 
   assertIsFlow(webdriver.promise.defaultFlow_)();

package/lib/webdriver/test/stacktrace_test.js

@@ -165,6 +165,11 @@ function testParseStackFrameInV8() {
       '    at Object.assert (http://bar:4000/bar.js?value=(a):150:3)',
       new webdriver.stacktrace.Frame('Object', 'assert', '',
           'http://bar:4000/bar.js?value=(a):150:3'));
+
+  assertStackFrame('Frame with non-standard leading whitespace (issue 7994)',
+      '  at module.exports.runCucumber (/local/dir/path)',
+      new webdriver.stacktrace.Frame('module.exports', 'runCucumber', '',
+          '/local/dir/path'));
 }
 
 function testParseStackFrameInOpera() {
@@ -468,6 +473,19 @@ function testFormatsUsingNameAndMessageIfAvailable() {
   assertEquals('TypeError: boom\n', ret.stack);
 }
 
+function testDoesNotFormatErrorIfOriginalStacktraceIsInAnUnexpectedFormat() {
+  var error = Error('testing');
+  var stack = error.stack = [
+    'Error: testing',
+    '..> at Color.red (http://x:1234)',
+    '..> at Foo.bar (http://y:5678)'
+  ].join('\n');
+
+  var ret = webdriver.stacktrace.format(error);
+  assertEquals(ret, error);
+  assertEquals(stack, error.stack);
+}
+
 function testParseStackFrameInIE10() {
   assertStackFrame('name and path',
       '   at foo (http://bar:4000/bar.js:150:3)',