without the plumbing!

third_party/WebKit/LayoutTests/http/tests/inspector-protocol/network/interception-test.js

+var initialize_InterceptionTest = function() {
+
+var interceptionRequestParams = {};
+var requestIdToFilename = {};
+var loggedMessages = {};
+var requestIdToCanonicalInterceptionId = {};
+var idToCanoncalId = {};
+var nextId = 1;
+
+function getNextId()
+{
+    return "ID " + nextId++;
+}
+
+function canonicalId(id)
+{
+    if (!idToCanoncalId.hasOwnProperty(id))
+        idToCanoncalId[id] = getNextId();
+    return idToCanoncalId[id];
+}
+
+function log(id, message)
+{
+    if (!loggedMessages.hasOwnProperty(id))
+        loggedMessages[id] = [];
+    loggedMessages[id].push(message);
+}
+
+function completeTest(message)
+{
+    // The order in which network events occur is not fully deterministic so we
+    // sort based on the interception ID to try and make the test non-flaky.
+    for (var property in loggedMessages) {
+        if (loggedMessages.hasOwnProperty(property)) {
+            var messages = loggedMessages[property];
+            for (var i = 0; i < messages.length; i++) {
+                InspectorTest.log(messages[i]);
+            }
+        }
+    }
+
+    if (message)
+        InspectorTest.log(message);
+
+    InspectorTest.completeTest();
+}
+
+InspectorTest.startInterceptionTest = function(interceptedRequestDict,
+                                               interceptedRedirectDict,
+                                               numConsoleLogsToWaitFor) {
+    if (typeof numConsoleLogsToWaitFor === "undefined")
+        numConsoleLogsToWaitFor = 0;
+
+    InspectorTest.eventHandler["Network.interceptedRequest"] = onInterceptedRequest;
+    InspectorTest.eventHandler["Network.interceptedRedirect"] = onInterceptedRedirect;
+    InspectorTest.eventHandler["Network.loadingFailed"] = onLoadingFailed;
+    InspectorTest.eventHandler["Network.requestWillBeSent"] = onRequestWillBeSent;
+    InspectorTest.eventHandler["Network.responseReceived"] = onResponseReceived;
+    InspectorTest.eventHandler["Runtime.consoleAPICalled"] = onConsoleAPICalled;
+    InspectorTest.eventHandler["Page.frameStoppedLoading"] = onStop;
+
+    var frameStoppedLoading = false;
+
+    function enableNetwork()
+    {
+        InspectorTest.log("Test started");
+        InspectorTest.sendCommand("Network.enable", {}, didEnableNetwork);
+    }
+
+    function didEnableNetwork(messageObject)
+    {
+        if (messageObject.error) {
+            completeTest("FAIL: Couldn't enable network agent" +
+                                  messageObject.error.message);
+            return;
+        }
+        InspectorTest.log("Network agent enabled");
+        InspectorTest.sendCommand(
+            "Network.enableFetchInterception", {"enabled": true},
+            didEnableFetchInterception);
+    }
+
+    function didEnableFetchInterception(messageObject)
+    {
+        if (messageObject.error) {
+            completeTest("FAIL: Couldn't enable fetch interception" +
+                                    messageObject.error.message);
+            return;
+        }
+        InspectorTest.log("Fetch interception enabled");
+        InspectorTest.sendCommand("Page.enable", {}, didEnablePage);
+    }
+
+    function didEnablePage(messageObject)
+    {
+        if (messageObject.error) {
+            completeTest("FAIL: Couldn't enable page agent" +
+                                    messageObject.error.message);
+            return;
+        }
+        InspectorTest.log("Page agent enabled");
+
+        InspectorTest.sendCommand("Runtime.enable", {}, didEnableRuntime);
+    }
+
+    function didEnableRuntime(messageObject)
+    {
+        if (messageObject.error) {
+            completeTest("FAIL: Couldn't enable runtime agent" +
+                                    messageObject.error.message);
+            return;
+        }
+        InspectorTest.log("Runtime agent enabled");
+
+        InspectorTest.sendCommand(
+            "Runtime.evaluate", { "expression": "appendIframe()"});
+    }
+
+    function onInterceptedRequest(event)
+    {
+        var filename = event.params.request.url.split('/').pop();
+        var id = canonicalId(event.params.requestId);
+        interceptionRequestParams[id] = event.params.request;
+        if (interceptedRequestDict.hasOwnProperty(filename)) {
+            log(id, "Network.interceptedRequest " + id + " " +
+                    event.params.request.method + " " + filename);
+            interceptedRequestDict[filename](event);
+        } else {
+            completeTest("FAILED: unexpected request interception " +
+                             JSON.stringify(event.params));
+        }
+    }
+
+    function onInterceptedRedirect(event)
+    {
+        var redirectFilename = event.params.redirectUrl.split('/').pop();
+        var id = canonicalId(event.params.requestId);
+        if (interceptedRedirectDict.hasOwnProperty(redirectFilename)) {
+            log(id, "Network.interceptedRedirect " + id + " " +
+                    event.params.responseStatusCode + " " +
+                    interceptionRequestParams[id].url.split('/').pop() +
+                    " -> " + redirectFilename);
+            interceptedRedirectDict[redirectFilename](event);
+        } else {
+            completeTest("FAILED: unexpected redirect interception " +
+                             JSON.stringify(event.params));
+        }
+        interceptionRequestParams[id].url = event.params.redirectUrl;
+    }
+
+    function onLoadingFailed(event)
+    {
+        var id = canonicalId(event.params.requestId);
+        log(id, "Network.loadingFailed " + id + " " +
+                requestIdToFilename[event.params.requestId] + " " +
+                event.params.errorText);
+    }
+
+    function onRequestWillBeSent(event)
+    {
+        var filename = event.params.request.url.split('/').pop();
+        requestIdToFilename[event.params.requestId] = filename;
+    }
+
+    function onResponseReceived(event)
+    {
+        var response = event.params.response;
+        var filename = response.url.split('/').pop();
+        var id = canonicalId(event.params.requestId);
+        log(id, "Network.responseReceived " + filename + " " + response.status +
+                " " + response.mimeType + " requestId = " + id);
+    }
+
+    function onStop()
+    {
+        frameStoppedLoading = true;
+        log(getNextId(), "Page.frameStoppedLoading");
+
+        maybeCompleteTest();
+    }
+
+    function onConsoleAPICalled(messageObject)
+    {
+        if (messageObject.params.type !== "log")
+            return;
+
+        numConsoleLogsToWaitFor--;
+        maybeCompleteTest();
+    }
+
+    // Wait until we've seen Page.frameStoppedLoading and the expected number of
+    // console logs.
+    function maybeCompleteTest() {
+        if (numConsoleLogsToWaitFor === 0 && frameStoppedLoading)
+            completeTest();
+    }
+
+    enableNetwork();
+}
+
+InspectorTest.allowRequest = function(event) {
+    var id = canonicalId(event.params.requestId);
+    log(id, "Network.allowRequest " + id);
+    InspectorTest.sendCommand(
+        "Network.allowRequest", { "requestId": event.params.requestId });
+}
+
+InspectorTest.modifyRequest = function(event, params) {
+    var id = canonicalId(event.params.requestId);
+    var mods = [];
+    for (property in params) {
+        if (!params.hasOwnProperty(property))
+            continue;
+        if (property === "url") {
+            var newUrl = params["url"];
+            var filename = interceptionRequestParams[id].url;
+            mods.push("url " + filename.split('/').pop() + " -> " + newUrl);
+            var directoryPath =
+                filename.substring(0, filename.lastIndexOf('/') + 1);
+            params["url"] = directoryPath + newUrl;
+        } else {
+            mods.push(property + " " +
+                      JSON.stringify(interceptionRequestParams[id][property]) +
+                      " -> " + JSON.stringify(params[property]));
+        }
+    }
+
+    log(id, "Network.modifyRequest " + id + ": " + mods.join("; "));
+    params["requestId"] = event.params.requestId;
+    InspectorTest.sendCommand("Network.modifyRequest", params);
+}
+
+InspectorTest.blockRequest = function(event, errorReason) {
+    var id = canonicalId(event.params.requestId);
+    log(id, "Network.blockRequest " + id + " " + errorReason);
+    InspectorTest.sendCommand("Network.blockRequest", {
+      "requestId": event.params.requestId, "errorReason": errorReason});
+}
+
+InspectorTest.mockResponse = function(event, rawResponse) {
+    var id = canonicalId(event.params.requestId);
+    log(id, "Network.mockResponse " + id);
+    InspectorTest.sendCommand("Network.mockResponse", {
+      "requestId": event.params.requestId,
+      "rawResponse": rawResponse});
+}
+
+}