def testAddReservedDiagnostics_TagmapsMerged(self):
hs1 = histogram_set.HistogramSet([self._CreateHistogram('foo1')])
hs1.AddSharedDiagnostic(
reserved_infos.TAG_MAP.name,
histogram.TagMap({'tagsToStoryNames': {
'foo1': ['bar1']
}}))
hs2 = histogram_set.HistogramSet([self._CreateHistogram('foo1')])
hs2.AddSharedDiagnostic(
reserved_infos.TAG_MAP.name,
histogram.TagMap({'tagsToStoryNames': {
'foo1': ['bar2']
}}))
hs = histogram_set.HistogramSet()
hs.ImportDicts(hs1.AsDicts())
hs.ImportDicts(hs2.AsDicts())
new_hs_json = add_reserved_diagnostics.AddReservedDiagnostics(
hs.AsDicts(), {'benchmarks': 'bar'})
new_hs = histogram_set.HistogramSet()
new_hs.ImportDicts(json.loads(new_hs_json))
d = [h.diagnostics[reserved_infos.TAG_MAP.name] for h in new_hs]
self.assertEqual(d[0], d[1])
def testInequality(self):
tags0 = {
'tag1': ['path1', 'path2'],
'tag2': ['path1', 'path2', 'path3']
}
tags1 = {'tag1': ['path1', 'path2']}
info0 = histogram.TagMap({'tagsToStoryNames': tags0})
info1 = histogram.TagMap({'tagsToStoryNames': tags1})
self.assertNotEqual(info0, info1)
def testCaseTags(self):
external_key = namespaced_stored_object.NamespaceKey(
update_test_suites.TEST_SUITES_2_CACHE_KEY,
datastore_hooks.EXTERNAL)
stored_object.Set(external_key, ['suite'])
testing_common.AddTests(['master'], ['a', 'b'], {
'suite': {
'measurement': {
'x': {},
'y': {},
'z': {},
},
},
})
for bot in 'ab':
for case in 'xyz':
test = utils.TestKey('master/%s/suite/measurement/%s' %
(bot, case)).get()
test.has_rows = True
test.put()
histogram.SparseDiagnostic(test=utils.TestKey('master/a/suite'),
name=reserved_infos.TAG_MAP.name,
end_revision=sys.maxint,
data=histogram_module.TagMap({
'tagsToStoryNames': {
'j': ['x']
}
}).AsDict()).put()
histogram.SparseDiagnostic(test=utils.TestKey('master/b/suite'),
name=reserved_infos.TAG_MAP.name,
end_revision=sys.maxint,
data=histogram_module.TagMap({
'tagsToStoryNames': {
'j': ['y'],
'k': ['y']
}
}).AsDict()).put()
self.Post('/update_test_suite_descriptors')
self.ExecuteDeferredTasks('default')
expected = {
'measurements': ['measurement'],
'bots': ['master:a', 'master:b'],
'cases': ['x', 'y', 'z'],
'caseTags': {
'j': ['x', 'y'],
'k': ['y']
},
}
actual = update_test_suite_descriptors.FetchCachedTestSuiteDescriptor(
'suite')
self.assertEqual(expected, actual)
def testMerge(self):
t0 = histogram.TagMap({
'tagsToStoryNames': {
'press': ['story0', 'story1'],
'desktop': ['story0', 'story1', 'story2']
}})
t1 = histogram.TagMap({
'tagsToStoryNames': {
'press': ['story3', 'story4'],
'android': ['story3', 'story4', 'story5']
}})
self.assertFalse(t0.CanAddDiagnostic(
histogram.Generic(''), None, None, None))
self.assertTrue(t0.CanAddDiagnostic(t1, None, None, None))
m0 = histogram.Diagnostic.FromDict(t0.AsDict())
self.assertTrue(isinstance(m0, histogram.TagMap))
self.assertFalse(
m0.CanAddDiagnostic(histogram.Generic(''), None, None, None))
self.assertTrue(m0.CanAddDiagnostic(t1, None, None, None))
m0.AddDiagnostic(t1, None, None, None)
m1 = histogram.Diagnostic.FromDict(t1.AsDict())
m1.AddDiagnostic(t0, None, None, None)
self.assertDictEqual(m0.AsDict(), m1.AsDict())
m2 = histogram.Diagnostic.FromDict(t1.AsDict())
self.assertNotEqual(m2.AsDict(), m0.AsDict())
# Test round-tripping of merged diagnostic
clone = histogram.Diagnostic.FromDict(m0.AsDict())
self.assertSetEqual(
set(clone.tags_to_story_names.keys()),
set(['press', 'desktop', 'android']))
self.assertSetEqual(
clone.tags_to_story_names.get('press'),
set(['story0', 'story1', 'story3', 'story4']))
self.assertSetEqual(
clone.tags_to_story_names.get('desktop'),
set(['story0', 'story1', 'story2']))
self.assertSetEqual(
clone.tags_to_story_names.get('android'),
set(['story3', 'story4', 'story5']))
def _QueryCaseTags(test_suite, bots):
test_paths = set()
for bot in bots:
desc = descriptor.Descriptor(test_suite=test_suite, bot=bot)
for test_path in desc.ToTestPathsSync():
test_paths.add(test_path)
futures = []
for test_path in test_paths:
futures.append(
histogram.SparseDiagnostic.GetMostRecentDataByNamesAsync(
utils.TestKey(test_path), [reserved_infos.TAG_MAP.name]))
ndb.Future.wait_all(futures)
tag_map = histogram_module.TagMap({})
for future in futures:
data = future.get_result().get(reserved_infos.TAG_MAP.name)
if not data:
continue
tag_map.AddDiagnostic(histogram_module.TagMap.FromDict(data))
return {
tag: list(sorted(cases))
for tag, cases in tag_map.tags_to_story_names.iteritems()
}
def AddTagAndStoryDisplayName(self):
tagmap = histogram.TagMap({})
self.assertDictEqual({}, tagmap.tags_to_story_names)
tagmap.AddTagAndStoryDisplayName('foo', 'bar')
self.assertListEqual(['foo'], tagmap.tags_to_story_names.keys())
self.assertSetEqual(set(['bar']), tagmap.tags_to_story_names['foo'])
tagmap.AddTagAndStoryDisplayName('foo', 'bar2')
self.assertListEqual(['foo'], tagmap.tags_to_story_names.keys())
self.assertSetEqual(set(['bar', 'bar2']),
tagmap.tags_to_story_names['foo'])
def testRoundtrip(self):
tags = {
'tag1': ['path1', 'path2', 'path3'],
'tag2': ['path1', 'path4'],
'tag3': ['path5'],
}
info = histogram.TagMap({'tagsToStoryNames': tags})
d = info.AsDict()
clone = diagnostic.Diagnostic.FromDict(d)
self.assertEqual(ToJSON(d), ToJSON(clone.AsDict()))
self.assertSetEqual(clone.tags_to_story_names['tag1'],
set(tags['tag1']))
self.assertSetEqual(clone.tags_to_story_names['tag2'],
set(tags['tag2']))
self.assertSetEqual(clone.tags_to_story_names['tag3'],
set(tags['tag3']))
def _GenerateTagMapFromStorySet(stories):
tagmap = histogram.TagMap({})
for s in stories:
for t in s.tags:
tagmap.AddTagAndStoryDisplayName(t, s.name)
return tagmap
