src/chrome/test/data/extensions/api_test/messaging/connect/test.js

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 var listenOnce = chrome.test.listenOnce;
   6 var listenForever = chrome.test.listenForever;
   7
   8 JSON.parse = function() {
   9   return "JSON.parse clobbered by extension.";
  10 };
  11
  12 JSON.stringify = function() {
  13   return "JSON.stringify clobbered by extension.";
  14 };
  15
  16 Array.prototype.toJSON = function() {
  17   return "Array.prototype.toJSON clobbered by extension.";
  18 };
  19
  20 Object.prototype.toJSON = function() {
  21   return "Object.prototype.toJSON clobbered by extension.";
  22 };
  23
  24 // Keep track of the tab that we're running tests in, for simplicity.
  25 var testTab = null;
  26
  27 chrome.test.getConfig(function(config) {
  28   chrome.test.runTests([
  29     function setupTestTab() {
  30       chrome.test.log("Creating tab...");
  31       chrome.tabs.create({
  32         url: "http://localhost:PORT/extensions/test_file.html"
  33                  .replace(/PORT/, config.testServer.port)
  34       }, function(newTab) {
  35         var doneListening = listenForever(chrome.tabs.onUpdated,
  36           function(_, info, tab) {
  37             if (tab.id == newTab.id && info.status == 'complete') {
  38               chrome.test.log("Created tab: " + tab.url);
  39               testTab = tab;
  40               doneListening();
  41             }
  42           });
  43       });
  44     },
  45
  46     // Tests that postMessage to the tab and its response works.
  47     function postMessage() {
  48       var port = chrome.tabs.connect(testTab.id);
  49       port.postMessage({testPostMessage: true});
  50       listenOnce(port.onMessage, function(msg) {
  51         port.disconnect();
  52       });
  53     },
  54
  55     // Tests that port name is sent & received correctly.
  56     function portName() {
  57       var portName = "lemonjello";
  58       var port = chrome.tabs.connect(testTab.id, {name: portName});
  59       port.postMessage({testPortName: true});
  60       listenOnce(port.onMessage, function(msg) {
  61         chrome.test.assertEq(msg.portName, portName);
  62         port.disconnect();
  63       });
  64     },
  65
  66     // Tests that postMessage from the tab and its response works.
  67     function postMessageFromTab() {
  68       listenOnce(chrome.runtime.onConnect, function(port) {
  69         chrome.test.assertEq({
  70           tab: testTab,
  71           url: testTab.url,
  72            id: chrome.runtime.id
  73         }, port.sender);
  74         listenOnce(port.onMessage, function(msg) {
  75           chrome.test.assertTrue(msg.testPostMessageFromTab);
  76           port.postMessage({success: true, portName: port.name});
  77           chrome.test.log("postMessageFromTab: got message from tab");
  78         });
  79       });
  80
  81       var port = chrome.tabs.connect(testTab.id);
  82       port.postMessage({testPostMessageFromTab: true});
  83       chrome.test.log("postMessageFromTab: sent first message to tab");
  84       listenOnce(port.onMessage, function(msg) {
  85         port.disconnect();
  86       });
  87     },
  88
  89     // Tests receiving a request from a content script and responding.
  90     function sendMessageFromTab() {
  91       var doneListening = listenForever(
  92         chrome.runtime.onMessage,
  93         function(request, sender, sendResponse) {
  94           chrome.test.assertEq({
  95             tab: testTab,
  96             url: testTab.url,
  97              id: chrome.runtime.id
  98           }, sender);
  99           if (request.step == 1) {
 100             // Step 1: Page should send another request for step 2.
 101             chrome.test.log("sendMessageFromTab: got step 1");
 102             sendResponse({nextStep: true});
 103           } else {
 104             // Step 2.
 105             chrome.test.assertEq(request.step, 2);
 106             sendResponse();
 107             doneListening();
 108           }
 109       });
 110
 111       var port = chrome.tabs.connect(testTab.id);
 112       port.postMessage({testSendMessageFromTab: true});
 113       port.disconnect();
 114       chrome.test.log("sendMessageFromTab: sent first message to tab");
 115     },
 116
 117     // Tests error handling when sending a request from a content script to an
 118     // invalid extension.
 119     function sendMessageFromTabError() {
 120       listenOnce(
 121         chrome.runtime.onMessage,
 122         function(request, sender, sendResponse) {
 123           if (!request.success)
 124             chrome.test.fail();
 125         }
 126       );
 127
 128       var port = chrome.tabs.connect(testTab.id);
 129       port.postMessage({testSendMessageFromTabError: true});
 130       port.disconnect();
 131       chrome.test.log("testSendMessageFromTabError: send 1st message to tab");
 132     },
 133
 134     // Tests error handling when connecting to an invalid extension from a
 135     // content script.
 136     function connectFromTabError() {
 137       listenOnce(
 138         chrome.runtime.onMessage,
 139         function(request, sender, sendResponse) {
 140           if (!request.success)
 141             chrome.test.fail();
 142         }
 143       );
 144
 145       var port = chrome.tabs.connect(testTab.id);
 146       port.postMessage({testConnectFromTabError: true});
 147       port.disconnect();
 148       chrome.test.log("testConnectFromTabError: sent 1st message to tab");
 149     },
 150
 151     // Tests sending a request to a tab and receiving a response.
 152     function sendMessage() {
 153       chrome.tabs.sendMessage(testTab.id, {step2: 1}, function(response) {
 154         chrome.test.assertTrue(response.success);
 155         chrome.test.succeed();
 156       });
 157     },
 158
 159     // Tests that we get the disconnect event when the tab disconnect.
 160     function disconnect() {
 161       var port = chrome.tabs.connect(testTab.id);
 162       port.postMessage({testDisconnect: true});
 163       listenOnce(port.onDisconnect, function() {});
 164     },
 165
 166     // Tests that a message which fails to serialize prints an error and
 167     // doesn't send (http://crbug.com/263077).
 168     function unserializableMessage() {
 169       try {
 170         chrome.tabs.connect(testTab.id).postMessage(function() {
 171           // This shouldn't ever be called, so it's a bit pointless.
 172           chrome.test.fail();
 173         });
 174         // Didn't crash.
 175         chrome.test.succeed();
 176       } catch (e) {
 177         chrome.test.fail(e.stack);
 178       }
 179     },
 180
 181     // Tests that we get the disconnect event when the tab context closes.
 182     function disconnectOnClose() {
 183       var port = chrome.tabs.connect(testTab.id);
 184       port.postMessage({testDisconnectOnClose: true});
 185       listenOnce(port.onDisconnect, function() {
 186         testTab = null; // the tab is about:blank now.
 187       });
 188     },
 189
 190     // Tests that the sendRequest API is disabled.
 191     function sendRequest() {
 192       var error;
 193       try {
 194         chrome.extension.sendRequest("hi");
 195       } catch(e) {
 196         error = e;
 197       }
 198       chrome.test.assertTrue(error != undefined);
 199
 200       error = undefined;
 201       try {
 202         chrome.extension.onRequest.addListener(function() {});
 203       } catch(e) {
 204         error = e;
 205       }
 206       chrome.test.assertTrue(error != undefined);
 207
 208       chrome.test.succeed();
 209     },
 210
 211   ]);
 212 });