// Copyright 2013 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.

/**
 * @fileoverview Tests the direct transport.
 */

goog.provide('goog.net.xpc.DirectTransportTest');

goog.require('goog.dom');
goog.require('goog.dom.TagName');
goog.require('goog.labs.userAgent.browser');
goog.require('goog.log');
goog.require('goog.log.Level');
goog.require('goog.net.xpc');
goog.require('goog.net.xpc.CfgFields');
goog.require('goog.net.xpc.CrossPageChannel');
goog.require('goog.net.xpc.CrossPageChannelRole');
goog.require('goog.net.xpc.TransportTypes');
goog.require('goog.testing.AsyncTestCase');
goog.require('goog.testing.jsunit');
goog.setTestOnly('goog.net.xpc.DirectTransportTest');

var asyncTestCase = goog.testing.AsyncTestCase.createAndInstall(
    'Direct transport tests.');


/**
 * Echo service name.
 * @type {string}
 * @const
 */
var ECHO_SERVICE_NAME = 'echo';


/**
 * Response service name.
 * @type {string}
 * @const
 */
var RESPONSE_SERVICE_NAME = 'response';


/**
 * Test Payload.
 * @type {string}
 * @const
 */
var MESSAGE_PAYLOAD_1 = 'This is message payload 1.';


/**
 * The name id of the peer iframe.
 * @type {string}
 * @const
 */
var PEER_IFRAME_ID = 'peer-iframe';


// Class aliases.
var CfgFields;
var CrossPageChannel;
var CrossPageChannelRole;
var TransportTypes;

var outerXpc;
var innerXpc;
var peerIframe;
var channelName;
var messageIsSync = false;

function setUpPage() {
  CfgFields = goog.net.xpc.CfgFields;
  CrossPageChannel = goog.net.xpc.CrossPageChannel;
  CrossPageChannelRole = goog.net.xpc.CrossPageChannelRole;
  TransportTypes = goog.net.xpc.TransportTypes;

  // Show debug log
  var debugDiv = document.createElement(goog.dom.TagName.DEBUGDIV);
  document.body.appendChild(debugDiv);
  var logger = goog.log.getLogger('goog.net.xpc');
  logger.setLevel(goog.log.Level.ALL);
  goog.log.addHandler(logger, function(logRecord) {
    var msgElm = goog.dom.createDom(goog.dom.TagName.DIV);
    msgElm.innerHTML = logRecord.getMessage();
    goog.dom.appendChild(debugDiv, msgElm);
  });
}


function tearDown() {
  if (peerIframe) {
    document.body.removeChild(peerIframe);
    peerIframe = null;
  }
  if (outerXpc) {
    outerXpc.dispose();
    outerXpc = null;
  }
  if (innerXpc) {
    innerXpc.dispose();
    innerXpc = null;
  }
  window.iframeLoadHandler = null;
  channelName = null;
  messageIsSync = false;
}


function createIframe() {
  peerIframe = document.createElement(goog.dom.TagName.IFRAME);
  peerIframe.id = PEER_IFRAME_ID;
  document.body.insertBefore(peerIframe, document.body.firstChild);
}


/**
 * Tests 2 same domain frames using direct transport.
 */
function testDirectTransport() {
  // This test has been flaky on IE 8-11 on Win7.
  // For now, disable.
  // Flakiness is tracked in http://b/18595666
  if (goog.labs.userAgent.browser.isIE()) {
    return;
  }

  createIframe();
  channelName = goog.net.xpc.getRandomString(10);
  outerXpc = new CrossPageChannel(
      getConfiguration(CrossPageChannelRole.OUTER, PEER_IFRAME_ID));
  // Outgoing service.
  outerXpc.registerService(ECHO_SERVICE_NAME, goog.nullFunction);
  // Incoming service.
  outerXpc.registerService(
      RESPONSE_SERVICE_NAME,
      responseMessageHandler_testDirectTransport);
  asyncTestCase.waitForAsync('Waiting for xpc connect.');
  outerXpc.connect(onConnect_testDirectTransport);
  // inner_peer.html calls this method at end of html.
  window.iframeLoadHandler = onIframeLoaded_testDirectTransport;
  peerIframe.src = 'testdata/inner_peer.html';
}


function onIframeLoaded_testDirectTransport() {
  peerIframe.contentWindow.instantiateChannel(
      getConfiguration(CrossPageChannelRole.INNER));
}


function onConnect_testDirectTransport() {
  assertTrue('XPC over direct channel is connected', outerXpc.isConnected());
  outerXpc.send(ECHO_SERVICE_NAME, MESSAGE_PAYLOAD_1);
}


