Fix unittests for Data Saver integration tests

tools/chrome_proxy/integration_tests/chrome_proxy_metrics_unittest.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 unittest
 
 from integration_tests import chrome_proxy_metrics as metrics
 from integration_tests import network_metrics_unittest as network_unittest
 from metrics import test_page_test_results
@@ skipping 28 matching lines @@
     url='http://test.html2',
     response_headers={
         'Content-Type': 'text/html',
         'Content-Encoding': 'gzip',
         'X-Original-Content-Length': str(len(network_unittest.HTML_BODY)),
         'Via': '1.1 ' + metrics.CHROME_PROXY_VIA_HEADER,
         },
     body=network_unittest.HTML_BODY,
     remote_port=80))
 
-# An HTML via proxy with the deprecated Via header.
-EVENT_HTML_PROXY_DEPRECATED_VIA = (
-    network_unittest.NetworkMetricTest.MakeNetworkTimelineEvent(
-    url='http://test.html2',
-    response_headers={
-        'Content-Type': 'text/html',
-        'Content-Encoding': 'gzip',
-        'X-Original-Content-Length': str(len(network_unittest.HTML_BODY)),
-        'Via': (metrics.CHROME_PROXY_VIA_HEADER_DEPRECATED +
-                ',other-via'),
-        },
-    body=network_unittest.HTML_BODY))
-
 # An image via proxy with Via header.
 EVENT_IMAGE_PROXY_VIA = (
     network_unittest.NetworkMetricTest.MakeNetworkTimelineEvent(
     url='http://test.image',
     response_headers={
         'Content-Type': 'image/jpeg',
         'Content-Encoding': 'gzip',
         'X-Original-Content-Length': str(network_unittest.IMAGE_OCL),
         'Via': '1.1 ' + metrics.CHROME_PROXY_VIA_HEADER,
         },
@@ skipping 44 matching lines @@
 EVENT_MALWARE_PROXY = (
     network_unittest.NetworkMetricTest.MakeNetworkTimelineEvent(
     url='http://test.malware',
     response_headers={
         'X-Malware-Url': '1',
         'Via': '1.1 ' + metrics.CHROME_PROXY_VIA_HEADER,
         'Location': 'http://test.malware',
         },
     status=307))
 
 # An HTML via proxy with the deprecated Via header.

[sclittle, 2015/02/06 20:44:38]

Remove the word "deprecated"

[bengr, 2015/02/06 20:55:14]

Done.

 EVENT_IMAGE_BYPASS = (
     network_unittest.NetworkMetricTest.MakeNetworkTimelineEvent(
     url='http://test.image',
     response_headers={
         'Chrome-Proxy': 'bypass=1',
         'Content-Type': 'text/html',
         'Via': '1.1 ' + metrics.CHROME_PROXY_VIA_HEADER,
         },
     status=502))
 
@@ skipping 47 matching lines @@
             body=base64.b64encode(network_unittest.IMAGE_BODY),
             base64_encoded_body=True))
     self.assertTrue(resp.ShouldHaveChromeProxyViaHeader())
     self.assertTrue(resp.HasChromeProxyViaHeader())
     self.assertTrue(resp.IsValidByViaHeader())
 
   def testChromeProxyMetricForDataSaving(self):
     metric = metrics.ChromeProxyMetric()
     events = [
         EVENT_HTML_DIRECT,
-        EVENT_HTML_PROXY_DEPRECATED_VIA,
+        EVENT_HTML_PROXY_VIA,
         EVENT_IMAGE_PROXY_CACHED,
         EVENT_IMAGE_DIRECT]
     metric.SetEvents(events)
 
     self.assertTrue(len(events), len(list(metric.IterResponses(None))))
     results = test_page_test_results.TestPageTestResults(self)
 
     metric.AddResultsForDataSaving(None, results)
     results.AssertHasPageSpecificScalarValue('resources_via_proxy', 'count', 2)
     results.AssertHasPageSpecificScalarValue('resources_from_cache', 'count', 1)
     results.AssertHasPageSpecificScalarValue('resources_direct', 'count', 2)
 
   def testChromeProxyMetricForHeaderValidation(self):
     metric = metrics.ChromeProxyMetric()
     metric.SetEvents([
         EVENT_HTML_DIRECT,
-        EVENT_HTML_PROXY_DEPRECATED_VIA,
+        EVENT_HTML_PROXY_VIA,
         EVENT_IMAGE_PROXY_CACHED,
         EVENT_IMAGE_DIRECT])
 
     results = test_page_test_results.TestPageTestResults(self)
 
     missing_via_exception = False
     try:
       metric.AddResultsForHeaderValidation(None, results)
     except metrics.ChromeProxyMetricException:
       missing_via_exception = True
     # Only the HTTP image response does not have a valid Via header.
     self.assertTrue(missing_via_exception)
 
     # Two events with valid Via headers.
     metric.SetEvents([
-        EVENT_HTML_PROXY_DEPRECATED_VIA,
+        EVENT_HTML_PROXY_VIA,
         EVENT_IMAGE_PROXY_CACHED])
     metric.AddResultsForHeaderValidation(None, results)
     results.AssertHasPageSpecificScalarValue('checked_via_header', 'count', 2)
 
   def testChromeProxyMetricForBypass(self):
     metric = metrics.ChromeProxyMetric()
     metric.SetEvents([
         EVENT_HTML_DIRECT,
-        EVENT_HTML_PROXY_DEPRECATED_VIA,
+        EVENT_HTML_PROXY_VIA,
         EVENT_IMAGE_PROXY_CACHED,
         EVENT_IMAGE_DIRECT])
     results = test_page_test_results.TestPageTestResults(self)
 
     bypass_exception = False
     try:
       metric.AddResultsForBypass(None, results)
     except metrics.ChromeProxyMetricException:
       bypass_exception = True
     # Two of the first three events have Via headers.
     self.assertTrue(bypass_exception)
 
     # Use directly fetched image only. It is treated as bypassed.
     metric.SetEvents([EVENT_IMAGE_DIRECT])
     metric.AddResultsForBypass(None, results)
     results.AssertHasPageSpecificScalarValue('bypass', 'count', 1)
 
   def testChromeProxyMetricForCorsBypass(self):
     metric = metrics.ChromeProxyMetric()
