<!DOCTYPE html>
<!--
Copyright 2010 WebDriver committers
Copyright 2010 Google Inc.

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.
-->
<html>
<head>
  <meta charset="utf-8">
  <title>Unit Tests for bot.inject</title>
  <link rel="stylesheet" href="/filez/_main/third_party/js/qunit/qunit.css">
  <script src="/filez/_main/third_party/js/qunit/qunit.js"></script>
  <script src="/filez/_main/third_party/js/qunit/qunit_test_runner.js"></script>
  <script src="test_bootstrap.js"></script>
  <script type="text/javascript">
    goog.require('bot.Error');
    goog.require('bot.ErrorCode');
    goog.require('bot.inject');
    goog.require('bot.inject.cache');
    goog.require('bot.json');
    goog.require('bot.userAgent');
    goog.require('goog.Promise');
    goog.require('goog.dom');
    goog.require('goog.events');
    goog.require('goog.userAgent');
    goog.require('goog.userAgent.product');
  </script>
</head>
<body>
  <div id="qunit"></div>
  <div id="qunit-fixture"></div>
  <div style="display:none">
    <iframe id="test-frame" src="testdata/blank_page.html"></iframe>
  </div>
  <script type="text/javascript">
    goog.global.MY_GLOBAL_CONSTANT = 123;

    var frame, frameWin, frameDoc;

    QUnit.testStart(function() {
      frame = goog.dom.$('test-frame');
      frameWin = goog.dom.getFrameContentWindow(frame);
      frameDoc = goog.dom.getFrameContentDocument(frame);

      document[bot.inject.cache.CACHE_KEY_] = null;
      frameDoc[bot.inject.cache.CACHE_KEY_] = null;
    });

    QUnit.test('AddWindowToCache', function(assert) {
      var id = bot.inject.cache.addElement(frameWin);
      assert.strictEqual(bot.inject.cache.getElement(id), frameWin);
    });


    QUnit.test('AddWindowToCacheMultipleTimesReusesIds', function(assert) {
      var id1 = bot.inject.cache.addElement(frameWin);
      var id2 = bot.inject.cache.addElement(frameWin);
      assert.strictEqual(id2, id1);
    });


    QUnit.test('GetElementThrowsIfWindowIsClosed', function(assert) {
      var win = {document: 1, closed: 1};
      var id = bot.inject.cache.addElement(win);
      assert.throws(function() { bot.inject.cache.getElement(id); });
    });


    QUnit.test('ShouldWrapAndUnwrapWindow', function(assert) {
      var wrapped = bot.inject.wrapValue(frameWin);
      assert.ok(wrapped !== null);
      assert.ok(wrapped !== undefined);
      assert.ok(goog.isObject(wrapped));
      assert.ok(goog.object.containsKey(wrapped, bot.inject.WINDOW_KEY));

      var id = wrapped[bot.inject.WINDOW_KEY];
      var res = bot.inject.cache.getElement(id);
      assert.strictEqual(res, frameWin);
      assert.strictEqual(bot.inject.unwrapValue(wrapped), frameWin);
    });


    QUnit.test('ShouldBeAbleToCacheElements', function(assert) {
      var id = bot.inject.cache.addElement(document.body);
      var el = bot.inject.cache.getElement(id);
      assert.strictEqual(el, document.body);
    });


    QUnit.test('ShouldReuseExistingIdIfElementAlreadyExistsInTheCache', function(assert) {
      var id1 = bot.inject.cache.addElement(document.body);
      var id2 = bot.inject.cache.addElement(document.body);
      assert.strictEqual(id2, id1);
    });


    QUnit.test('ShouldThrowIfElementDoesNotExistInTheCache', function(assert) {
      assert.throws(function() { bot.inject.cache.getElement('not-there'); });
    });


    QUnit.test('ShouldDecodeIdsWhenRetrievingFromTheCache', function(assert) {
      var id = bot.inject.cache.addElement(document.body);
      id = encodeURIComponent(id);
      var el = bot.inject.cache.getElement(id);
      assert.strictEqual(el, document.body);
    });


    QUnit.test('ShouldThrowIfCachedElementIsNoLongerAttachedToTheDom', function(assert) {
      if (goog.userAgent.IE) {
        assert.ok(true, 'Skipping: TODO fix for IE');
        return;
      }
      var div = document.createElement('DIV');
      document.body.appendChild(div);

      var id = bot.inject.cache.addElement(div);
      assert.strictEqual(bot.inject.cache.getElement(id), div);

      document.body.removeChild(div);
      assert.throws(function() { bot.inject.cache.getElement(id); });
    });


    QUnit.test('DoesNotWrapStringBooleansNumbersOrNull', function(assert) {
      assert.strictEqual(bot.inject.wrapValue('foo'), 'foo');
      assert.strictEqual(bot.inject.wrapValue(123), 123);
      assert.ok(bot.inject.wrapValue(true));
      assert.strictEqual(bot.inject.wrapValue(null), null);
    });


    QUnit.test('ConvertsUndefinedValueToNullForWrapping', function(assert) {
      assert.strictEqual(bot.inject.wrapValue(undefined), null);
    });


    QUnit.test('ShouldAddElementsToCacheWhenWrapping', function(assert) {
      var wrapped = bot.inject.wrapValue(document.body);
      assert.ok(wrapped !== null);
      assert.ok(wrapped !== undefined);
      assert.ok(goog.isObject(wrapped));
      assert.ok(goog.object.containsKey(wrapped, bot.inject.ELEMENT_KEY));

      var id = wrapped[bot.inject.ELEMENT_KEY];
      var el = bot.inject.cache.getElement(id);
      assert.strictEqual(el, document.body);
    });


    QUnit.test('ShouldRecursivelyWrapArrays', function(assert) {
      var unwrapped = [123, 'abc', null, document.body];
      var wrapped = bot.inject.wrapValue(unwrapped);

      assert.strictEqual(wrapped.length, unwrapped.length);
      assert.strictEqual(wrapped[0], unwrapped[0]);
      assert.strictEqual(wrapped[1], unwrapped[1]);
      assert.strictEqual(wrapped[2], unwrapped[2]);

      assert.ok(goog.object.containsKey(wrapped[3], bot.inject.ELEMENT_KEY));
      assert.strictEqual(bot.inject.cache.getElement(
          wrapped[3][bot.inject.ELEMENT_KEY]), unwrapped[3]);
    });


    QUnit.test('ShouldBeAbleToWrapNodeListsAsArrays', function(assert) {
      var unwrapped = document.getElementsByTagName('body');
      var wrapped = bot.inject.wrapValue(unwrapped);

      assert.ok(Array.isArray(wrapped), 'should return an array, but was ' + goog.typeOf(wrapped));
      assert.strictEqual(wrapped.length, unwrapped.length);
      assert.ok(goog.object.containsKey(wrapped[0], bot.inject.ELEMENT_KEY));
      assert.strictEqual(bot.inject.cache.getElement(
          wrapped[0][bot.inject.ELEMENT_KEY]), document.body);
    });


    QUnit.test('ShouldThrowWhenWrappingRecursiveStructure', function(assert) {
      var obj1 = {};
      var obj2 = {};
      obj1['obj2'] = obj2;
      obj2['obj1'] = obj1;
      assert.throws(function() { bot.inject.wrapValue(obj1); });
    });


    QUnit.test('ShouldBeAbleToUnWrapWrappedValues', function(assert) {
      var unwrapped = [123, 'abc', null, document.body];
      var wrapped = bot.inject.wrapValue(unwrapped);
      var roundTripped = bot.inject.unwrapValue(wrapped);
      assert.deepEqual(roundTripped, unwrapped);
    });


    QUnit.test('ShouldBeAbleToUnWrapNestedArrays', function(assert) {
      var unwrapped = [123, 'abc', null, [document.body, null,
          [document.body]]];
      var wrapped = bot.inject.wrapValue(unwrapped);
      var roundTripped = bot.inject.unwrapValue(wrapped);
      assert.deepEqual(roundTripped, unwrapped);
    });


    QUnit.test('ShouldBeAbleToUnWrapNestedObjects', function(assert) {
      var unwrapped = {'foo': {'bar': document.body}};
      var wrapped = bot.inject.wrapValue(unwrapped);
      var roundTripped = bot.inject.unwrapValue(wrapped);

      assert.ok(goog.object.containsKey(roundTripped, 'foo'));
      var foo = roundTripped['foo'];

      assert.ok(goog.object.containsKey(foo, 'bar'));
      assert.strictEqual(foo['bar'], document.body);
    });


    QUnit.test('ShouldUnWrapElementsUsingTheGivenDocumentsCache', function(assert) {
      var wrapped = bot.inject.wrapValue(frameDoc.body);
      assert.ok(wrapped !== null);
      assert.ok(wrapped !== undefined);
      assert.ok(goog.isObject(wrapped));
      assert.ok(goog.object.containsKey(wrapped, bot.inject.ELEMENT_KEY));

      assert.throws(function() { bot.inject.unwrapValue(wrapped); });

      var unwrapped = bot.inject.unwrapValue(wrapped, frameDoc);
      assert.strictEqual(unwrapped, frameDoc.body);
    });


    QUnit.test('ShouldBeAbleToUnwrapArgumentsExecuteScriptAndWrapResult', function(assert) {
      var id = bot.inject.cache.addElement(document.body);
      var args = [{}];
      args[0][bot.inject.ELEMENT_KEY] = id;
      var result = bot.inject.executeScript(
          function() { return arguments[0]; }, args);

      assert.ok(goog.object.containsKey(result, 'status'));
      assert.strictEqual(result['status'], bot.ErrorCode.SUCCESS);

      assert.ok(goog.object.containsKey(result, 'value'));
      assert.ok(goog.object.containsKey(result['value'],
          bot.inject.ELEMENT_KEY));
      assert.strictEqual(bot.inject.cache.getElement(
          result['value'][bot.inject.ELEMENT_KEY]), document.body);
    });


    QUnit.test('ShouldTrapAndReturnWrappedErrorsFromInjectedScripts', function(assert) {
      var result = bot.inject.executeScript(
          function() { throw Error('ouch'); }, []);
      assert.ok(goog.object.containsKey(result, 'status'));
      assert.ok(goog.object.containsKey(result, 'value'));

      assert.strictEqual(result['status'], bot.ErrorCode.UNKNOWN_ERROR);
      result = result['value'];
      assert.ok(goog.object.containsKey(result, 'message'));
      assert.strictEqual(result['message'], 'ouch');
    });


    QUnit.test('ShouldResetCacheWhenPageIsRefreshed', function(assert) {
      var done = assert.async();
      var id = bot.inject.cache.addElement(frameDoc.body);
      assert.strictEqual(bot.inject.cache.getElement(id, frameDoc), frameDoc.body);

      goog.events.listenOnce(frame, 'load', function() {
        frameDoc = goog.dom.getFrameContentDocument(frame);
        assert.throws(function() { bot.inject.cache.getElement(id, frameDoc); });
        done();
      });
      frameWin.location.reload();
    });


    QUnit.test('ShouldStringifyResultsWhenAskedToDoSo', function(assert) {
      var result = bot.inject.executeScript(function() {
        return arguments[0] + arguments[1];
      }, ['abc', 123], true);

      assert.strictEqual(goog.typeOf(result), 'string');
      var json = bot.json.parse(result);
      assert.ok('status' in json, 'No status: ' + result);
      assert.ok('value' in json, 'No value: ' + result);
      assert.strictEqual(json['status'], 0);
      assert.strictEqual(json['value'], 'abc123');
    });


    QUnit.test('ShouldStringifyErrorsWhenAskedForStringResults', function(assert) {
      var result = bot.inject.executeScript(function() {
        throw new bot.Error(bot.ErrorCode.NO_SUCH_ELEMENT, 'ouch');
      }, [], true);

      assert.strictEqual(goog.typeOf(result), 'string');
      var json = bot.json.parse(result);
      assert.ok('status' in json, 'No status: ' + result);
      assert.ok('value' in json, 'No value: ' + result);
      assert.strictEqual(json['status'], bot.ErrorCode.NO_SUCH_ELEMENT);
      assert.ok('message' in json['value'], 'No message: ' + result);
      assert.strictEqual(json['value']['message'], 'ouch');
    });


    QUnit.test('ShouldBeAbleToExecuteAsyncScript', function(assert) {
      var done = assert.async();
      bot.inject.executeAsyncScript(
          'window.setTimeout(goog.partial(arguments[0], 1), 10)',
          [], 250, function(result) {
        assert.ok(goog.object.containsKey(result, 'status'));
        assert.strictEqual(result['status'], bot.ErrorCode.SUCCESS);
        assert.ok(goog.object.containsKey(result, 'value'));
        assert.strictEqual(result['value'], 1);
        done();
      });
    });


    QUnit.test('ShouldBeAbleToExecuteAsyncScriptThatCallsbackSynchronously', function(assert) {
      var done = assert.async();
      bot.inject.executeAsyncScript('arguments[0](1)', [], 0, function(result) {
        assert.ok(goog.object.containsKey(result, 'status'));
        assert.strictEqual(result['status'], bot.ErrorCode.SUCCESS);
        assert.ok(goog.object.containsKey(result, 'value'));
        assert.strictEqual(result['value'], 1);
        done();
      });
    });


    QUnit.test('ShouldBeAbleToExecuteAsyncFunc', function(assert) {
      var done = assert.async();
      bot.inject.executeAsyncScript(
          function(callback) { callback(1) }, [], 0, function(result) {
        assert.ok(goog.object.containsKey(result, 'status'));
        assert.strictEqual(result['status'], bot.ErrorCode.SUCCESS);
        assert.ok(goog.object.containsKey(result, 'value'));
        assert.strictEqual(result['value'], 1);
        done();
      });
    });


    QUnit.test('ShouldThrowOnExecuteAsyncException', function(assert) {
      var done = assert.async();
      bot.inject.executeAsyncScript('nosuchfunc()', [], 0, function(result) {
        assert.ok(goog.object.containsKey(result, 'status'));
        assert.strictEqual(result['status'], bot.ErrorCode.UNKNOWN_ERROR);
        done();
      });
    });


    QUnit.test('ShouldTimeoutInExecuteAsync', function(assert) {
      var done = assert.async();
      bot.inject.executeAsyncScript('', [], 0, function(result) {
        assert.ok(goog.object.containsKey(result, 'status'));
        assert.strictEqual(result['status'], bot.ErrorCode.SCRIPT_TIMEOUT);
        done();
      });
    });


    QUnit.test('ShouldBeAbleToStringifyResult', function(assert) {
      var done = assert.async();
      bot.inject.executeAsyncScript('', [], 0, function(jsonResult) {
        var result = bot.json.parse(jsonResult);
        assert.ok(goog.object.containsKey(result, 'status'));
        assert.strictEqual(result['status'], bot.ErrorCode.SCRIPT_TIMEOUT);
        done();
      }, true);
    });


    QUnit.test('ShouldBeAbleToWrapAndUnwrapInExecuteAsyncScript', function(assert) {
      var done = assert.async();
      var id = bot.inject.cache.addElement(document.body);
      var args = [{}];
      args[0][bot.inject.ELEMENT_KEY] = id;
      bot.inject.executeAsyncScript(
          'arguments[1](arguments[0])', args, 0, function(result) {
        assert.ok(goog.object.containsKey(result, 'status'));
        assert.strictEqual(result['status'], bot.ErrorCode.SUCCESS);

        assert.ok(goog.object.containsKey(result, 'value'));
        assert.ok(goog.object.containsKey(result['value'],
            bot.inject.ELEMENT_KEY));
        assert.strictEqual(bot.inject.cache.getElement(
            result['value'][bot.inject.ELEMENT_KEY]), document.body);
        done();
      });
    });

    QUnit.test('ShouldExecuteAsyncScriptsInTheContextOfTheSpecifiedWindow', function(assert) {
      if (goog.userAgent.IE || goog.userAgent.product.SAFARI ||
          (goog.userAgent.product.ANDROID &&
           !bot.userAgent.isProductVersion(4))) {
        assert.ok(true, 'Skipping: known issue on this browser');
        return;
      }

      var done = assert.async();
      bot.inject.executeAsyncScript(function(callback) {
        callback({
          'this == window': (this == window),
          'this == top': (this == window.top),
          'typeof window.MY_GLOBAL_CONSTANT': (typeof MY_GLOBAL_CONSTANT),
          'typeof window.top.MY_GLOBAL_CONSTANT':
              (typeof window.top.MY_GLOBAL_CONSTANT)
        });
      }, [], 0, function(result) {
        var jsonResult = bot.json.stringify(result);

        assert.ok(goog.object.containsKey(result, 'status'), jsonResult);
        assert.strictEqual(result['status'], bot.ErrorCode.SUCCESS, jsonResult);

        assert.ok(goog.object.containsKey(result, 'value'), jsonResult);
        var value = result['value'];

        assert.strictEqual(value['this == window'], true, jsonResult);
        assert.strictEqual(value['this == top'], false, jsonResult);
        assert.strictEqual(value['typeof window.MY_GLOBAL_CONSTANT'], 'undefined', jsonResult);
        assert.strictEqual(value['typeof window.top.MY_GLOBAL_CONSTANT'], 'number', jsonResult);
        done();
      }, false, frameWin);
    });

    QUnit.test('ShouldExecuteScriptsInTheContextOfTheSpecifiedWindow', function(assert) {
      if (goog.userAgent.IE || goog.userAgent.product.SAFARI ||
          (goog.userAgent.product.ANDROID &&
           !bot.userAgent.isProductVersion(4))) {
        assert.ok(true, 'Skipping: known issue on this browser');
        return;
      }

      var result = bot.inject.executeScript(function() {
        return {
          'this == window': (this == window),
          'this == top': (this == window.top),
          'typeof window.MY_GLOBAL_CONSTANT': (typeof MY_GLOBAL_CONSTANT),
          'typeof window.top.MY_GLOBAL_CONSTANT':
              (typeof window.top.MY_GLOBAL_CONSTANT)
        };
      }, [], false, frameWin);

      var jsonResult = bot.json.stringify(result);

      assert.ok(goog.object.containsKey(result, 'status'), jsonResult);
      assert.strictEqual(result['status'], bot.ErrorCode.SUCCESS, jsonResult);

      assert.ok(goog.object.containsKey(result, 'value'), jsonResult);
      var value = result['value'];

      assert.strictEqual(value['this == window'], true, jsonResult);
      assert.strictEqual(value['this == top'], false, jsonResult);
      assert.strictEqual(value['typeof window.MY_GLOBAL_CONSTANT'], 'undefined', jsonResult);
      assert.strictEqual(value['typeof window.top.MY_GLOBAL_CONSTANT'], 'number', jsonResult);
    });

    QUnit.test('CorrectlyUnwrapsFunctionArgsForInjectedScripts', function(assert) {
      var result = bot.inject.executeScript(function() {
        return arguments[0]();
      }, [function() {return 1;}]);
      assert.strictEqual(result['status'], bot.ErrorCode.SUCCESS);
      assert.strictEqual(result['value'], 1);
    });

    QUnit.test('CorrectlyUnwrapsFunctionArgsForInjectedAsyncScripts', function(assert) {
      var done = assert.async();
      bot.inject.executeAsyncScript(function() {
        var callback = arguments[arguments.length - 1];
        callback(arguments[0]());
      }, [function() {return 1;}], 0, function(result) {
        assert.strictEqual(result['status'], bot.ErrorCode.SUCCESS);
        assert.strictEqual(result['value'], 1);
        done();
      }, false);
    });

    QUnit.test('CorrectlyUnwrapsArgsForInjectedScripts', function(assert) {
      if (goog.userAgent.IE) {
        assert.ok(true, 'Skipping: TODO fix for IE');
        return;
      }
      var wrapped = bot.inject.wrapValue(frameDoc.body);

      var result = bot.inject.executeScript(function() {
        return [arguments[0], arguments[0].tagName.toUpperCase()];
      }, [wrapped], false, frameWin);

      assert.strictEqual(result['status'], bot.ErrorCode.SUCCESS);

      var value = result['value'];
      assert.ok(Array.isArray(value));
      assert.strictEqual(value.length, 2);

      assert.ok(goog.isObject(value[0]));
      assert.ok(goog.object.containsKey(value[0], bot.inject.ELEMENT_KEY));
      assert.strictEqual(value[0][bot.inject.ELEMENT_KEY],
                   wrapped[bot.inject.ELEMENT_KEY]);

      assert.strictEqual(value[1], 'BODY');
    });

    QUnit.test('CorrectlyUnwrapsArgsForInjectedAsyncScripts', function(assert) {
      if (goog.userAgent.IE) {
        assert.ok(true, 'Skipping: TODO fix for IE');
        return;
      }
      var wrapped = bot.inject.wrapValue(frameDoc.body);

      var done = assert.async();
      bot.inject.executeAsyncScript(function(element, callback) {
        callback([element, element.tagName.toUpperCase()]);
      }, [wrapped], 0, function(result) {
        assert.strictEqual(result['status'], bot.ErrorCode.SUCCESS);

        var value = result['value'];
        assert.ok(Array.isArray(value));
        assert.strictEqual(value.length, 2);

        assert.ok(goog.isObject(value[0]));
        assert.ok(goog.object.containsKey(value[0], bot.inject.ELEMENT_KEY));
        assert.strictEqual(value[0][bot.inject.ELEMENT_KEY],
                     wrapped[bot.inject.ELEMENT_KEY]);

        assert.strictEqual(value[1], 'BODY');
        done();
      }, false, frameWin);
    });

    QUnit.test('ExecuteScriptShouldBeAbleToRecurseOnItself', function(assert) {
      if (goog.userAgent.IE) {
        assert.ok(true, 'Skipping: TODO fix for IE');
        return;
      }
      var json = bot.inject.executeScript(bot.inject.executeScript,
          ['return 1 +2;'], true);
      var result = bot.json.parse(json);

      assert.ok(goog.object.containsKey(result, 'status'), json);
      assert.strictEqual(result['status'], bot.ErrorCode.SUCCESS, json);
      assert.ok(goog.object.containsKey(result, 'value'), json);

      var innerResult = result['value'];
      assert.ok(goog.isObject(innerResult), json);
      assert.ok(goog.object.containsKey(innerResult, 'status'), json);
      assert.strictEqual(innerResult['status'], bot.ErrorCode.SUCCESS, json);
      assert.ok(goog.object.containsKey(innerResult, 'value'), json);
      assert.strictEqual(innerResult['value'], 3, json);
    });

  </script>
</body>
</html>