def testArgumentsWithNoChart(self):
     arguments = dict(_BASE_ARGUMENTS_HISTOGRAMS)
     arguments['story'] = 'trace_name'
     quest = read_value.ReadHistogramsJsonValue.FromDict(arguments)
     expected = read_value.ReadHistogramsJsonValue(
         'speedometer/perf_results.json', None, None, 'trace_name', None)
     self.assertEqual(quest, expected)
Exemple #2
0
  def testReadHistogramsDiagnosticRefSkipTraceUrls(self):
    hist = histogram_module.Histogram('hist', 'count')
    hist.AddSample(0)
    hist.diagnostics[reserved_infos.TRACE_URLS.name] = (
        generic_set.GenericSet(['trace_url1', 'trace_url2']))
    hist2 = histogram_module.Histogram('hist2', 'count')
    hist2.diagnostics[reserved_infos.TRACE_URLS.name] = (
        generic_set.GenericSet(['trace_url3']))
    hist2.diagnostics[reserved_infos.TRACE_URLS.name].guid = 'foo'
    histograms = histogram_set.HistogramSet([hist, hist2])
    self.SetOutputFileContents(histograms.AsDicts())

    quest = read_value.ReadHistogramsJsonValue(hist_name=hist.name)
    execution = quest.Start(None, 'server', 'output hash')
    execution.Poll()

    self.assertReadValueSuccess(execution)
    self.assertEqual(execution.result_values, (0,))
    self.assertEqual(
        {
            'result_values': (0,),
            'completed': True,
            'exception': None,
            'result_arguments': {},
            'details': {
                'isolate_server': 'server',
                'traces': [
                    {'url': 'trace_url1', 'name': 'trace_url1'},
                    {'url': 'trace_url2', 'name': 'trace_url2'},
                ]
            }
        },
        execution.AsDict())
    self.assertRetrievedOutputJson()
    def testReadHistogramsJsonValueSummary(self):
        samples = []
        hists = []
        for i in xrange(10):
            hist = histogram_module.Histogram('hist', 'count')
            hist.AddSample(0)
            hist.AddSample(1)
            hist.AddSample(2)
            hist.diagnostics[reserved_infos.STORIES.name] = (
                generic_set.GenericSet(['story%d' % i]))
            hists.append(hist)
            samples.extend(hist.sample_values)

        histograms = histogram_set.HistogramSet(hists)
        histograms.AddSharedDiagnostic(
            reserved_infos.STORY_TAGS.name,
            generic_set.GenericSet(['group:tir_label']))

        self.SetOutputFileContents(histograms.AsDicts())

        quest = read_value.ReadHistogramsJsonValue(hists[0].name, 'tir_label',
                                                   None)
        execution = quest.Start(None, 'output hash')
        execution.Poll()

        self.assertTrue(execution.completed)
        self.assertFalse(execution.failed)
        self.assertEqual(execution.result_values, tuple(samples))
        self.assertEqual(execution.result_arguments, {})

        expected_calls = [
            mock.call('output hash'),
            mock.call('output json hash')
        ]
        self.assertEqual(self._retrieve.mock_calls, expected_calls)
  def testReadHistogramsJsonValueMultipleHistograms(self):
    hist = histogram_module.Histogram('hist', 'count')
    hist.AddSample(0)
    hist.AddSample(1)
    hist.AddSample(2)
    hist2 = histogram_module.Histogram('hist', 'count')
    hist2.AddSample(0)
    hist2.AddSample(1)
    hist2.AddSample(2)
    hist3 = histogram_module.Histogram('some_other_histogram', 'count')
    hist3.AddSample(3)
    hist3.AddSample(4)
    hist3.AddSample(5)
    histograms = histogram_set.HistogramSet([hist, hist2, hist3])
    histograms.AddSharedDiagnostic(
        reserved_infos.STORY_TAGS.name,
        generic_set.GenericSet(['group:tir_label']))
    histograms.AddSharedDiagnostic(
        reserved_infos.STORIES.name,
        generic_set.GenericSet(['story']))
    self.SetOutputFileContents(histograms.AsDicts())

    quest = read_value.ReadHistogramsJsonValue(
        'chartjson-output.json', hist.name, 'tir_label', 'story')
    execution = quest.Start(None, 'server', 'output hash')
    execution.Poll()

    self.assertReadValueSuccess(execution)
    self.assertEqual(execution.result_values, (0, 1, 2, 0, 1, 2))
    self.assertRetrievedOutputJson()
  def testReadHistogramsJsonValueSummaryNoHistName(self):
    samples = []
    hists = []
    for i in xrange(10):
      hist = histogram_module.Histogram('hist', 'count')
      hist.AddSample(0)
      hist.AddSample(1)
      hist.AddSample(2)
      hist.diagnostics[reserved_infos.STORIES.name] = (
          generic_set.GenericSet(['story%d' % i]))
      hist.diagnostics[reserved_infos.STORY_TAGS.name] = (
          generic_set.GenericSet(['group:tir_label1']))
      hists.append(hist)
      samples.extend(hist.sample_values)

    histograms = histogram_set.HistogramSet(hists)
    histograms.AddSharedDiagnostic(
        reserved_infos.STORY_TAGS.name,
        generic_set.GenericSet(['group:tir_label']))

    self.SetOutputFileContents(histograms.AsDicts())

    quest = read_value.ReadHistogramsJsonValue('chartjson-output.json')
    execution = quest.Start(None, 'server', 'output hash')
    execution.Poll()

    self.assertReadValueSuccess(execution)
    self.assertEqual(execution.result_values, ())
    self.assertRetrievedOutputJson()
    def testReadHistogramsJsonValueWithNoStory(self):
        hist = histogram_module.Histogram('hist', 'count')
        hist.AddSample(0)
        hist.AddSample(1)
        hist.AddSample(2)
        histograms = histogram_set.HistogramSet([hist])
        histograms.AddSharedDiagnostic(reserved_infos.STORIES.name,
                                       generic_set.GenericSet(['story']))

        self.SetOutputFileContents(histograms.AsDicts())

        quest = read_value.ReadHistogramsJsonValue(hist.name, None, 'story')
        execution = quest.Start(None, 'output hash')
        execution.Poll()

        self.assertTrue(execution.completed)
        self.assertFalse(execution.failed)
        self.assertEqual(execution.result_values, (0, 1, 2))
        self.assertEqual(execution.result_arguments, {})

        expected_calls = [
            mock.call('output hash'),
            mock.call('output json hash')
        ]
        self.assertEqual(self._retrieve.mock_calls, expected_calls)
