[tools/perf] Migrate clients to LegacyPageTestCase

This new class makes it easier to write tests for LegacyPageTest
implementations, and is compatible with the add hoc measurements that
they normally write.

Depends on catapult CL:
https://chromium-review.googlesource.com/c/catapult/+/1862517

Bug: 999484
Change-Id: I13c64fdf7cb7181ac34306a124868d408bc99742
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1863292Reviewed-by: Ravi Mistry <rmistry@chromium.org>
Reviewed-by: Caleb Rouleau <crouleau@chromium.org>
Commit-Queue: Juan Antonio Navarro Pérez <perezju@chromium.org>
Cr-Commit-Position: refs/heads/master@{#706470}

tools/perf/contrib/cluster_telemetry/screenshot_unittest.py

@@ -3,41 +3,27 @@
 # found in the LICENSE file.
 
 import os
-import shutil
-import tempfile
 
 from telemetry import decorators
-from telemetry.testing import options_for_unittests
-from telemetry.testing import page_test_test_case
+from telemetry.testing import legacy_page_test_case
 from telemetry.util import image_util
 from contrib.cluster_telemetry import screenshot
 
-class ScreenshotUnitTest(page_test_test_case.PageTestTestCase):
-
-  def setUp(self):
-    self._png_outdir = tempfile.mkdtemp('_png_test')
-    self._options = options_for_unittests.GetRunOptions(
-        output_dir=self._png_outdir)
-
-  def tearDown(self):
-    shutil.rmtree(self._png_outdir)
 
+class ScreenshotUnitTest(legacy_page_test_case.LegacyPageTestCase):
   @decorators.Enabled('linux')
   def testScreenshot(self):
     # Screenshots for Cluster Telemetry purposes currently only supported on
     # Linux platform.
-    story_set = self.CreateStorySetFromFileInUnittestDataDir(
-      'screenshot_test.html')
-    measurement = screenshot.Screenshot(self._png_outdir)
-    self.RunMeasurement(measurement, story_set, run_options=self._options)
+    screenshot_test = screenshot.Screenshot(self.options.output_dir)
+    self.RunPageTest(screenshot_test, 'file://screenshot_test.html')
 
-    path = os.path.join(
-        self._png_outdir, story_set.stories[0].file_safe_name + '.png')
-    self.assertTrue(os.path.exists(path))
-    self.assertTrue(os.path.isfile(path))
-    self.assertTrue(os.access(path, os.R_OK))
+    filepath = os.path.join(self.options.output_dir, 'screenshot_test.png')
+    self.assertTrue(os.path.exists(filepath))
+    self.assertTrue(os.path.isfile(filepath))
+    self.assertTrue(os.access(filepath, os.R_OK))
 
-    image = image_util.FromPngFile(path)
+    image = image_util.FromPngFile(filepath)
     screenshot_pixels = image_util.Pixels(image)
     special_colored_pixel = bytearray([217, 115, 43])
     self.assertTrue(special_colored_pixel in screenshot_pixels)

tools/perf/measurements/multipage_skpicture_printer_unittest.py

@@ -2,30 +2,17 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-import shutil
-import tempfile
-
 from telemetry import decorators
-from telemetry.testing import options_for_unittests
-from telemetry.testing import page_test_test_case
+from telemetry.testing import legacy_page_test_case
 
 from measurements import multipage_skpicture_printer
 
 
-class MultipageSkpicturePrinterUnitTest(page_test_test_case.PageTestTestCase):
-
-  def setUp(self):
-    self._mskp_outdir = tempfile.mkdtemp('_mskp_test')
-    self._options = options_for_unittests.GetRunOptions(
-        output_dir=self._mskp_outdir)
-
-  def tearDown(self):
-    shutil.rmtree(self._mskp_outdir)
-
+class MultipageSkpicturePrinterUnitTest(
+    legacy_page_test_case.LegacyPageTestCase):
   # Picture printing is not supported on all platforms.
   @decorators.Disabled('android', 'chromeos')
   def testSkpicturePrinter(self):
-    story_set = self.CreateStorySetFromFileInUnittestDataDir('blank.html')
-    measurement = multipage_skpicture_printer.MultipageSkpicturePrinter(
-        self._mskp_outdir)
-    self.RunMeasurement(measurement, story_set, run_options=self._options)
+    page_test = multipage_skpicture_printer.MultipageSkpicturePrinter(
+        self.options.output_dir)
+    self.RunPageTest(page_test, 'file://blank.html')

tools/perf/measurements/rasterize_and_record_micro_unittest.py

@@ -2,20 +2,13 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-import logging
-import shutil
-import tempfile
-
 from telemetry import decorators
-from telemetry.page import legacy_page_test
-from telemetry.testing import options_for_unittests
-from telemetry.testing import page_test_test_case
-from telemetry.util import wpr_modes
+from telemetry.testing import legacy_page_test_case
 
 from measurements import rasterize_and_record_micro
 
 
-class RasterizeAndRecordMicroUnitTest(page_test_test_case.PageTestTestCase):
+class RasterizeAndRecordMicroUnitTest(legacy_page_test_case.LegacyPageTestCase):
   """Smoke test for rasterize_and_record_micro measurement
 
      Runs rasterize_and_record_micro measurement on a simple page and verifies
@@ -23,92 +16,33 @@ class RasterizeAndRecordMicroUnitTest(page_test_test_case.PageTestTestCase):
      i.e. it only checks if the metrics are present and non-zero.
   """
 
-  def setUp(self):
-    self._options = options_for_unittests.GetRunOptions(
-        output_dir=tempfile.mkdtemp())
-    self._options.browser_options.wpr_mode = wpr_modes.WPR_OFF
-
-  def tearDown(self):
-    shutil.rmtree(self._options.output_dir)
-
   @decorators.Disabled('win', 'chromeos', 'linux')
   def testRasterizeAndRecordMicro(self):
-    story_set = self.CreateStorySetFromFileInUnittestDataDir('blank.html')
-    measurement = rasterize_and_record_micro.RasterizeAndRecordMicro(
+    pate_test = rasterize_and_record_micro.RasterizeAndRecordMicro(
         rasterize_repeat=1, record_repeat=1, start_wait_time=0.0,
         report_detailed_results=True)
-    try:
-      results = self.RunMeasurement(
-          measurement, story_set, run_options=self._options)
-    except legacy_page_test.TestNotSupportedOnPlatformError as failure:
-      logging.warning(str(failure))
-      return
-    self.assertFalse(results.had_failures)
-
-    rasterize_time = results.FindAllPageSpecificValuesNamed('rasterize_time')
-    self.assertEquals(len(rasterize_time), 1)
-    self.assertGreater(rasterize_time[0].value, 0)
-
-    record_time = results.FindAllPageSpecificValuesNamed('record_time')
-    self.assertEquals(len(record_time), 1)
-    self.assertGreater(record_time[0].value, 0)
-
-    rasterized_pixels = results.FindAllPageSpecificValuesNamed(
-        'pixels_rasterized')
-    self.assertEquals(len(rasterized_pixels), 1)
-    self.assertGreater(rasterized_pixels[0].value, 0)
-
-    recorded_pixels = results.FindAllPageSpecificValuesNamed('pixels_recorded')
-    self.assertEquals(len(recorded_pixels), 1)
-    self.assertGreater(recorded_pixels[0].value, 0)
-
-    pixels_rasterized_with_non_solid_color = \
-        results.FindAllPageSpecificValuesNamed(
-            'pixels_rasterized_with_non_solid_color')
-    self.assertEquals(len(pixels_rasterized_with_non_solid_color), 1)
-    self.assertGreater(
-        pixels_rasterized_with_non_solid_color[0].value, 0)
-
-    pixels_rasterized_as_opaque = \
-        results.FindAllPageSpecificValuesNamed('pixels_rasterized_as_opaque')
-    self.assertEquals(len(pixels_rasterized_as_opaque), 1)
-    self.assertGreater(
-        pixels_rasterized_as_opaque[0].value, 0)
-
-    total_layers = results.FindAllPageSpecificValuesNamed('total_layers')
-    self.assertEquals(len(total_layers), 1)
-    self.assertGreater(total_layers[0].value, 0)
-
-    total_picture_layers = \
-        results.FindAllPageSpecificValuesNamed('total_picture_layers')
-    self.assertEquals(len(total_picture_layers), 1)
-    self.assertGreater(total_picture_layers[0].value, 0)
-
-    total_picture_layers_with_no_content = \
-        results.FindAllPageSpecificValuesNamed(
-            'total_picture_layers_with_no_content')
-    self.assertEquals(len(total_picture_layers_with_no_content), 1)
-    self.assertGreater(
-        total_picture_layers_with_no_content[0].value, 0)
-
-    total_picture_layers_off_screen = \
-        results.FindAllPageSpecificValuesNamed(
-            'total_picture_layers_off_screen')
-    self.assertEquals(len(total_picture_layers_off_screen), 1)
-    self.assertEqual(
-        total_picture_layers_off_screen[0].value, 0)
-
-    painter_memory_usage = results.FindAllPageSpecificValuesNamed(
-        'painter_memory_usage')
-    self.assertEquals(len(painter_memory_usage), 1)
-    self.assertGreater(painter_memory_usage[0].value, 0)
-
-    paint_op_memory_usage = results.FindAllPageSpecificValuesNamed(
-        'paint_op_memory_usage')
-    self.assertEquals(len(paint_op_memory_usage), 1)
-    self.assertGreater(paint_op_memory_usage[0].value, 0)
-
-    paint_op_count = results.FindAllPageSpecificValuesNamed(
-        'paint_op_count')
-    self.assertEquals(len(paint_op_count), 1)
-    self.assertGreater(paint_op_count[0].value, 0)
+    measurements = self.RunPageTest(pate_test, 'file://blank.html')
+
+    # For these measurements, a single positive scalar value is expected.
+    expected_positve_scalar = [
+        'rasterize_time',
+        'record_time',
+        'pixels_rasterized',
+        'pixels_recorded',
+        'pixels_rasterized_with_non_solid_color',
+        'pixels_rasterized_as_opaque',
+        'total_layers',
+        'total_picture_layers',
+        'total_picture_layers_with_no_content',
+        'painter_memory_usage',
+        'paint_op_memory_usage',
+        'paint_op_count',
+    ]
+    for name in expected_positve_scalar:
+      samples = measurements[name]['samples']
+      self.assertEqual(len(samples), 1)
+      self.assertGreater(samples[0], 0)
+
+    samples = measurements['total_picture_layers_off_screen']['samples']
+    self.assertEqual(len(samples), 1)
+    self.assertEqual(samples[0], 0)

tools/perf/measurements/skpicture_printer_unittest.py

@@ -2,35 +2,18 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-import shutil
-import tempfile
-
 from telemetry import decorators
-from telemetry.testing import options_for_unittests
-from telemetry.testing import page_test_test_case
+from telemetry.testing import legacy_page_test_case
 
 from measurements import skpicture_printer
 
 
-class SkpicturePrinterUnitTest(page_test_test_case.PageTestTestCase):
-
-  def setUp(self):
-    self._skp_outdir = tempfile.mkdtemp('_skp_test')
-    self._options = options_for_unittests.GetRunOptions(
-        output_dir=self._skp_outdir)
-
-  def tearDown(self):
-    shutil.rmtree(self._skp_outdir)
-
+class SkpicturePrinterUnitTest(legacy_page_test_case.LegacyPageTestCase):
   # Picture printing is not supported on all platforms.
   @decorators.Disabled('android', 'chromeos')
   def testSkpicturePrinter(self):
-    story_set = self.CreateStorySetFromFileInUnittestDataDir('blank.html')
-    measurement = skpicture_printer.SkpicturePrinter(self._skp_outdir)
-    results = self.RunMeasurement(
-        measurement, story_set, run_options=self._options)
-
-    saved_picture_count = results.FindAllPageSpecificValuesNamed(
-        'saved_picture_count')
+    page_test = skpicture_printer.SkpicturePrinter(self.options.output_dir)
+    measurements = self.RunPageTest(page_test, 'file://blank.html')
+    saved_picture_count = measurements['saved_picture_count']['samples']
     self.assertEquals(len(saved_picture_count), 1)
-    self.assertGreater(saved_picture_count[0].value, 0)
+    self.assertGreater(saved_picture_count[0], 0)