-    metric.SetEvents([EVENT_HTML_PROXY_DEPRECATED_VIA,
+    metric.SetEvents([EVENT_HTML_PROXY_VIA,
                       EVENT_IMAGE_BYPASS,
                       EVENT_IMAGE_DIRECT])
     results = test_page_test_results.TestPageTestResults(self)
     metric.AddResultsForCorsBypass(None, results)
     results.AssertHasPageSpecificScalarValue('cors_bypass', 'count', 1)
 
   def testChromeProxyMetricForBlockOnce(self):
     metric = metrics.ChromeProxyMetric()
     metric.SetEvents([EVENT_HTML_DIRECT,
                       EVENT_IMAGE_PROXY_VIA])
     results = test_page_test_results.TestPageTestResults(self)
     metric.AddResultsForBlockOnce(None, results)
     results.AssertHasPageSpecificScalarValue('eligible_responses', 'count', 2)
     results.AssertHasPageSpecificScalarValue('bypass', 'count', 1)
 
     metric.SetEvents([EVENT_HTML_DIRECT,
                       EVENT_IMAGE_DIRECT])
     exception_occurred = False
     try:
       metric.AddResultsForBlockOnce(None, results)
     except metrics.ChromeProxyMetricException:
       exception_occurred = True
     # The second response was over direct, but was expected via proxy.
     self.assertTrue(exception_occurred)
 
-  def testChromeProxyMetricForSafebrowsing(self):
+  def testChromeProxyMetricForSafebrowsingOn(self):
     metric = metrics.ChromeProxyMetric()
     metric.SetEvents([EVENT_MALWARE_PROXY])
     results = test_page_test_results.TestPageTestResults(self)
 
-    metric.AddResultsForSafebrowsing(None, results)
-    results.AssertHasPageSpecificScalarValue('safebrowsing', 'boolean', True)
+    metric.AddResultsForSafebrowsingOn(None, results)
+    results.AssertHasPageSpecificScalarValue(
+        'safebrowsing', 'timeout responses', 1)
 
     # Clear results and metrics to test no response for safebrowsing
     results = test_page_test_results.TestPageTestResults(self)
     metric.SetEvents([])
-    metric.AddResultsForSafebrowsing(None, results)
-    results.AssertHasPageSpecificScalarValue('safebrowsing', 'boolean', True)
+    metric.AddResultsForSafebrowsingOn(None, results)
+    results.AssertHasPageSpecificScalarValue(
+        'safebrowsing', 'timeout responses', 1)
 
   def testChromeProxyMetricForHTTPFallback(self):
     metric = metrics.ChromeProxyMetric()
     metric.SetEvents([EVENT_HTML_PROXY_VIA_HTTP_FALLBACK,
                       EVENT_IMAGE_PROXY_VIA_HTTP_FALLBACK])
     results = test_page_test_results.TestPageTestResults(self)
     metric.AddResultsForHTTPFallback(None, results)
     results.AssertHasPageSpecificScalarValue('via_fallback', 'count', 2)
 
     metric.SetEvents([EVENT_HTML_PROXY_VIA,
                        EVENT_IMAGE_PROXY_VIA])
     exception_occurred = False
     try:
       metric.AddResultsForHTTPFallback(None, results)
     except metrics.ChromeProxyMetricException:
       exception_occurred = True
     # The responses came through the SPDY proxy, but were expected through the
     # HTTP fallback proxy.
     self.assertTrue(exception_occurred)
 
   def testChromeProxyMetricForHTTPToDirectFallback(self):
     metric = metrics.ChromeProxyMetric()
     metric.SetEvents([EVENT_HTML_PROXY_VIA_HTTP_FALLBACK,
                       EVENT_HTML_DIRECT,
                       EVENT_IMAGE_DIRECT])
     results = test_page_test_results.TestPageTestResults(self)
-    metric.AddResultsForHTTPToDirectFallback(None, results)
+    metric.AddResultsForHTTPToDirectFallback(None, results, 'test.html2')
     results.AssertHasPageSpecificScalarValue('via_fallback', 'count', 1)
     results.AssertHasPageSpecificScalarValue('bypass', 'count', 2)
 
     metric.SetEvents([EVENT_HTML_PROXY_VIA,
                        EVENT_HTML_DIRECT])
     exception_occurred = False
     try:
-      metric.AddResultsForHTTPToDirectFallback(None, results)
+      metric.AddResultsForHTTPToDirectFallback(None, results, 'test.html2')
     except metrics.ChromeProxyMetricException:
       exception_occurred = True
     # The first response was expected through the HTTP fallback proxy.
     self.assertTrue(exception_occurred)
 
     metric.SetEvents([EVENT_HTML_PROXY_VIA_HTTP_FALLBACK,
                        EVENT_HTML_PROXY_VIA_HTTP_FALLBACK,
                        EVENT_IMAGE_PROXY_VIA_HTTP_FALLBACK])
     exception_occurred = False
     try:
-      metric.AddResultsForHTTPToDirectFallback(None, results)
+      metric.AddResultsForHTTPToDirectFallback(None, results, 'test.html2')
     except metrics.ChromeProxyMetricException:
       exception_occurred = True
     # All but the first response were expected to be over direct.
     self.assertTrue(exception_occurred)
 
     metric.SetEvents([EVENT_HTML_DIRECT,
                        EVENT_HTML_DIRECT,
                        EVENT_IMAGE_DIRECT])
     exception_occurred = False
     try:
-      metric.AddResultsForHTTPToDirectFallback(None, results)
+      metric.AddResultsForHTTPToDirectFallback(None, results, 'test.html2')
     except metrics.ChromeProxyMetricException:
       exception_occurred = True
     # The first response was expected through the HTTP fallback proxy.
     self.assertTrue(exception_occurred)