Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(273)

Side by Side Diff: tools/telemetry/telemetry/value/list_of_scalar_values_unittest.py

Issue 809393002: Added support for improvement_direction to relevant values, which is propogated to chartjson. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Fix linter issues Created 5 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 # Copyright 2013 The Chromium Authors. All rights reserved. 1 # Copyright 2013 The Chromium Authors. All rights reserved.
2 # Use of this source code is governed by a BSD-style license that can be 2 # Use of this source code is governed by a BSD-style license that can be
3 # found in the LICENSE file. 3 # found in the LICENSE file.
4 import os 4 import os
5 import unittest 5 import unittest
6 6
7 from telemetry import page as page_module 7 from telemetry import page as page_module
8 from telemetry import value 8 from telemetry import value
9 from telemetry.page import page_set 9 from telemetry.page import page_set
10 from telemetry.value import improvement_direction
10 from telemetry.value import list_of_scalar_values 11 from telemetry.value import list_of_scalar_values
11 from telemetry.value import none_values 12 from telemetry.value import none_values
12 13
13 14
14 class TestBase(unittest.TestCase): 15 class TestBase(unittest.TestCase):
15 def setUp(self): 16 def setUp(self):
16 ps = page_set.PageSet(file_path=os.path.dirname(__file__)) 17 ps = page_set.PageSet(file_path=os.path.dirname(__file__))
17 ps.AddUserStory(page_module.Page('http://www.bar.com/', ps, ps.base_dir)) 18 ps.AddUserStory(page_module.Page('http://www.bar.com/', ps, ps.base_dir))
18 ps.AddUserStory(page_module.Page('http://www.baz.com/', ps, ps.base_dir)) 19 ps.AddUserStory(page_module.Page('http://www.baz.com/', ps, ps.base_dir))
19 ps.AddUserStory(page_module.Page('http://www.foo.com/', ps, ps.base_dir)) 20 ps.AddUserStory(page_module.Page('http://www.foo.com/', ps, ps.base_dir))
20 self.page_set = ps 21 self.page_set = ps
21 22
22 @property 23 @property
23 def pages(self): 24 def pages(self):
24 return self.page_set.pages 25 return self.page_set.pages
25 26
26 class ValueTest(TestBase): 27 class ValueTest(TestBase):
27 def testListSamePageMergingWithSamePageConcatenatePolicy(self): 28 def testListSamePageMergingWithSamePageConcatenatePolicy(self):
28 page0 = self.pages[0] 29 page0 = self.pages[0]
29 v0 = list_of_scalar_values.ListOfScalarValues( 30 v0 = list_of_scalar_values.ListOfScalarValues(
30 page0, 'x', 'unit', 31 page0, 'x', 'unit',
31 [1, 2], same_page_merge_policy=value.CONCATENATE) 32 [1, 2], same_page_merge_policy=value.CONCATENATE,
33 improvement_direction=improvement_direction.DOWN)
32 v1 = list_of_scalar_values.ListOfScalarValues( 34 v1 = list_of_scalar_values.ListOfScalarValues(
33 page0, 'x', 'unit', 35 page0, 'x', 'unit',
34 [3, 4], same_page_merge_policy=value.CONCATENATE) 36 [3, 4], same_page_merge_policy=value.CONCATENATE,
37 improvement_direction=improvement_direction.DOWN)
35 self.assertTrue(v1.IsMergableWith(v0)) 38 self.assertTrue(v1.IsMergableWith(v0))
36 39
37 vM = (list_of_scalar_values.ListOfScalarValues. 40 vM = (list_of_scalar_values.ListOfScalarValues.
38 MergeLikeValuesFromSamePage([v0, v1])) 41 MergeLikeValuesFromSamePage([v0, v1]))
39 self.assertEquals(page0, vM.page) 42 self.assertEquals(page0, vM.page)
40 self.assertEquals('x', vM.name) 43 self.assertEquals('x', vM.name)
41 self.assertEquals('unit', vM.units) 44 self.assertEquals('unit', vM.units)
42 self.assertEquals(value.CONCATENATE, vM.same_page_merge_policy) 45 self.assertEquals(value.CONCATENATE, vM.same_page_merge_policy)
43 self.assertEquals(True, vM.important) 46 self.assertEquals(True, vM.important)
44 self.assertEquals([1, 2, 3, 4], vM.values) 47 self.assertEquals([1, 2, 3, 4], vM.values)
48 self.assertEquals(improvement_direction.DOWN, vM.improvement_direction)
45 49
46 def testListSamePageMergingWithPickFirstPolicy(self): 50 def testListSamePageMergingWithPickFirstPolicy(self):
47 page0 = self.pages[0] 51 page0 = self.pages[0]
48 v0 = list_of_scalar_values.ListOfScalarValues( 52 v0 = list_of_scalar_values.ListOfScalarValues(
49 page0, 'x', 'unit', 53 page0, 'x', 'unit',
50 [1, 2], same_page_merge_policy=value.PICK_FIRST) 54 [1, 2], same_page_merge_policy=value.PICK_FIRST,
55 improvement_direction=improvement_direction.UP)
51 v1 = list_of_scalar_values.ListOfScalarValues( 56 v1 = list_of_scalar_values.ListOfScalarValues(
52 page0, 'x', 'unit', 57 page0, 'x', 'unit',
53 [3, 4], same_page_merge_policy=value.PICK_FIRST) 58 [3, 4], same_page_merge_policy=value.PICK_FIRST,
59 improvement_direction=improvement_direction.UP)
54 self.assertTrue(v1.IsMergableWith(v0)) 60 self.assertTrue(v1.IsMergableWith(v0))
55 61
56 vM = (list_of_scalar_values.ListOfScalarValues. 62 vM = (list_of_scalar_values.ListOfScalarValues.
57 MergeLikeValuesFromSamePage([v0, v1])) 63 MergeLikeValuesFromSamePage([v0, v1]))
58 self.assertEquals(page0, vM.page) 64 self.assertEquals(page0, vM.page)
59 self.assertEquals('x', vM.name) 65 self.assertEquals('x', vM.name)
60 self.assertEquals('unit', vM.units) 66 self.assertEquals('unit', vM.units)
61 self.assertEquals(value.PICK_FIRST, vM.same_page_merge_policy) 67 self.assertEquals(value.PICK_FIRST, vM.same_page_merge_policy)
62 self.assertEquals(True, vM.important) 68 self.assertEquals(True, vM.important)
63 self.assertEquals([1, 2], vM.values) 69 self.assertEquals([1, 2], vM.values)
70 self.assertEquals(improvement_direction.UP, vM.improvement_direction)
64 71
65 def testListDifferentPageMerging(self): 72 def testListDifferentPageMerging(self):
66 page0 = self.pages[0] 73 page0 = self.pages[0]
67 page1 = self.pages[1] 74 page1 = self.pages[1]
68 v0 = list_of_scalar_values.ListOfScalarValues( 75 v0 = list_of_scalar_values.ListOfScalarValues(
69 page0, 'x', 'unit', 76 page0, 'x', 'unit',
70 [1, 2], same_page_merge_policy=value.CONCATENATE) 77 [1, 2], same_page_merge_policy=value.CONCATENATE,
78 improvement_direction=improvement_direction.DOWN)
71 v1 = list_of_scalar_values.ListOfScalarValues( 79 v1 = list_of_scalar_values.ListOfScalarValues(
72 page1, 'x', 'unit', 80 page1, 'x', 'unit',
73 [3, 4], same_page_merge_policy=value.CONCATENATE) 81 [3, 4], same_page_merge_policy=value.CONCATENATE,
82 improvement_direction=improvement_direction.DOWN)
74 self.assertTrue(v1.IsMergableWith(v0)) 83 self.assertTrue(v1.IsMergableWith(v0))
75 84
76 vM = (list_of_scalar_values.ListOfScalarValues. 85 vM = (list_of_scalar_values.ListOfScalarValues.
77 MergeLikeValuesFromDifferentPages([v0, v1])) 86 MergeLikeValuesFromDifferentPages([v0, v1]))
78 self.assertEquals(None, vM.page) 87 self.assertEquals(None, vM.page)
79 self.assertEquals('x', vM.name) 88 self.assertEquals('x', vM.name)
80 self.assertEquals('unit', vM.units) 89 self.assertEquals('unit', vM.units)
81 self.assertEquals(value.CONCATENATE, vM.same_page_merge_policy) 90 self.assertEquals(value.CONCATENATE, vM.same_page_merge_policy)
82 self.assertEquals(True, vM.important) 91 self.assertEquals(True, vM.important)
83 self.assertEquals([1, 2, 3, 4], vM.values) 92 self.assertEquals([1, 2, 3, 4], vM.values)
93 self.assertEquals(improvement_direction.DOWN, vM.improvement_direction)
84 94
85 def testListWithNoneValueMerging(self): 95 def testListWithNoneValueMerging(self):
86 page0 = self.pages[0] 96 page0 = self.pages[0]
87 v0 = list_of_scalar_values.ListOfScalarValues( 97 v0 = list_of_scalar_values.ListOfScalarValues(
88 page0, 'x', 'unit', 98 page0, 'x', 'unit',
89 [1, 2], same_page_merge_policy=value.CONCATENATE) 99 [1, 2], same_page_merge_policy=value.CONCATENATE,
100 improvement_direction=improvement_direction.UP)
90 v1 = list_of_scalar_values.ListOfScalarValues( 101 v1 = list_of_scalar_values.ListOfScalarValues(
91 page0, 'x', 'unit', 102 page0, 'x', 'unit',
92 None, same_page_merge_policy=value.CONCATENATE, none_value_reason='n') 103 None, same_page_merge_policy=value.CONCATENATE, none_value_reason='n',
104 improvement_direction=improvement_direction.UP)
93 self.assertTrue(v1.IsMergableWith(v0)) 105 self.assertTrue(v1.IsMergableWith(v0))
94 106
95 vM = (list_of_scalar_values.ListOfScalarValues. 107 vM = (list_of_scalar_values.ListOfScalarValues.
96 MergeLikeValuesFromSamePage([v0, v1])) 108 MergeLikeValuesFromSamePage([v0, v1]))
97 self.assertEquals(None, vM.values) 109 self.assertEquals(None, vM.values)
98 self.assertEquals(none_values.MERGE_FAILURE_REASON, 110 self.assertEquals(none_values.MERGE_FAILURE_REASON,
99 vM.none_value_reason) 111 vM.none_value_reason)
112 self.assertEquals(improvement_direction.UP, vM.improvement_direction)
100 113
101 def testListWithNoneValueMustHaveNoneReason(self): 114 def testListWithNoneValueMustHaveNoneReason(self):
102 page0 = self.pages[0] 115 page0 = self.pages[0]
103 self.assertRaises(none_values.NoneValueMissingReason, 116 self.assertRaises(none_values.NoneValueMissingReason,
104 lambda: list_of_scalar_values.ListOfScalarValues( 117 lambda: list_of_scalar_values.ListOfScalarValues(
105 page0, 'x', 'unit', None)) 118 page0, 'x', 'unit', None,
119 improvement_direction=improvement_direction.DOWN))
106 120
107 def testListWithNoneReasonMustHaveNoneValue(self): 121 def testListWithNoneReasonMustHaveNoneValue(self):
108 page0 = self.pages[0] 122 page0 = self.pages[0]
109 self.assertRaises(none_values.ValueMustHaveNoneValue, 123 self.assertRaises(none_values.ValueMustHaveNoneValue,
110 lambda: list_of_scalar_values.ListOfScalarValues( 124 lambda: list_of_scalar_values.ListOfScalarValues(
111 page0, 'x', 'unit', [1, 2], 125 page0, 'x', 'unit', [1, 2],
112 none_value_reason='n')) 126 none_value_reason='n',
127 improvement_direction=improvement_direction.UP))
113 128
114 def testAsDict(self): 129 def testAsDict(self):
115 v = list_of_scalar_values.ListOfScalarValues( 130 v = list_of_scalar_values.ListOfScalarValues(
116 None, 'x', 'unit', [1, 2], 131 None, 'x', 'unit', [1, 2],
117 same_page_merge_policy=value.PICK_FIRST, important=False) 132 same_page_merge_policy=value.PICK_FIRST, important=False,
133 improvement_direction=improvement_direction.DOWN)
118 d = v.AsDictWithoutBaseClassEntries() 134 d = v.AsDictWithoutBaseClassEntries()
119 135
120 self.assertEquals(d, { 136 self.assertEquals(d, {
121 'values': [1, 2] 137 'values': [1, 2]
122 }) 138 })
123 139
124 def testNoneValueAsDict(self): 140 def testNoneValueAsDict(self):
125 v = list_of_scalar_values.ListOfScalarValues( 141 v = list_of_scalar_values.ListOfScalarValues(
126 None, 'x', 'unit', None, same_page_merge_policy=value.PICK_FIRST, 142 None, 'x', 'unit', None, same_page_merge_policy=value.PICK_FIRST,
127 important=False, none_value_reason='n') 143 important=False, none_value_reason='n',
144 improvement_direction=improvement_direction.UP)
128 d = v.AsDictWithoutBaseClassEntries() 145 d = v.AsDictWithoutBaseClassEntries()
129 146
130 self.assertEquals(d, { 147 self.assertEquals(d, {
131 'values': None, 148 'values': None,
132 'none_value_reason': 'n' 149 'none_value_reason': 'n'
133 }) 150 })
134 151
135 def testFromDictInts(self): 152 def testFromDictInts(self):
136 d = { 153 d = {
137 'type': 'list_of_scalar_values', 154 'type': 'list_of_scalar_values',
138 'name': 'x', 155 'name': 'x',
139 'units': 'unit', 156 'units': 'unit',
140 'values': [1, 2] 157 'values': [1, 2],
158 'improvement_direction': improvement_direction.DOWN,
141 } 159 }
142 v = value.Value.FromDict(d, {}) 160 v = value.Value.FromDict(d, {})
143 161
144 self.assertTrue(isinstance(v, list_of_scalar_values.ListOfScalarValues)) 162 self.assertTrue(isinstance(v, list_of_scalar_values.ListOfScalarValues))
145 self.assertEquals(v.values, [1, 2]) 163 self.assertEquals(v.values, [1, 2])
164 self.assertEquals(improvement_direction.DOWN, v.improvement_direction)
146 165
147 def testFromDictFloats(self): 166 def testFromDictFloats(self):
148 d = { 167 d = {
149 'type': 'list_of_scalar_values', 168 'type': 'list_of_scalar_values',
150 'name': 'x', 169 'name': 'x',
151 'units': 'unit', 170 'units': 'unit',
152 'values': [1.3, 2.7] 171 'values': [1.3, 2.7],
172 'improvement_direction': improvement_direction.UP
153 } 173 }
154 v = value.Value.FromDict(d, {}) 174 v = value.Value.FromDict(d, {})
155 175
156 self.assertTrue(isinstance(v, list_of_scalar_values.ListOfScalarValues)) 176 self.assertTrue(isinstance(v, list_of_scalar_values.ListOfScalarValues))
157 self.assertEquals(v.values, [1.3, 2.7]) 177 self.assertEquals(v.values, [1.3, 2.7])
158 178
159 def testFromDictNoneValue(self): 179 def testFromDictNoneValue(self):
160 d = { 180 d = {
161 'type': 'list_of_scalar_values', 181 'type': 'list_of_scalar_values',
162 'name': 'x', 182 'name': 'x',
163 'units': 'unit', 183 'units': 'unit',
164 'values': None, 184 'values': None,
165 'none_value_reason': 'n' 185 'none_value_reason': 'n',
186 'improvement_direction': improvement_direction.DOWN,
166 } 187 }
167 v = value.Value.FromDict(d, {}) 188 v = value.Value.FromDict(d, {})
168 189
169 self.assertTrue(isinstance(v, list_of_scalar_values.ListOfScalarValues)) 190 self.assertTrue(isinstance(v, list_of_scalar_values.ListOfScalarValues))
170 self.assertEquals(v.values, None) 191 self.assertEquals(v.values, None)
171 self.assertEquals(v.none_value_reason, 'n') 192 self.assertEquals(v.none_value_reason, 'n')
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698