openlayers/mapbox-gl/closure-library/closure/goog/testing/deferredtestcase_test.js

// Copyright 2010 The Closure Library Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS-IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

goog.provide('goog.testing.DeferredTestCaseTest');
goog.setTestOnly('goog.testing.DeferredTestCaseTest');

goog.require('goog.async.Deferred');
goog.require('goog.testing.DeferredTestCase');
goog.require('goog.testing.TestCase');
goog.require('goog.testing.TestRunner');
goog.require('goog.testing.jsunit');
goog.require('goog.testing.recordFunction');

var deferredTestCase =
    goog.testing.DeferredTestCase.createAndInstall(document.title);
var testTestCase;
var runner;

// Optionally, set a longer-than-usual step timeout.
deferredTestCase.stepTimeout = 15 * 1000; // 15 seconds

// This is the sample code in deferredtestcase.js
function testDeferredCallbacks() {
  var callbackTime = goog.now();
  var callbacks = new goog.async.Deferred();
  deferredTestCase.addWaitForAsync('Waiting for 1st callback', callbacks);
  callbacks.addCallback(
      function() {
        assertTrue(
            'We\'re going back in time!', goog.now() >= callbackTime);
        callbackTime = goog.now();
      });
  deferredTestCase.addWaitForAsync('Waiting for 2nd callback', callbacks);
  callbacks.addCallback(
      function() {
        assertTrue(
            'We\'re going back in time!', goog.now() >= callbackTime);
        callbackTime = goog.now();
      });
  deferredTestCase.addWaitForAsync('Waiting for last callback', callbacks);
  callbacks.addCallback(
      function() {
        assertTrue(
            'We\'re going back in time!', goog.now() >= callbackTime);
        callbackTime = goog.now();
      });

  deferredTestCase.waitForDeferred(callbacks);
}

function createDeferredTestCase(d) {
  testTestCase = new goog.testing.DeferredTestCase('Foobar TestCase');
  testTestCase.add(new goog.testing.TestCase.Test(
      'Foobar Test',
      function() {
        this.waitForDeferred(d);
      },
      testTestCase));

  var testCompleteCallback = new goog.async.Deferred();
  testTestCase.setCompletedCallback(
      function() {
        testCompleteCallback.callback(true);
      });

  // We're not going to use the runner to run the test, but we attach one
  // here anyway because without a runner TestCase throws an exception in
  // finalize().
  var runner = new goog.testing.TestRunner();
  runner.initialize(testTestCase);

  return testCompleteCallback;
}

function testDeferredWait() {
  var d = new goog.async.Deferred();
  deferredTestCase.addWaitForAsync('Foobar', d);
  d.addCallback(function() {
    return goog.async.Deferred.succeed(true);
  });
  deferredTestCase.waitForDeferred(d);
}

function testNonAsync() {
  assertTrue(true);
}

function testPassWithTestRunner() {
  var d = new goog.async.Deferred();
  d.addCallback(function() {
    return goog.async.Deferred.succeed(true);
  });

  var testCompleteDeferred = createDeferredTestCase(d);
  testTestCase.execute();

  var deferredCallbackOnPass = new goog.async.Deferred();
  deferredCallbackOnPass.addCallback(function() {
    return testCompleteDeferred;
  });
  deferredCallbackOnPass.addCallback(function() {
    assertTrue('Test case should have succeded.', testTestCase.isSuccess());
  });

  deferredTestCase.waitForDeferred(deferredCallbackOnPass);
}

function testFailWithTestRunner() {
  var d = new goog.async.Deferred();
  d.addCallback(function() {
    return goog.async.Deferred.fail(true);
  });

  var testCompleteDeferred = createDeferredTestCase(d);

  // Mock doAsyncError to instead let the test completes successfully,
  // but record the failure. The test works as is because the failing
  // deferred is not actually asynchronous.
  var mockDoAsyncError = goog.testing.recordFunction(function() {
    testTestCase.continueTesting();
  });
  testTestCase.doAsyncError = mockDoAsyncError;

  testTestCase.execute();
  assertEquals(1, mockDoAsyncError.getCallCount());
}