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