Exemple #7
0
    def testReadHistogramsJsonValueWithNoStory(self, retrieve):
        hist = histogram_module.Histogram('hist', 'count')
        hist.AddSample(0)
        hist.AddSample(1)
        hist.AddSample(2)
        histograms = histogram_set.HistogramSet([hist])
        histograms.AddSharedDiagnostic(reserved_infos.STORIES.name,
                                       histogram_module.GenericSet(['story']))

        retrieve.side_effect = (
            {
                'files': {
                    'chartjson-output.json': {
                        'h': 'histograms hash'
                    }
                }
            },
            json.dumps(histograms.AsDicts()),
        )

        quest = read_value.ReadHistogramsJsonValue(hist.name, None, 'story')
        execution = quest.Start(None, 'output hash')
        execution.Poll()

        self.assertTrue(execution.completed)
        self.assertFalse(execution.failed)
        self.assertEqual(execution.result_values, (0, 1, 2))
        self.assertEqual(execution.result_arguments, {})

        expected_calls = [
            mock.call('output hash'),
            mock.call('histograms hash')
        ]
        self.assertEqual(retrieve.mock_calls, expected_calls)
    def testMinimumArguments(self):
        arguments = {}

        expected = read_value.ReadHistogramsJsonValue(None, None, None)
        self.assertEqual(
            read_value.ReadHistogramsJsonValue.FromDict(arguments),
            (arguments, expected))
 def testMinimumArguments(self):
     quest = read_value.ReadHistogramsJsonValue.FromDict(
         _BASE_ARGUMENTS_HISTOGRAMS)
     expected = read_value.ReadHistogramsJsonValue(
         'speedometer/perf_results.json')
     print quest._results_filename
     self.assertEqual(quest, expected)
    def testWindows(self):
        arguments = dict(_BASE_ARGUMENTS_HISTOGRAMS)
        arguments['dimensions'] = [{'key': 'os', 'value': 'Windows-10'}]
        quest = read_value.ReadHistogramsJsonValue.FromDict(arguments)

        expected = read_value.ReadHistogramsJsonValue(
            'speedometer\\perf_results.json')
        self.assertEqual(quest, expected)
    def testReadHistogramsJsonValueEmptyHistogramSet(self):
        self.SetOutputFileContents([])

        quest = read_value.ReadHistogramsJsonValue('metric', 'test')
        execution = quest.Start(None, 'output hash')
        execution.Poll()

        self.assertReadValueError(execution)
    def testReadHistogramsJsonValueWithMissingFile(self):
        self._retrieve.return_value = '{"files": {}}'

        quest = read_value.ReadHistogramsJsonValue('metric', 'test')
        execution = quest.Start(None, 'output hash')
        execution.Poll()

        self.assertReadValueError(execution)
  def testPerformanceTestSuite(self):
    arguments = dict(_BASE_ARGUMENTS_HISTOGRAMS)
    arguments['target'] = 'performance_test_suite'
    quest = read_value.ReadHistogramsJsonValue.FromDict(arguments)

    expected = read_value.ReadHistogramsJsonValue(
        'speedometer/perf_results.json')
    self.assertEqual(quest, expected)
  def testReadHistogramsJsonValueWithMissingFile(self):
    self._retrieve.return_value = '{"files": {}}'

    quest = read_value.ReadHistogramsJsonValue(
        'chartjson-output.json', hist_name='metric', tir_label='test')
    execution = quest.Start(None, 'server', 'output hash')
    execution.Poll()

    self.assertReadValueError(execution)
  def testReadHistogramsJsonValueEmptyHistogramSet(self):
    self.SetOutputFileContents([])

    quest = read_value.ReadHistogramsJsonValue(
        'chartjson-output.json', hist_name='metric', tir_label='test')
    execution = quest.Start(None, 'server', 'output hash')
    execution.Poll()

    self.assertReadValueError(execution)
