Added support for improvement_direction to relevant values, which is propogated to chartjson.

tools/telemetry/telemetry/results/page_test_results_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 os
 
 from telemetry import page as page_module
 from telemetry.page import page_set
 from telemetry.results import base_test_results_unittest
 from telemetry.results import page_test_results
 from telemetry.timeline import trace_data
 from telemetry.value import failure
 from telemetry.value import histogram
+from telemetry.value import improvement_direction
 from telemetry.value import scalar
 from telemetry.value import skip
 from telemetry.value import trace
 
 
 class PageTestResultsTest(base_test_results_unittest.BaseTestResultsUnittest):
   def setUp(self):
     ps = page_set.PageSet(file_path=os.path.dirname(__file__))
     ps.AddUserStory(page_module.Page("http://www.bar.com/", ps, ps.base_dir))
     ps.AddUserStory(page_module.Page("http://www.baz.com/", ps, ps.base_dir))
@@ skipping 35 matching lines @@
     self.assertEqual(set([self.pages[0], self.pages[1]]),
                      results.pages_that_succeeded)
 
     self.assertEqual(2, len(results.all_page_runs))
     self.assertTrue(results.all_page_runs[0].skipped)
     self.assertTrue(results.all_page_runs[1].ok)
 
   def test_basic(self):
     results = page_test_results.PageTestResults()
     results.WillRunPage(self.pages[0])
-    results.AddValue(scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3))
+    results.AddValue(scalar.ScalarValue(
+        self.pages[0], 'a', 'seconds', 3,
+        improvement_direction=improvement_direction.DOWN))
     results.DidRunPage(self.pages[0])
 
     results.WillRunPage(self.pages[1])
-    results.AddValue(scalar.ScalarValue(self.pages[1], 'a', 'seconds', 3))
+    results.AddValue(scalar.ScalarValue(
+        self.pages[1], 'a', 'seconds', 3,
+        improvement_direction=improvement_direction.DOWN))
     results.DidRunPage(self.pages[1])
 
     results.PrintSummary()
 
     values = results.FindPageSpecificValuesForPage(self.pages[0], 'a')
     self.assertEquals(1, len(values))
     v = values[0]
     self.assertEquals(v.name, 'a')
     self.assertEquals(v.page, self.pages[0])
 
     values = results.FindAllPageSpecificValuesNamed('a')
     assert len(values) == 2
 
   def test_url_is_invalid_value(self):
     results = page_test_results.PageTestResults()
     results.WillRunPage(self.pages[0])
     self.assertRaises(
       AssertionError,
       lambda: results.AddValue(scalar.ScalarValue(
-          self.pages[0], 'url', 'string', 'foo')))
+          self.pages[0], 'url', 'string', 'foo',
+          improvement_direction=improvement_direction.DOWN)))
 
   def test_add_summary_value_with_page_specified(self):
     results = page_test_results.PageTestResults()
     results.WillRunPage(self.pages[0])
     self.assertRaises(
       AssertionError,
-      lambda: results.AddSummaryValue(scalar.ScalarValue(self.pages[0],
-                                                         'a', 'units', 3)))
+      lambda: results.AddSummaryValue(scalar.ScalarValue(
+          self.pages[0], 'a', 'units', 3,
+          improvement_direction=improvement_direction.DOWN)))
 
   def test_unit_change(self):
     results = page_test_results.PageTestResults()
     results.WillRunPage(self.pages[0])
-    results.AddValue(scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3))
+    results.AddValue(scalar.ScalarValue(
+        self.pages[0], 'a', 'seconds', 3,
+        improvement_direction=improvement_direction.DOWN))
     results.DidRunPage(self.pages[0])
 
     results.WillRunPage(self.pages[1])
     self.assertRaises(
       AssertionError,
       lambda: results.AddValue(scalar.ScalarValue(
-          self.pages[1], 'a', 'foobgrobbers', 3)))
+          self.pages[1], 'a', 'foobgrobbers', 3,
+          improvement_direction=improvement_direction.DOWN)))
 
   def test_type_change(self):
     results = page_test_results.PageTestResults()
     results.WillRunPage(self.pages[0])
-    results.AddValue(scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3))
+    results.AddValue(scalar.ScalarValue(
+        self.pages[0], 'a', 'seconds', 3,
+        improvement_direction=improvement_direction.DOWN))
     results.DidRunPage(self.pages[0])
 
     results.WillRunPage(self.pages[1])
     self.assertRaises(
       AssertionError,
       lambda: results.AddValue(histogram.HistogramValue(
           self.pages[1], 'a', 'seconds',
-          raw_value_json='{"buckets": [{"low": 1, "high": 2, "count": 1}]}')))
+          raw_value_json='{"buckets": [{"low": 1, "high": 2, "count": 1}]}',
+          improvement_direction=improvement_direction.DOWN)))
 
   def test_get_pages_that_succeeded_all_pages_fail(self):
     results = page_test_results.PageTestResults()
     results.WillRunPage(self.pages[0])
