Declarative Web Request: firstPartyForCookiesUrl

chrome/test/data/extensions/api_test/webrequest/test_declarative.js

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 var onRequest = chrome.declarativeWebRequest.onRequest;
 var AddResponseHeader =
     chrome.declarativeWebRequest.AddResponseHeader;
 var RequestMatcher = chrome.declarativeWebRequest.RequestMatcher;
 var CancelRequest = chrome.declarativeWebRequest.CancelRequest;
 var RedirectByRegEx = chrome.declarativeWebRequest.RedirectByRegEx;
@@ skipping 38 matching lines @@
 function getURLHttpRedirectTest() {
   return getServerURL(
       "files/extensions/api_test/webrequest/declarative/a.html");
 }
 
 function getURLHttpWithHeaders() {
   return getServerURL(
       "files/extensions/api_test/webrequest/declarative/headers.html");
 }
 
-function getURLThirdParty() {
+function getURLOfHTMLWithThirdParty() {
   // Returns the URL of a HTML document with a third-party resource.
   return getServerURL(
       "files/extensions/api_test/webrequest/declarative/third-party.html");
 }
 
 function getURLSetCookie() {
   return getServerURL('set-cookie?Foo=Bar');
 }
 
 function getURLSetCookie2() {
   return getServerURL('set-cookie?passedCookie=Foo&editedCookie=Foo&' +
                       'deletedCookie=Foo');
 }
 
 function getURLEchoCookie() {
   return getServerURL('echoheader?Cookie');
 }
 
 function getURLHttpXHRData() {
   return getServerURL("files/extensions/api_test/webrequest/xhr/data.json",
                       "b.com");
 }
 
 // Shared test sections.
 function cancelThirdPartyExpected() {
     return [
       { label: "onBeforeRequest",
         event: "onBeforeRequest",
         details: {
-          url: getURLThirdParty(),
-          frameUrl: getURLThirdParty()
+          url: getURLOfHTMLWithThirdParty(),
+          frameUrl: getURLOfHTMLWithThirdParty()
         }
       },
       { label: "onBeforeSendHeaders",
         event: "onBeforeSendHeaders",
-        details: {url: getURLThirdParty()}
+        details: {url: getURLOfHTMLWithThirdParty()}
       },
       { label: "onSendHeaders",
         event: "onSendHeaders",
-        details: {url: getURLThirdParty()}
+        details: {url: getURLOfHTMLWithThirdParty()}
       },
       { label: "onHeadersReceived",
         event: "onHeadersReceived",
         details: {
-          url: getURLThirdParty(),
+          url: getURLOfHTMLWithThirdParty(),
           statusLine: "HTTP/1.0 200 OK"
         }
       },
       { label: "onResponseStarted",
         event: "onResponseStarted",
         details: {
-          url: getURLThirdParty(),
+          url: getURLOfHTMLWithThirdParty(),
           fromCache: false,
           ip: "127.0.0.1",
           statusCode: 200,
           statusLine: "HTTP/1.0 200 OK"
         }
       },
       { label: "onCompleted",
         event: "onCompleted",
         details: {
           fromCache: false,
           ip: "127.0.0.1",
-          url: getURLThirdParty(),
+          url: getURLOfHTMLWithThirdParty(),
           statusCode: 200,
           statusLine: "HTTP/1.0 200 OK"
         }
       },
       { label: "img-onBeforeRequest",
         event: "onBeforeRequest",
         details: {
           type: "image",
           url: "http://non_existing_third_party.com/image.png",
-          frameUrl: getURLThirdParty()
+          frameUrl: getURLOfHTMLWithThirdParty()
         }
       },
       { label: "img-onErrorOccurred",
         event: "onErrorOccurred",
         details: {
           error: "net::ERR_BLOCKED_BY_CLIENT",
           fromCache: false,
           type: "image",
           url: "http://non_existing_third_party.com/image.png"
         }
@@ skipping 97 matching lines @@
       function() {navigateAndWait(getURLHttpWithHeaders());}
     );
   },
   // Tests that "thirdPartyForCookies: true" matches third party requests.
   function testThirdParty() {
     ignoreUnexpected = false;
     expect(cancelThirdPartyExpected(), cancelThirdPartyExpectedOrder());
     onRequest.addRules(
       [ {'conditions': [new RequestMatcher({thirdPartyForCookies: true})],
          'actions': [new chrome.declarativeWebRequest.CancelRequest()]},],
-      function() {navigateAndWait(getURLThirdParty());}
+      function() {navigateAndWait(getURLOfHTMLWithThirdParty());}
     );
   },
 
   // Tests that "thirdPartyForCookies: false" matches first party requests,
   // by cancelling all requests, and overriding the cancelling rule only for
   // requests matching "thirdPartyForCookies: false".
   function testFirstParty() {
     ignoreUnexpected = false;
     expect(cancelThirdPartyExpected(), cancelThirdPartyExpectedOrder());
     onRequest.addRules(
       [ {'priority': 2,
          'conditions': [
            new RequestMatcher({thirdPartyForCookies: false})
          ],
          'actions': [
            new chrome.declarativeWebRequest.IgnoreRules({
               lowerPriorityThan: 2 })
          ]
         },
         {'priority': 1,
          'conditions': [new RequestMatcher({})],
          'actions': [new chrome.declarativeWebRequest.CancelRequest()]
         },
       ],
-      function() {navigateAndWait(getURLThirdParty());}
+      function() {navigateAndWait(getURLOfHTMLWithThirdParty());}
     );
   },
 
+  // Tests "firstPartyForCookiesUrl" by using it to override a cancelling rule.

[Jeffrey Yasskin, 2013/01/24 00:39:17]

Instead of doing this in an apitest, can you fake the relevant requests and test
this in a unittest? That'll run faster, and likely be clearer because you can
inspect the deltas directly instead of needing to use several rule priorities.
IMO, the API test should be limited to testing that the overall system works
together, as opposed to testing each individual piece.

[vabr (Chromium), 2013/01/24 18:24:08]

I agree with this test being too heavy, so I had to rethink my objectives. This
is what I wanted to test:
1. That 'firstPartyForCookiesUrl' works end-to-end.
2. That it is evaluated against the firstPartyForCookies URL, as opposed to the
'url' attribute.

After talking to Dominic, I still want to test 1. with an apitest. All
Declarative WR attributes get tested end-to-end this way. If this can be
improved, we should plan for a switch of all of them to other kind of tests, but
that's beyond this CL.

However, for testing 1. I can use (and used) a much simpler apitest.

To test 2. I wrote a unittest for rules registry.

Is that acceptable to you, Jeffrey?

[Jeffrey Yasskin, 2013/01/24 19:54:46]

Totally acceptable for this change. I think that I disagree that all
declarativeWebRequest attributes should be individually tested in an apitest,
but there's no need to change that in this CL.

+  function testFirstPartyForCookiesUrl() {
+    // This test sets up three rules:
+    // Rule 1 is a priority 1 cancel-all rule to fire onBeforeRequest.
+    // Rule 2 is a priority 2 rule to ignore rule 1 for requests satisfying the
+    //   first-party filter. This rule is the core of this test.
+    // Rule 3 is a priority 3 canceling rule for non-existing URLs. It will
+    //   fire later, in stage onBeforeSendHeaders. This is necessary to avoid
+    //   platform-dependent HTTP 404 responses.
+    ignoreUnexpected = false;
+    expect(
+      [
+        // This block of events is a successfull fetch of the main frame doc.

[Jeffrey Yasskin, 2013/01/24 00:39:17]

sp: successfull

[vabr (Chromium), 2013/01/24 18:24:08]

Done (and then removed completely :)).

+        { label: "onBeforeRequest",
+          event: "onBeforeRequest",
+          details: {
+            url: getURLOfHTMLWithThirdParty(),
+            frameUrl: getURLOfHTMLWithThirdParty()
+          }
+        },
+        // Once we are here, rule 1 has been ignored.
+        { label: "onBeforeSendHeaders",
+          event: "onBeforeSendHeaders",
+          details: {url: getURLOfHTMLWithThirdParty()}
+        },
+        // Rule 3 does not apply, because the requested resource exists.
+        { label: "onSendHeaders",
+          event: "onSendHeaders",
+          details: {url: getURLOfHTMLWithThirdParty()}
+        },
+        { label: "onHeadersReceived",
+          event: "onHeadersReceived",
+          details: {
+            url: getURLOfHTMLWithThirdParty(),
+            statusLine: "HTTP/1.0 200 OK"
+          }
+        },
+        { label: "onResponseStarted",
+          event: "onResponseStarted",
+          details: {
+            url: getURLOfHTMLWithThirdParty(),
+            fromCache: false,
+            ip: "127.0.0.1",
+            statusCode: 200,
+            statusLine: "HTTP/1.0 200 OK"
+          }
+        },
+        { label: "onCompleted",
+          event: "onCompleted",
+          details: {
+            fromCache: false,
+            ip: "127.0.0.1",
+            url: getURLOfHTMLWithThirdParty(),
+            statusCode: 200,
+            statusLine: "HTTP/1.0 200 OK"
+          }
+        },
+
+        // This block of events is a fetch of a non-existing sub-resource.
+        { label: "img-onBeforeRequest",
+          event: "onBeforeRequest",
+          details: {
+            type: "image",
+            url: "http://non_existing_third_party.com/image.png",
+            frameUrl: getURLOfHTMLWithThirdParty()
+          }
+        },
+        // Once we are here, rule 1 has been ignored.
+        { label: "img-onBeforeSendHeaders",
+          event: "onBeforeSendHeaders",
+          details: {
+            type: "image",
+            url: "http://non_existing_third_party.com/image.png",
+          }
+        },
+        // Rule 3 has fired, and saved us the trouble of getting a 404.
+        { label: "img-onErrorOccurred",
+          event: "onErrorOccurred",
+          details: {
+            url: "http://non_existing_third_party.com/image.png",
+            type: "image",
+            fromCache: false,
+            error: "net::ERR_BLOCKED_BY_CLIENT"
+          }
+        },
+      ],
+      [ ["onBeforeRequest", "onBeforeSendHeaders", "onSendHeaders",
+         "onHeadersReceived", "onResponseStarted", "onCompleted"],
+        ["img-onBeforeRequest", "img-onBeforeSendHeaders",
+         "img-onErrorOccurred"] ]);
+    onRequest.addRules(
+      [ // This rule cancels everyhting, and sooner than the very last rule
+        // would. The test is reduced to making sure this (1st) rule was ignored
+        // as a consequence of the 2nd rule.
+        {'priority': 1,
+         'conditions': [new RequestMatcher({
+           'stages': ["onBeforeRequest"]
+         })],
+         'actions': [new chrome.declarativeWebRequest.CancelRequest()]
+        },
+        {'priority': 2,
+         'conditions': [
+           new RequestMatcher({
+             firstPartyForCookiesUrl: {
+               hostEquals: testServer
+             }
+           })
+         ],
+         'actions': [
+           new chrome.declarativeWebRequest.IgnoreRules({
+              lowerPriorityThan: 2 })
+         ]
+        },
+        // This rule cancels the request with a 3rd party URL just before it is
+        // sent. This is necessary, because sending it would generate different
+        // HTTP 4xx codes on different platforms, making it impossible to
+        // present a single list of expected events.
+        {'priority': 3,
+         'conditions': [new RequestMatcher({
+           'url': { 'hostEquals': 'non_existing_third_party.com' },
+           'stages': ["onBeforeSendHeaders"]
+         })],
+         'actions': [new chrome.declarativeWebRequest.CancelRequest()]
+        },
+      ],
+      function() {navigateAndWait(getURLOfHTMLWithThirdParty());}
+    );
+  },
+
   function testRedirectRequest() {
     ignoreUnexpected = true;
     expect(
       [
         { label: "onBeforeRequest-a",
           event: "onBeforeRequest",
           details: {
             type: "main_frame",
             url: getURLHttpComplex(),
             frameUrl: getURLHttpComplex()
@@ skipping 404 matching lines @@
              },
              'requestHeaders': [{ nameContains: "" }],
              'excludeRequestHeaders': [{ valueContains: ["", "value123"] }]
               })],
          'actions': [new CancelRequest()]}
       ],
       function() {navigateAndWait(getURLHttpSimple());}
     );
   },
   ]);