1# Copyright 2014 The Chromium Authors. All rights reserved.
2# Use of this source code is governed by a BSD-style license that can be
3# found in the LICENSE file.
4import os
5import unittest
6
7from telemetry import value
8from telemetry.page import page_set
9from telemetry.value import list_of_string_values
10from telemetry.value import none_values
11
12
13class TestBase(unittest.TestCase):
14  def setUp(self):
15    self.page_set = page_set.PageSet(file_path=os.path.dirname(__file__))
16    self.page_set.AddPageWithDefaultRunNavigate("http://www.bar.com/")
17    self.page_set.AddPageWithDefaultRunNavigate("http://www.baz.com/")
18    self.page_set.AddPageWithDefaultRunNavigate("http://www.foo.com/")
19
20  @property
21  def pages(self):
22    return self.page_set.pages
23
24class ListOfStringValuesTest(TestBase):
25  def testListSamePageMergingWithSamePageConcatenatePolicy(self):
26    page0 = self.pages[0]
27    v0 = list_of_string_values.ListOfStringValues(
28        page0, 'x', 'label',
29        ['L1','L2'], same_page_merge_policy=value.CONCATENATE)
30    v1 = list_of_string_values.ListOfStringValues(
31        page0, 'x', 'label',
32        ['L3','L4'], same_page_merge_policy=value.CONCATENATE)
33    self.assertTrue(v1.IsMergableWith(v0))
34
35    vM = (list_of_string_values.ListOfStringValues.
36          MergeLikeValuesFromSamePage([v0, v1]))
37    self.assertEquals(page0, vM.page)
38    self.assertEquals('x', vM.name)
39    self.assertEquals('label', vM.units)
40    self.assertEquals(value.CONCATENATE, vM.same_page_merge_policy)
41    self.assertEquals(True, vM.important)
42    self.assertEquals(['L1', 'L2', 'L3', 'L4'], vM.values)
43
44  def testListSamePageMergingWithPickFirstPolicy(self):
45    page0 = self.pages[0]
46    v0 = list_of_string_values.ListOfStringValues(
47        page0, 'x', 'label',
48        ['L1','L2'], same_page_merge_policy=value.PICK_FIRST)
49    v1 = list_of_string_values.ListOfStringValues(
50        page0, 'x', 'label',
51        ['L3','L4'], same_page_merge_policy=value.PICK_FIRST)
52    self.assertTrue(v1.IsMergableWith(v0))
53
54    vM = (list_of_string_values.ListOfStringValues.
55          MergeLikeValuesFromSamePage([v0, v1]))
56    self.assertEquals(page0, vM.page)
57    self.assertEquals('x', vM.name)
58    self.assertEquals('label', vM.units)
59    self.assertEquals(value.PICK_FIRST, vM.same_page_merge_policy)
60    self.assertEquals(True, vM.important)
61    self.assertEquals(['L1', 'L2'], vM.values)
62
63  def testListDifferentPageMerging(self):
64    page0 = self.pages[0]
65    page1 = self.pages[0]
66    v0 = list_of_string_values.ListOfStringValues(
67        page0, 'x', 'label',
68        ['L1', 'L2'], same_page_merge_policy=value.CONCATENATE)
69    v1 = list_of_string_values.ListOfStringValues(
70        page1, 'x', 'label',
71        ['L3', 'L4'], same_page_merge_policy=value.CONCATENATE)
72    self.assertTrue(v1.IsMergableWith(v0))
73
74    vM = (list_of_string_values.ListOfStringValues.
75          MergeLikeValuesFromDifferentPages([v0, v1]))
76    self.assertEquals(None, vM.page)
77    self.assertEquals('x', vM.name)
78    self.assertEquals('label', vM.units)
79    self.assertEquals(value.CONCATENATE, vM.same_page_merge_policy)
80    self.assertEquals(True, vM.important)
81    self.assertEquals(['L1', 'L2', 'L3', 'L4'], vM.values)
82
83  def testListWithNoneValueMerging(self):
84    page0 = self.pages[0]
85    v0 = list_of_string_values.ListOfStringValues(
86        page0, 'x', 'unit',
87        ['L1', 'L2'], same_page_merge_policy=value.CONCATENATE)
88    v1 = list_of_string_values.ListOfStringValues(
89        page0, 'x', 'unit',
90        None, same_page_merge_policy=value.CONCATENATE, none_value_reason='n')
91    self.assertTrue(v1.IsMergableWith(v0))
92
93    vM = (list_of_string_values.ListOfStringValues.
94          MergeLikeValuesFromSamePage([v0, v1]))
95    self.assertEquals(None, vM.values)
96    self.assertEquals(none_values.MERGE_FAILURE_REASON, vM.none_value_reason)
97
98  def testListWithNoneValueMustHaveNoneReason(self):
99    page0 = self.pages[0]
100    self.assertRaises(none_values.NoneValueMissingReason,
101                      lambda: list_of_string_values.ListOfStringValues(
102                          page0, 'x', 'unit', None))
103
104  def testListWithNoneReasonMustHaveNoneValue(self):
105    page0 = self.pages[0]
106    self.assertRaises(none_values.ValueMustHaveNoneValue,
107                      lambda: list_of_string_values.ListOfStringValues(
108                          page0, 'x', 'unit', ['L1', 'L2'],
109                          none_value_reason='n'))
110
111  def testAsDict(self):
112    v = list_of_string_values.ListOfStringValues(
113        None, 'x', 'unit', ['foo', 'bar'],
114        same_page_merge_policy=value.PICK_FIRST, important=False)
115    d = v.AsDictWithoutBaseClassEntries()
116
117    self.assertEquals(d, {
118          'values': ['foo', 'bar']
119        })
120
121  def testNoneValueAsDict(self):
122    v = list_of_string_values.ListOfStringValues(
123        None, 'x', 'unit', None, same_page_merge_policy=value.PICK_FIRST,
124        important=False, none_value_reason='n')
125    d = v.AsDictWithoutBaseClassEntries()
126
127    self.assertEquals(d, {
128          'values': None,
129          'none_value_reason': 'n'
130        })
131
132  def testFromDict(self):
133    d = {
134      'type': 'list_of_string_values',
135      'name': 'x',
136      'units': 'unit',
137      'values': ['foo', 'bar']
138    }
139    v = value.Value.FromDict(d, {})
140
141    self.assertTrue(isinstance(v, list_of_string_values.ListOfStringValues))
142    self.assertEquals(v.values, ['foo', 'bar'])
143
144  def testFromDictNoneValue(self):
145    d = {
146      'type': 'list_of_string_values',
147      'name': 'x',
148      'units': 'unit',
149      'values': None,
150      'none_value_reason': 'n'
151    }
152    v = value.Value.FromDict(d, {})
153
154    self.assertTrue(isinstance(v, list_of_string_values.ListOfStringValues))
155    self.assertEquals(v.values, None)
156    self.assertEquals(v.none_value_reason, 'n')
157