-    results.AddValue(scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3))
+    results.AddValue(scalar.ScalarValue(
+        self.pages[0], 'a', 'seconds', 3,
+        improvement_direction=improvement_direction.DOWN))
     results.AddValue(failure.FailureValue.FromMessage(self.pages[0], 'message'))
     results.DidRunPage(self.pages[0])
 
     results.WillRunPage(self.pages[1])
-    results.AddValue(scalar.ScalarValue(self.pages[1], 'a', 'seconds', 7))
+    results.AddValue(scalar.ScalarValue(
+        self.pages[1], 'a', 'seconds', 7,
+        improvement_direction=improvement_direction.DOWN))
     results.AddValue(failure.FailureValue.FromMessage(self.pages[1], 'message'))
     results.DidRunPage(self.pages[1])
 
     results.PrintSummary()
     self.assertEquals(0, len(results.pages_that_succeeded))
 
   def test_get_successful_page_values_merged_no_failures(self):
     results = page_test_results.PageTestResults()
     results.WillRunPage(self.pages[0])
-    results.AddValue(scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3))
+    results.AddValue(scalar.ScalarValue(
+        self.pages[0], 'a', 'seconds', 3,
+        improvement_direction=improvement_direction.DOWN))
     self.assertEquals(1, len(results.all_page_specific_values))
     results.DidRunPage(self.pages[0])
 
   def test_get_all_values_for_successful_pages(self):
     results = page_test_results.PageTestResults()
     results.WillRunPage(self.pages[0])
-    value1 = scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3)
+    value1 = scalar.ScalarValue(
+        self.pages[0], 'a', 'seconds', 3,
+        improvement_direction=improvement_direction.DOWN)
     results.AddValue(value1)
     results.DidRunPage(self.pages[0])
 
     results.WillRunPage(self.pages[1])
-    value2 = scalar.ScalarValue(self.pages[1], 'a', 'seconds', 3)
+    value2 = scalar.ScalarValue(
+        self.pages[1], 'a', 'seconds', 3,
+        improvement_direction=improvement_direction.DOWN)
     results.AddValue(value2)
     results.DidRunPage(self.pages[1])
 
     results.WillRunPage(self.pages[2])
-    value3 = scalar.ScalarValue(self.pages[2], 'a', 'seconds', 3)
+    value3 = scalar.ScalarValue(
+        self.pages[2], 'a', 'seconds', 3,
+        improvement_direction=improvement_direction.DOWN)
     results.AddValue(value3)
     results.DidRunPage(self.pages[2])
 
     self.assertEquals(
         [value1, value2, value3], results.all_page_specific_values)
 
   def test_get_all_values_for_successful_pages_one_page_fails(self):
     results = page_test_results.PageTestResults()
     results.WillRunPage(self.pages[0])
-    value1 = scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3)
+    value1 = scalar.ScalarValue(
+        self.pages[0], 'a', 'seconds', 3,
+        improvement_direction=improvement_direction.DOWN)
     results.AddValue(value1)
     results.DidRunPage(self.pages[0])
 
     results.WillRunPage(self.pages[1])
     value2 = failure.FailureValue.FromMessage(self.pages[1], 'Failure')
     results.AddValue(value2)
     results.DidRunPage(self.pages[1])
 
     results.WillRunPage(self.pages[2])
-    value3 = scalar.ScalarValue(self.pages[2], 'a', 'seconds', 3)
+    value3 = scalar.ScalarValue(
+        self.pages[2], 'a', 'seconds', 3,
+        improvement_direction=improvement_direction.DOWN)
     results.AddValue(value3)
     results.DidRunPage(self.pages[2])
 
     self.assertEquals(
         [value1, value2, value3], results.all_page_specific_values)
 
   def testTraceValue(self):
     results = page_test_results.PageTestResults()
     results.WillRunPage(self.pages[0])
     results.AddValue(trace.TraceValue(None, trace_data.TraceData({'test' : 1})))
     results.DidRunPage(self.pages[0])
 
     results.WillRunPage(self.pages[1])
     results.AddValue(trace.TraceValue(None, trace_data.TraceData({'test' : 2})))
     results.DidRunPage(self.pages[1])
 
     results.PrintSummary()
 
     values = results.FindAllTraceValues()
     self.assertEquals(2, len(values))