Added integration tests for falling back from the HTTP proxy to direct.

tools/chrome_proxy/integration_tests/chrome_proxy_metrics.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 datetime
 import logging
 import os
 
 from integration_tests import network_metrics
 from telemetry.page import page_test
@@ skipping 23 matching lines @@
   with open(os.path.join(os.path.dirname(__file__),
                          'chrome_proxy_metrics.js')) as f:
     js = f.read()
     tab.ExecuteJavaScript(js)
   tab.WaitForJavaScriptExpression('performance.timing.loadEventStart', 300)
   info = tab.EvaluateJavaScript('window.__getChromeProxyInfo()')
   return info
 
 
 def ProxyRetryTimeInRange(retry_time, low, high, grace_seconds=30):
-  return (retry_time >= low and
+  return (retry_time >= low - datetime.timedelta(seconds=grace_seconds) and
           (retry_time < high + datetime.timedelta(seconds=grace_seconds)))
 
 
 class ChromeProxyResponse(network_metrics.HTTPResponse):
   """ Represents an HTTP response from a timeleine event."""
   def __init__(self, event):
     super(ChromeProxyResponse, self).__init__(event)
 
   def ShouldHaveChromeProxyViaHeader(self):
     resp = self.response
@@ skipping 109 matching lines @@
         raise ChromeProxyMetricException, ('%s: Response is not 200: %d' %
                                            (r.url, r.status))
       if not resp.IsValidByViaHeader():
         raise ChromeProxyMetricException, ('%s: Response missing via header' %
                                            (r.url))
     results.AddValue(scalar.ScalarValue(
         results.current_page, 'version_test', 'count', 1))
 
 
   def IsProxyBypassed(self, tab):
-    """ Returns True if all configured proxies are bypassed."""
+    """Get whether all configured proxies are bypassed.
+
+    Returns:
+        A tuple of the form (boolean, string list). If all configured proxies
+        are bypassed, then the return value will be (True, bypassed proxies).
+        Otherwise, the return value will be (False, empty list).
+    """
     if not tab:
       return False, []
 
     info = GetProxyInfoFromNetworkInternals(tab)
     if not info['enabled']:
       raise ChromeProxyMetricException, (
           'Chrome proxy should be enabled. proxy info: %s' % info)
 
     bad_proxies = [str(p['proxy']) for p in info['badProxies']]
     bad_proxies.sort()
@@ skipping 35 matching lines @@
                         datetime.timedelta(seconds=retry_seconds_high))
       got_retry_time = datetime.datetime.fromtimestamp(int(p['retry'])/1000)
       if not ProxyRetryTimeInRange(
           got_retry_time, retry_time_low, retry_time_high):
         raise ChromeProxyMetricException, (
             'Bad proxy %s retry time (%s) should be within range (%s-%s).' % (
                 p['proxy'], str(got_retry_time), str(retry_time_low),
                 str(retry_time_high)))
     return True
 
+  def VerifyAllProxiesBypassed(self, tab):
+    if tab:
+      info = GetProxyInfoFromNetworkInternals(tab)
+      if not info['enabled']:
+        raise ChromeProxyMetricException, (
+            'Chrome proxy should be enabled. proxy info: %s' % info)
+      is_bypassed, expected_bad_proxies = self.IsProxyBypassed(tab)
+      if not is_bypassed:
+        raise ChromeProxyMetricException, (
+            'Chrome proxy should be bypassed. proxy info: %s' % info)
+      self.VerifyBadProxies(info['badProxies'], expected_bad_proxies)
+
   def AddResultsForBypass(self, tab, results):
     bypass_count = 0
     for resp in self.IterResponses(tab):
       if resp.HasChromeProxyViaHeader():
         r = resp.response
         raise ChromeProxyMetricException, (
             '%s: Should not have Via header (%s) (refer=%s, status=%d)' % (
                 r.url, r.GetHeader('Via'), r.GetHeader('Referer'), r.status))
       bypass_count += 1
 
-    if tab:
-      info = GetProxyInfoFromNetworkInternals(tab)
-      if not info['enabled']:
-        raise ChromeProxyMetricException, (
-            'Chrome proxy should be enabled. proxy info: %s' % info)
-      _, expected_bad_proxies = self.IsProxyBypassed(tab)
-      self.VerifyBadProxies(info['badProxies'], expected_bad_proxies)
-
+    self.VerifyAllProxiesBypassed(tab)
     results.AddValue(scalar.ScalarValue(
         results.current_page, 'bypass', 'count', bypass_count))
 
   def AddResultsForCorsBypass(self, tab, results):
     eligible_response_count = 0
     bypass_count = 0
     bypasses = {}
     for resp in self.IterResponses(tab):
       logging.warn('got a resource %s' % (resp.response.url))
 
