Added several new bypass telemetry tests for the data reduction proxy

tools/chrome_proxy/integration_tests/chrome_proxy_measurements.py

 # Copyright 2014 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.
 
 import base64
 import logging
 import urlparse
 
 from integration_tests import chrome_proxy_metrics as metrics
 from metrics import loading
@@ skipping 94 matching lines @@
 class ChromeProxyBypass(ChromeProxyValidation):
   """Correctness measurement for bypass responses."""
 
   def __init__(self):
     super(ChromeProxyBypass, self).__init__(restart_after_each_page=True)
 
   def AddResults(self, tab, results):
     self._metrics.AddResultsForBypass(tab, results)
 
 
+class ChromeProxyFallback(ChromeProxyValidation):
+  """Correctness measurement for bypass responses."""

[bengr, 2014/10/17 23:24:07]

Can you be more specific?

[sclittle, 2014/10/17 23:42:33]

Done.

+
+  def __init__(self):
+    super(ChromeProxyFallback, self).__init__(restart_after_each_page=True)
+
+  def AddResults(self, tab, results):
+    self._metrics.AddResultsForFallback(tab, results)
+
+
 class ChromeProxyCorsBypass(ChromeProxyValidation):
   """Correctness measurement for bypass responses."""
 
   def __init__(self):
     super(ChromeProxyCorsBypass, self).__init__(restart_after_each_page=True)
 
   def ValidateAndMeasurePage(self, page, tab, results):
     # The test page sets window.xhrRequestCompleted to true when the XHR fetch
     # finishes.
     tab.WaitForJavaScriptExpression('window.xhrRequestCompleted', 15000)
     super(ChromeProxyCorsBypass,
-          self).ValidateAndMeasurePag1Ge(page, tab, results)
+          self).ValidateAndMeasurePage(page, tab, results)
 
   def AddResults(self, tab, results):
     self._metrics.AddResultsForCorsBypass(tab, results)
 
 
 class ChromeProxyBlockOnce(ChromeProxyValidation):
   """Correctness measurement for block-once responses."""
 
   def __init__(self):
     super(ChromeProxyBlockOnce, self).__init__(restart_after_each_page=True)
@@ skipping 19 matching lines @@
 _FAKE_PROXY_AUTH_VALUE = 'aabbccdd3b7579186c1b0620614fdb1f0000ffff'
 _TEST_SERVER = 'chromeproxy-test.appspot.com'
 _TEST_SERVER_DEFAULT_URL = 'http://' + _TEST_SERVER + '/default'
 
 
 # We rely on the chromeproxy-test server to facilitate some of the tests.
 # The test server code is at <TBD location> and runs at _TEST_SERVER
 #
 # The test server allow request to override response status, headers, and
 # body through query parameters. See GetResponseOverrideURL.
-def GetResponseOverrideURL(url, respStatus=0, respHeader="", respBody=""):
+def GetResponseOverrideURL(url=_TEST_SERVER_DEFAULT_URL, respStatus=0,
+                           respHeader="", respBody=""):
   """ Compose the request URL with query parameters to override
   the chromeproxy-test server response.
   """
 
   queries = []
   if respStatus > 0:
     queries.append('respStatus=%d' % respStatus)
   if respHeader:
     queries.append('respHeader=%s' % base64.b64encode(respHeader))
   if respBody:
@@ skipping 17 matching lines @@
 
   def __init__(self):
     super(ChromeProxyHTTPFallbackProbeURL, self).__init__()
 
   def CustomizeBrowserOptions(self, options):
     super(ChromeProxyHTTPFallbackProbeURL,
           self).CustomizeBrowserOptions(options)
     # Use the test server probe URL which returns the response
     # body as specified by respBody.
     probe_url = GetResponseOverrideURL(
-        _TEST_SERVER_DEFAULT_URL,
         respBody='not OK')
     options.AppendExtraBrowserArgs(
         '--data-reduction-proxy-probe-url=%s' % probe_url)
 
   def AddResults(self, tab, results):
     self._metrics.AddResultsForHTTPFallback(tab, results)
 
 
 class ChromeProxyHTTPFallbackViaHeader(ChromeProxyValidation):
   """Correctness measurement for proxy fallback.
@@ skipping 62 matching lines @@
         self._metrics.effective_proxies['proxy'],
         self._metrics.effective_proxies['fallback'],
         self._metrics.effective_proxies['direct']]
     bad_proxies = [self._metrics.effective_proxies['proxy']]
     self._metrics.VerifyProxyInfo(tab, proxies, bad_proxies)
 
   def AddResults(self, tab, results):
     self._metrics.AddResultsForHTTPToDirectFallback(tab, results)
 
 
+class ChromeProxyExplicitBypass(ChromeProxyValidation):
+  """Correctness measurement for explicit proxy bypasses.
+
+  In this test, the configured proxy is the chromeproxy-test server which
+  will send back a response without the expected Via header. Chrome is
+  expected to use the fallback proxy and add the configured proxy to the
+  bad proxy list.
+  """
+
+  def __init__(self):
+    super(ChromeProxyExplicitBypass, self).__init__(
+        restart_after_each_page=True)
+
+  def CustomizeBrowserOptions(self, options):
+    super(ChromeProxyExplicitBypass,
+          self).CustomizeBrowserOptions(options)
+    options.AppendExtraBrowserArgs('--ignore-certificate-errors')
+    options.AppendExtraBrowserArgs(
+        '--spdy-proxy-auth-origin=http://%s' % _TEST_SERVER)
+    options.AppendExtraBrowserArgs(
+        '--spdy-proxy-auth-value=%s' % _FAKE_PROXY_AUTH_VALUE)
+
+  def AddResults(self, tab, results):
+    bad_proxies = [{
+        'proxy': _TEST_SERVER + ':80',
+        'retry_seconds_low': self._page.bypass_seconds_low,
+        'retry_seconds_high': self._page.bypass_seconds_high
+    }]
+    if self._page.num_bypassed_proxies == 2:
+      bad_proxies.append({
+          'proxy': self._metrics.effective_proxies['fallback'],
+          'retry_seconds_low': self._page.bypass_seconds_low,
+          'retry_seconds_high': self._page.bypass_seconds_high
+      })
+    else:
+      # Even if the test page only causes the primary proxy to be bypassed,
+      # Chrome will attempt to fetch the favicon for the test server through
+      # the data reduction proxy, which will cause a "block=0" bypass.
+      bad_proxies.append({'proxy': self._metrics.effective_proxies['fallback']})
+
+    self._metrics.AddResultsForExplicitBypass(tab, results, bad_proxies)
+
+
 class ChromeProxySmoke(ChromeProxyValidation):
   """Smoke measurement for basic chrome proxy correctness."""
 
   def __init__(self):
     super(ChromeProxySmoke, self).__init__()
 
   def WillNavigateToPage(self, page, tab):
     super(ChromeProxySmoke, self).WillNavigateToPage(page, tab)
     if page.name == 'safebrowsing':
       self._expect_timeout = True
@@ skipping 16 matching lines @@
             ],
         'bypass': [self._metrics.AddResultsForBypass],
         'safebrowsing': [self._metrics.AddResultsForSafebrowsing],
         }
     if not self._page.name in page_to_metrics:
       raise page_test.MeasurementFailure(
           'Invalid page name (%s) in smoke. Page name must be one of:\n%s' % (
           self._page.name, page_to_metrics.keys()))
     for add_result in page_to_metrics[self._page.name]:
       add_result(tab, results)