Update metrics verification for dev-proxy.

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
 from telemetry.value import scalar
 
 
 class ChromeProxyMetricException(page_test.MeasurementFailure):
   pass
 
 
 CHROME_PROXY_VIA_HEADER = 'Chrome-Compression-Proxy'
 CHROME_PROXY_VIA_HEADER_DEPRECATED = '1.1 Chrome Compression Proxy'
 
 PROXY_SETTING_HTTPS = 'proxy.googlezip.net:443'
 PROXY_SETTING_HTTPS_WITH_SCHEME = 'https://' + PROXY_SETTING_HTTPS
+PROXY_DEV_SETTING_HTTPS_WITH_SCHEME = 'http://proxy-dev.googlezip.net:80'
 PROXY_SETTING_HTTP = 'compress.googlezip.net:80'
 PROXY_SETTING_DIRECT = 'direct://'
 
 # The default Chrome Proxy bypass time is a range from one to five mintues.
 # See ProxyList::UpdateRetryInfoOnFallback in net/proxy/proxy_list.cc.
 DEFAULT_BYPASS_MIN_SECONDS = 60
 DEFAULT_BYPASS_MAX_SECONDS = 5 * 60
 
 def GetProxyInfoFromNetworkInternals(tab, url='chrome://net-internals#proxy'):
   tab.Navigate(url)
@@ skipping 57 matching lines @@
 
 
 class ChromeProxyMetric(network_metrics.NetworkMetric):
   """A Chrome proxy timeline metric."""
 
   def __init__(self):
     super(ChromeProxyMetric, self).__init__()
     self.compute_data_saving = True
     self.effective_proxies = {
         "proxy": PROXY_SETTING_HTTPS_WITH_SCHEME,
+        "proxy-dev": PROXY_DEV_SETTING_HTTPS_WITH_SCHEME,
         "fallback": PROXY_SETTING_HTTP,
         "direct": PROXY_SETTING_DIRECT,
         }
 
   def SetEvents(self, events):
     """Used for unittest."""
     self._events = events
 
   def ResponseFromEvent(self, event):
     return ChromeProxyResponse(event)
@@ skipping 23 matching lines @@
         resources_from_cache))
     results.AddValue(scalar.ScalarValue(
         results.current_page, 'resources_direct', 'count', resources_direct))
 
   def AddResultsForHeaderValidation(self, tab, results):
     via_count = 0
     bypass_count = 0
     for resp in self.IterResponses(tab):
       if resp.IsValidByViaHeader():
         via_count += 1
-      elif tab and self.IsProxyBypassed(tab):
-        logging.warning('Proxy bypassed for %s', resp.response.url)
-        bypass_count += 1
       else:
-        r = resp.response
-        raise ChromeProxyMetricException, (
-            '%s: Via header (%s) is not valid (refer=%s, status=%d)' % (
-                r.url, r.GetHeader('Via'), r.GetHeader('Referer'), r.status))
+        bypassed, _ = self.IsProxyBypassed(tab)
+        if tab and bypassed:
+          logging.warning('Proxy bypassed for %s', resp.response.url)
+          bypass_count += 1
+        else:
+          r = resp.response
+          raise ChromeProxyMetricException, (
+              '%s: Via header (%s) is not valid (refer=%s, status=%d)' % (
+                  r.url, r.GetHeader('Via'), r.GetHeader('Referer'), r.status))
     results.AddValue(scalar.ScalarValue(
         results.current_page, 'checked_via_header', 'count', via_count))
     results.AddValue(scalar.ScalarValue(
         results.current_page, 'request_bypassed', 'count', bypass_count))
 
   def IsProxyBypassed(self, tab):
     """ Returns True if all configured proxies are bypassed."""
     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']].sort()
+    bad_proxies = [str(p['proxy']) for p in info['badProxies']]
+    bad_proxies.sort()
     proxies = [self.effective_proxies['proxy'],
-               self.effective_proxies['fallback']].sort()
-    return bad_proxies == proxies
+               self.effective_proxies['fallback']]
+    proxies.sort()
+    proxies_dev = [self.effective_proxies['proxy-dev'],
+               self.effective_proxies['fallback']]

[bengr, 2014/09/09 19:11:49]

indentation is off.

[bolian, 2014/09/09 20:59:12]

Done.

+    proxies_dev.sort()
+    if bad_proxies == proxies:
+      return True, proxies
+    elif bad_proxies == proxies_dev:
+      return True, proxies_dev
+    return False, []
 
   @staticmethod
   def VerifyBadProxies(
       badProxies, expected_proxies,
       retry_seconds_low = DEFAULT_BYPASS_MIN_SECONDS,
       retry_seconds_high = DEFAULT_BYPASS_MAX_SECONDS):
     """Verify the bad proxy list and their retry times are expected. """
     if not badProxies or (len(badProxies) != len(expected_proxies)):
       return False
 
@@ skipping 29 matching lines @@
         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)
-      self.VerifyBadProxies(
-          info['badProxies'],
-          [self.effective_proxies['proxy'],
-           self.effective_proxies['fallback']])
+      _, expected_bad_proxies = self.IsProxyBypassed(tab)
+      self.VerifyBadProxies(info['badProxies'], expected_bad_proxies)
 
     results.AddValue(scalar.ScalarValue(
         results.current_page, 'bypass', 'count', bypass_count))
 
   def AddResultsForSafebrowsing(self, tab, results):
     count = 0
     safebrowsing_count = 0
     for resp in self.IterResponses(tab):
       count += 1
       if resp.IsSafebrowsingResponse():
@@ skipping 34 matching lines @@
     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)))
     results.AddValue(scalar.ScalarValue(
         results.current_page, 'http_fallback', 'boolean', True))