src/tools/telemetry/telemetry/value/list_of_string_values_unittest.py

   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.
   4 import os
   5 import unittest
   6
   7 from telemetry import value
   8 from telemetry.page import page_set
   9 from telemetry.value import list_of_string_values
  10 from telemetry.value import none_values
  11
  12
  13 class 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
  24 class 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')