function responseMessageHandler_testDirectTransport(message) {
  assertEquals(
      'Received payload is equal to sent payload.',
      message,
      MESSAGE_PAYLOAD_1);
  asyncTestCase.continueTesting();
}


/**
 * Tests 2 xpc's communicating with each other in the same window.
 */
function testSameWindowDirectTransport() {
  channelName = goog.net.xpc.getRandomString(10);

  outerXpc = new CrossPageChannel(getConfiguration(CrossPageChannelRole.OUTER));
  outerXpc.setPeerWindowObject(self);

  // Outgoing service.
  outerXpc.registerService(ECHO_SERVICE_NAME, goog.nullFunction);
  // Incoming service.
  outerXpc.registerService(
      RESPONSE_SERVICE_NAME,
      outerResponseMessageHandler_testSameWindowDirectTransport);
  asyncTestCase.waitForAsync('Waiting for outer xpc connect.');
  outerXpc.connect(onOuterConnect_testSameWindowDirectTransport);

  innerXpc = new CrossPageChannel(getConfiguration(CrossPageChannelRole.INNER));
  innerXpc.setPeerWindowObject(self);
  // Incoming service.
  innerXpc.registerService(
      ECHO_SERVICE_NAME,
      innerEchoMessageHandler_testSameWindowDirectTransport);
  // Outgoing service.
  innerXpc.registerService(
      RESPONSE_SERVICE_NAME,
      goog.nullFunction);
  innerXpc.connect();
}


function onOuterConnect_testSameWindowDirectTransport() {
  assertTrue(
      'XPC over direct channel, same window, is connected',
      outerXpc.isConnected());
  outerXpc.send(ECHO_SERVICE_NAME, MESSAGE_PAYLOAD_1);
}


function outerResponseMessageHandler_testSameWindowDirectTransport(message) {
  assertEquals(
      'Received payload is equal to sent payload.',
      message,
      MESSAGE_PAYLOAD_1);
  asyncTestCase.continueTesting();
}


function innerEchoMessageHandler_testSameWindowDirectTransport(message) {
  innerXpc.send(RESPONSE_SERVICE_NAME, message);
}


function getConfiguration(role, opt_peerFrameId) {
  var cfg = {};
  cfg[CfgFields.TRANSPORT] = TransportTypes.DIRECT;
  if (goog.isDefAndNotNull(opt_peerFrameId)) {
    cfg[CfgFields.IFRAME_ID] = opt_peerFrameId;
  }
  cfg[CfgFields.CHANNEL_NAME] = channelName;
  cfg[CfgFields.ROLE] = role;
  return cfg;
}


/**
 * Tests 2 same domain frames using direct transport using sync mode.
 */
function testSyncMode() {
  createIframe();
  channelName = goog.net.xpc.getRandomString(10);

  var cfg = getConfiguration(CrossPageChannelRole.OUTER, PEER_IFRAME_ID);
  cfg[CfgFields.DIRECT_TRANSPORT_SYNC_MODE] = true;

  outerXpc = new CrossPageChannel(cfg);
  // Outgoing service.
  outerXpc.registerService(ECHO_SERVICE_NAME, goog.nullFunction);
  // Incoming service.
  outerXpc.registerService(
      RESPONSE_SERVICE_NAME,
      responseMessageHandler_testSyncMode);
  asyncTestCase.waitForAsync('Waiting for xpc connect.');
  outerXpc.connect(onConnect_testSyncMode);
  // inner_peer.html calls this method at end of html.
  window.iframeLoadHandler = onIframeLoaded_testSyncMode;
  peerIframe.src = 'testdata/inner_peer.html';
}


function onIframeLoaded_testSyncMode() {
  var cfg = getConfiguration(CrossPageChannelRole.INNER);
  cfg[CfgFields.DIRECT_TRANSPORT_SYNC_MODE] = true;
  peerIframe.contentWindow.instantiateChannel(cfg);
}


function onConnect_testSyncMode() {
  assertTrue('XPC over direct channel is connected', outerXpc.isConnected());
  messageIsSync = true;
  outerXpc.send(ECHO_SERVICE_NAME, MESSAGE_PAYLOAD_1);
  messageIsSync = false;
}


function responseMessageHandler_testSyncMode(message) {
  assertTrue('The message response was syncronous', messageIsSync);
  assertEquals(
      'Received payload is equal to sent payload.',
      message,
      MESSAGE_PAYLOAD_1);
  asyncTestCase.continueTesting();
}