Exemple #16
0
  def testReadHistogramsJsonValueWithMissingHistogram(self):
    hist = histogram_module.Histogram('hist', 'count')
    histograms = histogram_set.HistogramSet([hist])
    self.SetOutputFileContents(histograms.AsDicts())

    quest = read_value.ReadHistogramsJsonValue('does_not_exist', None, None)
    execution = quest.Start(None, 'output hash')
    execution.Poll()

    self.assertReadValueError(execution)
Exemple #17
0
  def testReadHistogramsJsonValueWithNoValues(self):
    hist = histogram_module.Histogram('hist', 'count')
    histograms = histogram_set.HistogramSet([hist])
    self.SetOutputFileContents(histograms.AsDicts())

    quest = read_value.ReadHistogramsJsonValue(hist_name='chart')
    execution = quest.Start(None, 'server', 'output hash')
    execution.Poll()

    self.assertReadValueError(execution)
Exemple #18
0
 def testAllArguments(self):
   arguments = {
       'chart': 'timeToFirst',
       'tir_label': 'pcv1-cold',
       'trace': 'trace_name',
       'statistic': 'avg',
   }
   quest = read_value.ReadHistogramsJsonValue.FromDict(arguments)
   expected = read_value.ReadHistogramsJsonValue(
       'timeToFirst', 'pcv1-cold', 'trace_name', 'avg')
   self.assertEqual(quest, expected)
