tools/chrome_proxy/integration_tests/chrome_proxy_measurements.py

   1 # Copyright 2014 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 import base64
   6 import logging
   7 import urlparse
   8
   9 from common.chrome_proxy_measurements import ChromeProxyValidation
  10 from integration_tests import chrome_proxy_metrics as metrics
  11 from metrics import loading
  12 from telemetry.core import exceptions
  13 from telemetry.page import page_test
  14
  15 class ChromeProxyLatency(page_test.PageTest):
  16   """Chrome proxy latency measurement."""
  17
  18   def __init__(self, *args, **kwargs):
  19     super(ChromeProxyLatency, self).__init__(*args, **kwargs)
  20     self._metrics = metrics.ChromeProxyMetric()
  21
  22   def CustomizeBrowserOptions(self, options):
  23     options.AppendExtraBrowserArgs('--enable-spdy-proxy-auth')
  24
  25   def WillNavigateToPage(self, page, tab):
  26     tab.ClearCache(force=True)
  27
  28   def ValidateAndMeasurePage(self, page, tab, results):
  29     # Wait for the load event.
  30     tab.WaitForJavaScriptExpression('performance.timing.loadEventStart', 300)
  31     self._metrics.AddResultsForLatency(tab, results)
  32
  33
  34 class ChromeProxyDataSaving(page_test.PageTest):
  35   """Chrome proxy data saving measurement."""
  36   def __init__(self, *args, **kwargs):
  37     super(ChromeProxyDataSaving, self).__init__(*args, **kwargs)
  38     self._metrics = metrics.ChromeProxyMetric()
  39
  40   def CustomizeBrowserOptions(self, options):
  41     options.AppendExtraBrowserArgs('--enable-spdy-proxy-auth')
  42
  43   def WillNavigateToPage(self, page, tab):
  44     tab.ClearCache(force=True)
  45     self._metrics.Start(page, tab)
  46
  47   def ValidateAndMeasurePage(self, page, tab, results):
  48     # Wait for the load event.
  49     tab.WaitForJavaScriptExpression('performance.timing.loadEventStart', 300)
  50     self._metrics.Stop(page, tab)
  51     self._metrics.AddResultsForDataSaving(tab, results)
  52
  53
  54 class ChromeProxyHeaders(ChromeProxyValidation):
  55   """Correctness measurement for response headers."""
  56
  57   def __init__(self):
  58     super(ChromeProxyHeaders, self).__init__(
  59         restart_after_each_page=True,
  60         metrics=metrics.ChromeProxyMetric())
  61
  62   def AddResults(self, tab, results):
  63     self._metrics.AddResultsForHeaderValidation(tab, results)
  64
  65
  66 class ChromeProxyBypass(ChromeProxyValidation):
  67   """Correctness measurement for bypass responses."""
  68
  69   def __init__(self):
  70     super(ChromeProxyBypass, self).__init__(
  71         restart_after_each_page=True,
  72         metrics=metrics.ChromeProxyMetric())
  73
  74   def AddResults(self, tab, results):
  75     self._metrics.AddResultsForBypass(tab, results)
  76
  77
  78 class ChromeProxyCorsBypass(ChromeProxyValidation):
  79   """Correctness measurement for bypass responses for CORS requests."""
  80
  81   def __init__(self):
  82     super(ChromeProxyCorsBypass, self).__init__(
  83         restart_after_each_page=True,
  84         metrics=metrics.ChromeProxyMetric())
  85
  86   def ValidateAndMeasurePage(self, page, tab, results):
  87     # The test page sets window.xhrRequestCompleted to true when the XHR fetch
  88     # finishes.
  89     tab.WaitForJavaScriptExpression('window.xhrRequestCompleted', 300)
  90     super(ChromeProxyCorsBypass,
  91           self).ValidateAndMeasurePage(page, tab, results)
  92
  93   def AddResults(self, tab, results):
  94     self._metrics.AddResultsForCorsBypass(tab, results)
  95
  96
  97 class ChromeProxyBlockOnce(ChromeProxyValidation):
  98   """Correctness measurement for block-once responses."""
  99
 100   def __init__(self):
 101     super(ChromeProxyBlockOnce, self).__init__(
 102         restart_after_each_page=True,
 103         metrics=metrics.ChromeProxyMetric())
 104
 105   def AddResults(self, tab, results):
 106     self._metrics.AddResultsForBlockOnce(tab, results)
 107
 108
 109 class ChromeProxySafebrowsingOn(ChromeProxyValidation):
 110   """Correctness measurement for safebrowsing."""
 111
 112   def __init__(self):
 113     super(ChromeProxySafebrowsingOn, self).__init__(
 114         metrics=metrics.ChromeProxyMetric())
 115
 116   def WillNavigateToPage(self, page, tab):
 117     super(ChromeProxySafebrowsingOn, self).WillNavigateToPage(page, tab)
 118     self._expect_timeout = True
 119
 120   def AddResults(self, tab, results):
 121     self._metrics.AddResultsForSafebrowsingOn(tab, results)
 122
 123 class ChromeProxySafebrowsingOff(ChromeProxyValidation):
 124   """Correctness measurement for safebrowsing."""
 125
 126   def __init__(self):
 127     super(ChromeProxySafebrowsingOff, self).__init__(
 128         metrics=metrics.ChromeProxyMetric())
 129
 130   def AddResults(self, tab, results):
 131     self._metrics.AddResultsForSafebrowsingOff(tab, results)
 132
 133 _FAKE_PROXY_AUTH_VALUE = 'aabbccdd3b7579186c1b0620614fdb1f0000ffff'
 134 _TEST_SERVER = 'chromeproxy-test.appspot.com'
 135 _TEST_SERVER_DEFAULT_URL = 'http://' + _TEST_SERVER + '/default'
 136
 137
 138 # We rely on the chromeproxy-test server to facilitate some of the tests.
 139 # The test server code is at <TBD location> and runs at _TEST_SERVER
 140 #
 141 # The test server allow request to override response status, headers, and
 142 # body through query parameters. See GetResponseOverrideURL.
 143 def GetResponseOverrideURL(url=_TEST_SERVER_DEFAULT_URL, respStatus=0,
 144                            respHeader="", respBody=""):
 145   """ Compose the request URL with query parameters to override
 146   the chromeproxy-test server response.
 147   """
 148
 149   queries = []
 150   if respStatus > 0:
 151     queries.append('respStatus=%d' % respStatus)
 152   if respHeader:
 153     queries.append('respHeader=%s' % base64.b64encode(respHeader))
 154   if respBody:
 155     queries.append('respBody=%s' % base64.b64encode(respBody))
 156   if len(queries) == 0:
 157     return url
 158   "&".join(queries)
 159   # url has query already
 160   if urlparse.urlparse(url).query:
 161     return url + '&' + "&".join(queries)
 162   else:
 163     return url + '?' + "&".join(queries)
 164
 165
 166 class ChromeProxyHTTPFallbackProbeURL(ChromeProxyValidation):
 167   """Correctness measurement for proxy fallback.
 168
 169   In this test, the probe URL does not return 'OK'. Chrome is expected
 170   to use the fallback proxy.
 171   """
 172
 173   def __init__(self):
 174     super(ChromeProxyHTTPFallbackProbeURL, self).__init__(
 175         restart_after_each_page=True,
 176         metrics=metrics.ChromeProxyMetric())
 177
 178   def CustomizeBrowserOptions(self, options):
 179     super(ChromeProxyHTTPFallbackProbeURL,
 180           self).CustomizeBrowserOptions(options)
 181     # Set the secure proxy check URL to the google.com favicon, which will be
 182     # interpreted as a secure proxy check failure since the response body is not
 183     # "OK". The google.com favicon is used because it will load reliably fast,
 184     # and there have been problems with chromeproxy-test.appspot.com being slow
 185     # and causing tests to flake.
 186     options.AppendExtraBrowserArgs(
 187         '--data-reduction-proxy-secure-proxy-check-url='
 188         'http://www.google.com/favicon.ico')
 189
 190   def AddResults(self, tab, results):
 191     self._metrics.AddResultsForHTTPFallback(tab, results)
 192
 193
 194 class ChromeProxyHTTPFallbackViaHeader(ChromeProxyValidation):
 195   """Correctness measurement for proxy fallback.
 196
 197   In this test, the configured proxy is the chromeproxy-test server which
 198   will send back a response without the expected Via header. Chrome is
 199   expected to use the fallback proxy and add the configured proxy to the
 200   bad proxy list.
 201   """
 202
 203   def __init__(self):
 204     super(ChromeProxyHTTPFallbackViaHeader, self).__init__(
 205         restart_after_each_page=True,
 206         metrics=metrics.ChromeProxyMetric())
 207
 208   def CustomizeBrowserOptions(self, options):
 209     super(ChromeProxyHTTPFallbackViaHeader,
 210           self).CustomizeBrowserOptions(options)
 211     options.AppendExtraBrowserArgs('--ignore-certificate-errors')
 212     options.AppendExtraBrowserArgs(
 213         '--spdy-proxy-auth-origin=http://%s' % _TEST_SERVER)
 214
 215   def AddResults(self, tab, results):
 216     self._metrics.AddResultsForHTTPFallback(tab, results)
 217
 218
 219 class ChromeProxyClientVersion(ChromeProxyValidation):
 220   """Correctness measurement for version directives in Chrome-Proxy header.
 221
 222   The test verifies that the version information provided in the Chrome-Proxy
 223   request header overrides any version, if specified, that is provided in the
 224   user agent string.
 225   """
 226
 227   def __init__(self):
 228     super(ChromeProxyClientVersion, self).__init__(
 229         metrics=metrics.ChromeProxyMetric())
 230
 231   def CustomizeBrowserOptions(self, options):
 232     super(ChromeProxyClientVersion,
 233           self).CustomizeBrowserOptions(options)
 234     options.AppendExtraBrowserArgs('--user-agent="Chrome/32.0.1700.99"')
 235
 236   def AddResults(self, tab, results):
 237     self._metrics.AddResultsForClientVersion(tab, results)
 238
 239
 240 class ChromeProxyClientType(ChromeProxyValidation):
 241   """Correctness measurement for Chrome-Proxy header client type directives."""
 242
 243   def __init__(self):
 244     super(ChromeProxyClientType, self).__init__(
 245         restart_after_each_page=True,
 246         metrics=metrics.ChromeProxyMetric())
 247     self._chrome_proxy_client_type = None
 248
 249   def AddResults(self, tab, results):
 250     # Get the Chrome-Proxy client type from the first page in the page set, so
 251     # that the client type value can be used to determine which of the later
 252     # pages in the page set should be bypassed.
 253     if not self._chrome_proxy_client_type:
 254       client_type = self._metrics.GetClientTypeFromRequests(tab)
 255       if client_type:
 256         self._chrome_proxy_client_type = client_type
 257
 258     self._metrics.AddResultsForClientType(tab,
 259                                           results,
 260                                           self._chrome_proxy_client_type,
 261                                           self._page.bypass_for_client_type)
 262
 263
 264 class ChromeProxyLoFi(ChromeProxyValidation):
 265   """Correctness measurement for Lo-Fi in Chrome-Proxy header."""
 266
 267   def __init__(self):
 268     super(ChromeProxyLoFi, self).__init__(restart_after_each_page=True,
 269                                           metrics=metrics.ChromeProxyMetric())
 270
 271   def CustomizeBrowserOptions(self, options):
 272     super(ChromeProxyLoFi, self).CustomizeBrowserOptions(options)
 273     options.AppendExtraBrowserArgs('--enable-data-reduction-proxy-lo-fi')
 274
 275   def AddResults(self, tab, results):
 276     self._metrics.AddResultsForLoFi(tab, results)
 277
 278 class ChromeProxyExpDirective(ChromeProxyValidation):
 279   """Correctness measurement for experiment directives in Chrome-Proxy header.
 280
 281   This test verifies that "exp=test" in the Chrome-Proxy request header
 282   causes a bypass on the experiment test page.
 283   """
 284
 285   def __init__(self):
 286     super(ChromeProxyExpDirective, self).__init__(
 287         restart_after_each_page=True,
 288         metrics=metrics.ChromeProxyMetric())
 289
 290   def CustomizeBrowserOptions(self, options):
 291     super(ChromeProxyExpDirective, self).CustomizeBrowserOptions(options)
 292     options.AppendExtraBrowserArgs('--data-reduction-proxy-experiment=test')
 293
 294   def AddResults(self, tab, results):
 295     self._metrics.AddResultsForBypass(tab, results)
 296
 297
 298 class ChromeProxyHTTPToDirectFallback(ChromeProxyValidation):
 299   """Correctness measurement for HTTP proxy fallback to direct."""
 300
 301   def __init__(self):
 302     super(ChromeProxyHTTPToDirectFallback, self).__init__(
 303         restart_after_each_page=True,
 304         metrics=metrics.ChromeProxyMetric())
 305
 306   def CustomizeBrowserOptions(self, options):
 307     super(ChromeProxyHTTPToDirectFallback,
 308           self).CustomizeBrowserOptions(options)
 309     # Set the primary proxy to something that will fail to be resolved so that
 310     # this test will run using the HTTP fallback proxy.
 311     options.AppendExtraBrowserArgs(
 312         '--spdy-proxy-auth-origin=http://nonexistent.googlezip.net')
 313
 314   def WillNavigateToPage(self, page, tab):
 315     super(ChromeProxyHTTPToDirectFallback, self).WillNavigateToPage(page, tab)
 316     # Attempt to load a page through the nonexistent primary proxy in order to
 317     # cause a proxy fallback, and have this test run starting from the HTTP
 318     # fallback proxy.
 319     tab.Navigate(_TEST_SERVER_DEFAULT_URL)
 320     tab.WaitForJavaScriptExpression('performance.timing.loadEventStart', 300)
 321
 322   def AddResults(self, tab, results):
 323     self._metrics.AddResultsForHTTPToDirectFallback(tab, results, _TEST_SERVER)
 324
 325
 326 class ChromeProxyReenableAfterBypass(ChromeProxyValidation):
 327   """Correctness measurement for re-enabling proxies after bypasses.
 328
 329   This test loads a page that causes all data reduction proxies to be bypassed
 330   for 1 to 5 minutes, then waits 5 minutes and verifies that the proxy is no
 331   longer bypassed.
 332   """
 333
 334   def __init__(self):
 335     super(ChromeProxyReenableAfterBypass, self).__init__(
 336         restart_after_each_page=True,
 337         metrics=metrics.ChromeProxyMetric())
 338
 339   def AddResults(self, tab, results):
 340     self._metrics.AddResultsForReenableAfterBypass(
 341         tab, results, self._page.bypass_seconds_min,
 342         self._page.bypass_seconds_max)
 343
 344
 345 class ChromeProxySmoke(ChromeProxyValidation):
 346   """Smoke measurement for basic chrome proxy correctness."""
 347
 348   def __init__(self):
 349     super(ChromeProxySmoke, self).__init__(restart_after_each_page=True,
 350                                            metrics=metrics.ChromeProxyMetric())
 351
 352   def WillNavigateToPage(self, page, tab):
 353     super(ChromeProxySmoke, self).WillNavigateToPage(page, tab)
 354
 355   def AddResults(self, tab, results):
 356     # Map a page name to its AddResults func.
 357     page_to_metrics = {
 358         'header validation': [self._metrics.AddResultsForHeaderValidation],
 359         'compression: image': [
 360             self._metrics.AddResultsForHeaderValidation,
 361             self._metrics.AddResultsForDataSaving,
 362             ],
 363         'compression: javascript': [
 364             self._metrics.AddResultsForHeaderValidation,
 365             self._metrics.AddResultsForDataSaving,
 366             ],
 367         'compression: css': [
 368             self._metrics.AddResultsForHeaderValidation,
 369             self._metrics.AddResultsForDataSaving,
 370             ],
 371         'bypass': [self._metrics.AddResultsForBypass],
 372         }
 373     if not self._page.name in page_to_metrics:
 374       raise page_test.MeasurementFailure(
 375           'Invalid page name (%s) in smoke. Page name must be one of:\n%s' % (
 376           self._page.name, page_to_metrics.keys()))
 377     for add_result in page_to_metrics[self._page.name]:
 378       add_result(tab, results)