@@ skipping 17 matching lines @@
         raise ChromeProxyMetricException, (
               '%s: Got a 502 without a subsequent 200' % (url))
       elif bypasses[url] > 1:
         raise ChromeProxyMetricException, (
               '%s: Got a 502 and multiple 200s: %d' % (url, bypasses[url]))
     if bypass_count == 0:
       raise ChromeProxyMetricException, (
           'At least one response should be bypassed. '
           '(eligible_response_count=%d, bypass_count=%d)\n' % (
               eligible_response_count, bypass_count))
-    if tab:
-      info = GetProxyInfoFromNetworkInternals(tab)
-      if not info['enabled']:
-        raise ChromeProxyMetricException, (
-            'Chrome proxy should be enabled. proxy info: %s' % info)
-      _, expected_bad_proxies = self.IsProxyBypassed(tab)
-      self.VerifyBadProxies(info['badProxies'], expected_bad_proxies)
 
+    self.VerifyAllProxiesBypassed(tab)
     results.AddValue(scalar.ScalarValue(
         results.current_page, 'cors_bypass', 'count', bypass_count))
 
   def AddResultsForBlockOnce(self, tab, results):
     eligible_response_count = 0
     bypass_count = 0
     for resp in self.IterResponses(tab):
       if resp.ShouldHaveChromeProxyViaHeader():
         eligible_response_count += 1
         if not resp.HasChromeProxyViaHeader():
@@ skipping 37 matching lines @@
             'Reponse: status=(%d, %s)\nHeaders:\n %s' % (
                 r.url, r.status, r.status_text, r.headers))
     if count == safebrowsing_count:
       results.AddValue(scalar.ScalarValue(
           results.current_page, 'safebrowsing', 'boolean', True))
     else:
       raise ChromeProxyMetricException, (
           'Safebrowsing failed (count=%d, safebrowsing_count=%d)\n' % (
               count, safebrowsing_count))
 
-  def AddResultsForHTTPFallback(
-      self, tab, results, expected_proxies=None, expected_bad_proxies=None):
+  def VerifyProxyInfo(self, tab, expected_proxies, expected_bad_proxies):
     info = GetProxyInfoFromNetworkInternals(tab)
     if not 'enabled' in info or not info['enabled']:
       raise ChromeProxyMetricException, (
           'Chrome proxy should be enabled. proxy info: %s' % info)
 
-    if not expected_proxies:
-      expected_proxies = [self.effective_proxies['fallback'],
-                          self.effective_proxies['direct']]
-    if not expected_bad_proxies:
-      expected_bad_proxies = []
-
     proxies = info['proxies']
     if proxies != expected_proxies:
       raise ChromeProxyMetricException, (
           'Wrong effective proxies (%s). Expect: "%s"' % (
           str(proxies), str(expected_proxies)))
 
     bad_proxies = []
     if 'badProxies' in info and info['badProxies']:
       bad_proxies = [p['proxy'] for p in info['badProxies']
                      if 'proxy' in p and p['proxy']]
     if bad_proxies != expected_bad_proxies:
       raise ChromeProxyMetricException, (
           'Wrong bad proxies (%s). Expect: "%s"' % (
           str(bad_proxies), str(expected_bad_proxies)))
+
+  def AddResultsForHTTPFallback(
+      self, tab, results, expected_proxies=None, expected_bad_proxies=None):
+    if not expected_proxies:
+      expected_proxies = [self.effective_proxies['fallback'],
+                          self.effective_proxies['direct']]
+    if not expected_bad_proxies:
+      expected_bad_proxies = []
+
+    self.VerifyProxyInfo(tab, expected_proxies, expected_bad_proxies)
     results.AddValue(scalar.ScalarValue(
         results.current_page, 'http_fallback', 'boolean', True))
+
+  def AddResultsForHTTPToDirectFallback(self, tab, results):
+    self.VerifyAllProxiesBypassed(tab)
+    results.AddValue(scalar.ScalarValue(
+        results.current_page, 'direct_fallback', 'boolean', True))