Merge page_measurement_unittest to page_test_unittest.

tools/telemetry/telemetry/page/page_test_unittest.py

Index: tools/telemetry/telemetry/page/page_test_unittest.py
diff --git a/tools/telemetry/telemetry/page/page_test_unittest.py b/tools/telemetry/telemetry/page/page_test_unittest.py
index 6b068bf04be4ef94ec94de96385471546001a1f6..65a852aa562758becb31ba394f67606ab1bc34b4 100644
--- a/tools/telemetry/telemetry/page/page_test_unittest.py
+++ b/tools/telemetry/telemetry/page/page_test_unittest.py
@@ -2,32 +2,167 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-import unittest
+import json
+import os
 
-from telemetry.core import util
+from telemetry import benchmark
+from telemetry.core import exceptions
+from telemetry.core import wpr_modes
 from telemetry.page import page as page_module
+from telemetry.page import page_set
+from telemetry.page import page_set_archive_info
 from telemetry.page import page_test
+from telemetry.testing import page_test_test_case
+from telemetry.unittest import options_for_unittests
+from telemetry.value import scalar
 
 
-class DoNothingPageTest(page_test.PageTest):
-  def ValidateAndMeasurePage(self, *_):
+class PageTestThatFails(page_test.PageTest):
+  def MeasurePage(self, page, tab, results):
+    raise exceptions.IntentionalException
+
+
+class PageTestThatHasDefaults(page_test.PageTest):
+  def AddCommandLineArgs(self, parser):
+    parser.add_option('-x', dest='x', default=3)
+
+  def MeasurePage(self, page, tab, results):
+    if not hasattr(self.options, 'x'):
+      raise page_test.MeasurementFailure('Default option was not set.')
+    if self.options.x != 3:
+      raise page_test.MeasurementFailure(
+          'Expected x == 3, got x == ' + self.options.x)
+    results.AddValue(scalar.ScalarValue(page, 'x', 'ms', 7))
+
+
+class PageTestForBlank(page_test.PageTest):
+  def MeasurePage(self, page, tab, results):
+    contents = tab.EvaluateJavaScript('document.body.textContent')
+    if contents.strip() != 'Hello world':
+      raise page_test.MeasurementFailure(
+          'Page contents were: ' + contents)
+
+
+class PageTestForReplay(page_test.PageTest):
+  def MeasurePage(self, page, tab, results):
+    # Web Page Replay returns '404 Not found' if a page is not in the archive.
+    contents = tab.EvaluateJavaScript('document.body.textContent')
+    if '404 Not Found' in contents.strip():
+      raise page_test.MeasurementFailure('Page not in archive.')
+
+
+class PageTestQueryParams(page_test.PageTest):
+  def MeasurePage(self, page, tab, results):
+    query = tab.EvaluateJavaScript('window.location.search')
+    expected = '?foo=1'
+    if query.strip() != expected:
+      raise page_test.MeasurementFailure(
+          'query was %s, not %s.' % (query, expected))
+
+
+class PageTestWithAction(page_test.PageTest):
+  def __init__(self):
+    super(PageTestWithAction, self).__init__('RunTestAction')
+
+  def MeasurePage(self, page, tab, results):
     pass
 
 
-class TestPage(page_module.Page):
-  def __init__(self, url, page_set, base_dir):
-    super(TestPage, self).__init__(url, page_set, base_dir)
-    self.run_action_to_run_called = False
+class PageWithAction(page_module.Page):
+  def __init__(self, url, ps):
+    super(PageWithAction, self).__init__(url, ps, ps.base_dir)
+    self.run_test_action_called = False
 
-  def RunActionToRun(self, _):
-    self.run_action_to_run_called = True
+  def RunTestAction(self, _):
+    self.run_test_action_called = True
 
 
-class PageTestUnitTest(unittest.TestCase):
-  def testRunActions(self):
-    test = DoNothingPageTest('RunActionToRun')
-    page = TestPage('file://blank.html', None, util.GetUnittestDataDir())
+class PageTestUnitTest(page_test_test_case.PageTestTestCase):
 