Exemple #19
0
  def testReadHistogramsJsonValueEmptyHistogramSet(self, retrieve):
    retrieve.side_effect = (
        {'files': {'chartjson-output.json': {'h': 'histograms hash'}}},
        json.dumps([]),
    )

    quest = read_value.ReadHistogramsJsonValue('metric', 'test')
    execution = quest.Start(None, 'output hash')
    execution.Poll()

    self.assertReadValueError(execution)
Exemple #20
0
    def testReadHistogramsTraceUrls(self, retrieve):
        hist = histogram_module.Histogram('hist', 'count')
        hist.AddSample(0)
        hist.diagnostics[reserved_infos.TRACE_URLS.name] = (
            histogram_module.GenericSet(['trace_url1', 'trace_url2']))
        hist2 = histogram_module.Histogram('hist2', 'count')
        hist2.diagnostics[reserved_infos.TRACE_URLS.name] = (
            histogram_module.GenericSet(['trace_url3']))
        histograms = histogram_set.HistogramSet([hist, hist2])
        retrieve.side_effect = (
            {
                'files': {
                    'chartjson-output.json': {
                        'h': 'histograms hash'
                    }
                }
            },
            json.dumps(histograms.AsDicts()),
        )

        quest = read_value.ReadHistogramsJsonValue(hist.name, None, None)
        execution = quest.Start(None, 'output hash')
        execution.Poll()

        self.assertTrue(execution.completed)
        self.assertFalse(execution.failed)
        self.assertEqual(execution.result_values, (0, ))
        self.assertEqual(
            {
                'result_values': (0, ),
                'completed': True,
                'exception': None,
                'result_arguments': {},
                'details': {
                    'traces': [{
                        'url': 'trace_url1',
                        'name': 'hist'
                    }, {
                        'url': 'trace_url2',
                        'name': 'hist'
                    }, {
                        'url': 'trace_url3',
                        'name': 'hist2'
                    }]
                }
            }, execution.AsDict())
        self.assertEqual(execution.result_arguments, {})

        expected_calls = [
            mock.call('output hash'),
            mock.call('histograms hash')
        ]
        self.assertEqual(retrieve.mock_calls, expected_calls)
  def testAllArguments(self):
    arguments = dict(_BASE_ARGUMENTS_HISTOGRAMS)
    arguments['chart'] = 'timeToFirst'
    arguments['tir_label'] = 'pcv1-cold'
    arguments['trace'] = 'trace_name'
    arguments['statistic'] = 'avg'
    quest = read_value.ReadHistogramsJsonValue.FromDict(arguments)

    expected = read_value.ReadHistogramsJsonValue(
        'chartjson-output.json', 'timeToFirst',
        'pcv1-cold', 'trace_name', 'avg')
    self.assertEqual(quest, expected)
    def testReadHistogramsJsonValueTirLabelWithNoValues(self):
        hist = histogram_module.Histogram('hist', 'count')
        histograms = histogram_set.HistogramSet([hist])
        self.SetOutputFileContents(histograms.AsDicts())

        quest = read_value.ReadHistogramsJsonValue('chartjson-output.json',
                                                   hist_name='chart',
                                                   tir_label='tir_label')
        execution = quest.Start(None, 'server', 'output hash')
        execution.Poll()

        self.assertReadValueError(execution, 'ReadValueNotFound')
