def testAddReservedDiagnostics_TagmapsMerged(self):
hs1 = histogram_set.HistogramSet([self._CreateHistogram('foo1')])
hs1.AddSharedDiagnosticToAllHistograms(
reserved_infos.TAG_MAP.name,
tag_map.TagMap({'tagsToStoryNames': {
'foo1': ['bar1']
}}))
hs2 = histogram_set.HistogramSet([self._CreateHistogram('foo1')])
hs2.AddSharedDiagnosticToAllHistograms(
reserved_infos.TAG_MAP.name,
tag_map.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 = tag_map.TagMap({'tagsToStoryNames': tags0})
info1 = tag_map.TagMap({'tagsToStoryNames': tags1})
self.assertNotEqual(info0, info1)
def testMerge(self):
t0 = tag_map.TagMap({
'tagsToStoryNames': {
'press': ['story0', 'story1'],
'desktop': ['story0', 'story1', 'story2']
}})
t1 = tag_map.TagMap({
'tagsToStoryNames': {
'press': ['story3', 'story4'],
'android': ['story3', 'story4', 'story5']
}})
self.assertFalse(t0.CanAddDiagnostic(generic_set.GenericSet([])))
self.assertTrue(t0.CanAddDiagnostic(t1))
m0 = diagnostic.Diagnostic.FromDict(t0.AsDict())
self.assertTrue(isinstance(m0, tag_map.TagMap))
self.assertFalse(
m0.CanAddDiagnostic(generic_set.GenericSet([])))
self.assertTrue(m0.CanAddDiagnostic(t1))
m0.AddDiagnostic(t1)
m1 = diagnostic.Diagnostic.FromDict(t1.AsDict())
m1.AddDiagnostic(t0)
self.assertDictEqual(_SortStories(m0.AsDict()), _SortStories(m1.AsDict()))
m2 = diagnostic.Diagnostic.FromDict(t1.AsDict())
self.assertNotEqual(_SortStories(m2.AsDict()), _SortStories(m0.AsDict()))
# Test round-tripping of merged diagnostic
clone = diagnostic.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 AddTagAndStoryDisplayName(self):
tagmap = tag_map.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 = tag_map.TagMap({'tagsToStoryNames': tags})
d = info.AsDict()
clone = diagnostic.Diagnostic.FromDict(d)
self.assertEqual(histogram_unittest.ToJSON(_SortStories(d)),
histogram_unittest.ToJSON(_SortStories(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 _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 = tag_map_module.TagMap({})
for future in futures:
data = future.get_result().get(reserved_infos.TAG_MAP.name)
if not data:
continue
tag_map.AddDiagnostic(tag_map_module.TagMap.FromDict(data))
return {tag: list(sorted(cases))
for tag, cases in tag_map.tags_to_story_names.iteritems()}
def _GenerateTagMapFromStorySet(stories):
tagmap = tag_map.TagMap({})
for s in stories:
for t in s.tags:
tagmap.AddTagAndStoryDisplayName(t, s.name)
return tagmap