-    test.RunPage(page, None, None)
+  def setUp(self):
+    self._options = options_for_unittests.GetCopy()
+    self._options.browser_options.wpr_mode = wpr_modes.WPR_OFF
 
-    self.assertTrue(page.run_action_to_run_called)
+  def testGotToBlank(self):
+    ps = self.CreatePageSetFromFileInUnittestDataDir('blank.html')
+    measurement = PageTestForBlank()
+    all_results = self.RunMeasurement(measurement, ps, options=self._options)
+    self.assertEquals(0, len(all_results.failures))
+
+  def testGotQueryParams(self):
+    ps = self.CreatePageSetFromFileInUnittestDataDir('blank.html?foo=1')
+    measurement = PageTestQueryParams()
+    all_results = self.RunMeasurement(measurement, ps, options=self._options)
+    self.assertEquals(0, len(all_results.failures))
+
+  def testFailure(self):
+    ps = self.CreatePageSetFromFileInUnittestDataDir('blank.html')
+    measurement = PageTestThatFails()
+    all_results = self.RunMeasurement(measurement, ps, options=self._options)
+    self.assertEquals(1, len(all_results.failures))
+
+  def testDefaults(self):
+    ps = self.CreatePageSetFromFileInUnittestDataDir('blank.html')
+    measurement = PageTestThatHasDefaults()
+    all_results = self.RunMeasurement(measurement, ps, options=self._options)
+    self.assertEquals(len(all_results.all_page_specific_values), 1)
+    self.assertEquals(
+      all_results.all_page_specific_values[0].value, 7)
+
+  # This test is disabled because it runs against live sites, and needs to be
+  # fixed. crbug.com/179038
+  @benchmark.Disabled
+  def testRecordAndReplay(self):
+    test_archive = '/tmp/google.wpr'
+    google_url = 'http://www.google.com/'
+    foo_url = 'http://www.foo.com/'
+    archive_info_template = ("""
+{
+"archives": {
+  "%s": ["%s"]
+}
+}
+""")
+    try:
+      ps = page_set.PageSet()
+      measurement = PageTestForReplay()
+
+      # First record an archive with only www.google.com.
+      self._options.browser_options.wpr_mode = wpr_modes.WPR_RECORD
+
+      ps.wpr_archive_info = page_set_archive_info.PageSetArchiveInfo(
+          '', '', json.loads(archive_info_template %
+                             (test_archive, google_url)))
+      ps.pages = [page_module.Page(google_url, ps)]
+      all_results = self.RunMeasurement(measurement, ps, options=self._options)
+      self.assertEquals(0, len(all_results.failures))
+
+      # Now replay it and verify that google.com is found but foo.com is not.
+      self._options.browser_options.wpr_mode = wpr_modes.WPR_REPLAY
+
+      ps.wpr_archive_info = page_set_archive_info.PageSetArchiveInfo(
+          '', '', json.loads(archive_info_template % (test_archive, foo_url)))
+      ps.pages = [page_module.Page(foo_url, ps)]
+      all_results = self.RunMeasurement(measurement, ps, options=self._options)
+      self.assertEquals(1, len(all_results.failures))
+
+      ps.wpr_archive_info = page_set_archive_info.PageSetArchiveInfo(
+          '', '', json.loads(archive_info_template %
+                             (test_archive, google_url)))
+      ps.pages = [page_module.Page(google_url, ps)]
+      all_results = self.RunMeasurement(measurement, ps, options=self._options)
+      self.assertEquals(0, len(all_results.failures))
+
+      self.assertTrue(os.path.isfile(test_archive))
+
+    finally:
+      if os.path.isfile(test_archive):
+        os.remove(test_archive)
+
+  def testRunActions(self):
+    ps = self.CreateEmptyPageSet()
+    page = PageWithAction('file://blank.html', ps)
+    ps.AddPage(page)
+    measurement = PageTestWithAction()
+    self.RunMeasurement(measurement, ps, options=self._options)
+    self.assertTrue(page.run_test_action_called)