Exemple #23
0
    def testArgumentsWithStoryInsteadOfTrace(self):
        arguments = dict(_BASE_ARGUMENTS_HISTOGRAMS)
        arguments['chart'] = 'timeToFirst'
        arguments['grouping_label'] = 'pcv1-cold'
        arguments['story'] = 'trace_name'
        arguments['statistic'] = 'avg'
        quest = read_value.ReadHistogramsJsonValue.FromDict(arguments)

        expected = read_value.ReadHistogramsJsonValue(
            'speedometer/perf_results.json', 'timeToFirst', 'pcv1-cold',
            'trace_name', 'avg')
        self.assertEqual(quest, expected)
Exemple #24
0
  def testReadHistogramsJsonValueStoryWithNoValues(self, retrieve):
    hist = histogram_module.Histogram('hist', 'count')
    histograms = histogram_set.HistogramSet([hist])
    retrieve.side_effect = (
        {'files': {'chartjson-output.json': {'h': 'histograms hash'}}},
        json.dumps(histograms.AsDicts()),
    )

    quest = read_value.ReadHistogramsJsonValue('chart', None, 'story')
    execution = quest.Start(None, 'output hash')
    execution.Poll()

    self.assertReadValueError(execution)
Exemple #25
0
  def testReadHistogramsJsonValueStatisticNoSamples(self):
    hist = histogram_module.Histogram('hist', 'count')
    histograms = histogram_set.HistogramSet([hist])
    histograms.AddSharedDiagnostic(
        reserved_infos.STORY_TAGS.name,
        generic_set.GenericSet(['group:tir_label']))
    histograms.AddSharedDiagnostic(
        reserved_infos.STORIES.name,
        generic_set.GenericSet(['story']))
    self.SetOutputFileContents(histograms.AsDicts())

    quest = read_value.ReadHistogramsJsonValue(
        hist.name, 'tir_label', 'story', statistic='avg')
    execution = quest.Start(None, 'server', 'output hash')
    execution.Poll()

    self.assertReadValueError(execution)
    def testReadHistogramsTraceUrls(self):
        hist = histogram_module.Histogram('hist', 'count')
        hist.AddSample(0)
        hist.diagnostics[reserved_infos.TRACE_URLS.name] = (
            generic_set.GenericSet(['trace_url1', 'trace_url2']))
        hist2 = histogram_module.Histogram('hist2', 'count')
        hist2.diagnostics[reserved_infos.TRACE_URLS.name] = (
            generic_set.GenericSet(['trace_url3']))
        hist3 = histogram_module.Histogram('hist3', 'count')
        hist3.diagnostics[reserved_infos.TRACE_URLS.name] = (
            generic_set.GenericSet(['trace_url2']))
        histograms = histogram_set.HistogramSet([hist, hist2, hist3])
        self.SetOutputFileContents(histograms.AsDicts())

        quest = read_value.ReadHistogramsJsonValue('chartjson-output.json',
                                                   hist_name=hist.name)
        execution = quest.Start(None, 'server', 'output hash')
        execution.Poll()

        self.assertReadValueSuccess(execution)
        self.assertEqual(execution.result_values, (0, ))
        self.assertEqual(
            {
                'completed':
                True,
                'exception':
                None,
                'details': [
                    {
                        'key': 'trace',
                        'value': 'trace_url1',
                        'url': 'trace_url1',
                    },
                    {
                        'key': 'trace',
                        'value': 'trace_url2',
                        'url': 'trace_url2',
                    },
                    {
                        'key': 'trace',
                        'value': 'trace_url3',
                        'url': 'trace_url3',
                    },
                ],
            }, execution.AsDict())
        self.assertRetrievedOutputJson()
    def testReadHistogramsDiagnosticRefSkipTraceUrls(self):
        hist = histogram_module.Histogram('hist', 'count')
        hist.AddSample(0)
        hist.diagnostics[reserved_infos.TRACE_URLS.name] = (
            generic_set.GenericSet(['trace_url1', 'trace_url2']))
        hist2 = histogram_module.Histogram('hist2', 'count')
        hist2.diagnostics[reserved_infos.TRACE_URLS.name] = (
            generic_set.GenericSet(['trace_url3']))
        hist2.diagnostics[reserved_infos.TRACE_URLS.name].guid = 'foo'
        histograms = histogram_set.HistogramSet([hist, hist2])
        self.SetOutputFileContents(histograms.AsDicts())

        quest = read_value.ReadHistogramsJsonValue(hist.name, None, None)
        execution = quest.Start(None, 'output hash')
        execution.Poll()

        self.assertTrue(execution.completed)
        self.assertFalse(execution.failed)
        self.assertEqual(execution.result_values, (0, ))
        self.assertEqual(
            {
                'result_values': (0, ),
                'completed': True,
                'exception': None,
                'result_arguments': {},
                'details': {
                    'traces': [
                        {
                            'url': 'trace_url1',
                            'name': 'trace_url1'
                        },
                        {
                            'url': 'trace_url2',
                            'name': 'trace_url2'
                        },
                    ]
                }
            }, execution.AsDict())
        self.assertEqual(execution.result_arguments, {})

        expected_calls = [
            mock.call('output hash'),
            mock.call('output json hash')
        ]
        self.assertEqual(self._retrieve.mock_calls, expected_calls)
Exemple #28
0
  def testReadHistogramsJsonValueWithNoStory(self):
    hist = histogram_module.Histogram('hist', 'count')
    hist.AddSample(0)
    hist.AddSample(1)
    hist.AddSample(2)
    histograms = histogram_set.HistogramSet([hist])
    histograms.AddSharedDiagnostic(
        reserved_infos.STORIES.name,
        generic_set.GenericSet(['story']))

    self.SetOutputFileContents(histograms.AsDicts())

    quest = read_value.ReadHistogramsJsonValue(hist.name, None, 'story')
    execution = quest.Start(None, 'output hash')
    execution.Poll()

    self.assertReadValueSuccess(execution)
    self.assertEqual(execution.result_values, (0, 1, 2))
    self.assertRetrievedOutputJson()
  def testReadHistogramsJsonValueWithNoTirLabel(self):
    hist = histogram_module.Histogram('hist', 'count')
    hist.AddSample(0)
    hist.AddSample(1)
    hist.AddSample(2)
    histograms = histogram_set.HistogramSet([hist])
    histograms.AddSharedDiagnostic(
        reserved_infos.STORY_TAGS.name,
        generic_set.GenericSet(['group:tir_label']))

    self.SetOutputFileContents(histograms.AsDicts())

    quest = read_value.ReadHistogramsJsonValue(
        'chartjson-output.json', hist_name=hist.name, tir_label='tir_label')
    execution = quest.Start(None, 'server', 'output hash')
    execution.Poll()

    self.assertReadValueSuccess(execution)
    self.assertEqual(execution.result_values, (0, 1, 2))
    self.assertRetrievedOutputJson()
Exemple #30
0
    def testReadHistogramsJsonValueGroupingLabelOptional(self):
        hist = histogram_module.Histogram('hist:name:has:colons', 'count')
        hist.AddSample(0)
        hist.AddSample(1)
        hist.AddSample(2)
        histograms = histogram_set.HistogramSet([hist])
        histograms.AddSharedDiagnosticToAllHistograms(
            reserved_infos.STORY_TAGS.name,
            generic_set.GenericSet(['group:label']))
        histograms.AddSharedDiagnosticToAllHistograms(
            reserved_infos.STORIES.name,
            generic_set.GenericSet(['story:has:colons:too']))
        self.SetOutputFileContents(histograms.AsDicts())

        quest = read_value.ReadHistogramsJsonValue('chartjson-output.json',
                                                   hist.name, None,
                                                   'story:has:colons:too')
        execution = quest.Start(None, 'server', 'output hash')
        execution.Poll()

        self.assertReadValueSuccess(execution)
        self.assertEqual(execution.result_values, (0, 1, 2))
        self.assertRetrievedOutputJson()