def testNoLeakedTempFileOnImplicitCleanUp(self):
with trace.TraceValue(
None, trace_data.CreateTraceDataFromRawData([{
'test': 1
}])):
pass
self.assertTrue(_IsEmptyDir(self.temp_test_dir))
def testNoLeakedTempFileWhenUploadingTrace(self):
v = trace.TraceValue(
None, trace_data.CreateTraceDataFromRawData([{
'test': 1
}]))
v.CleanUp()
self.assertTrue(_IsEmptyDir(self.temp_test_dir))
def testRepr(self):
v = trace.TraceValue(self.pages[0],
trace_data.CreateTraceDataFromRawData([{
'test': 1
}]),
important=True,
description='desc')
self.assertEquals('TraceValue(http://www.bar.com/, trace)', str(v))
def testSerialize(self):
ri = trace_data.CreateTraceDataFromRawData({'traceEvents': [1, 2, 3]})
f = cStringIO.StringIO()
ri.Serialize(f)
d = f.getvalue()
self.assertIn('traceEvents', d)
self.assertIn('[1, 2, 3]', d)
json.loads(d)
def testSerialize(self):
test_dir = tempfile.mkdtemp()
trace_path = os.path.join(test_dir, 'test_trace.json')
try:
ri = trace_data.CreateTraceDataFromRawData({'traceEvents': [1, 2, 3]})
ri.Serialize(trace_path)
with open(trace_path) as f:
json_traces = html2trace.ReadTracesFromHTMLFile(f)
self.assertEqual(json_traces, [{'traceEvents': [1, 2, 3]}])
finally:
shutil.rmtree(test_dir)
def testNoTracesLeftAfterCleanUp(self):
results = page_test_results.PageTestResults()
v0 = trace.TraceValue(
None, trace_data.CreateTraceDataFromRawData([{
'test': 1
}]))
v1 = trace.TraceValue(
None, trace_data.CreateTraceDataFromRawData([{
'test': 2
}]))
results.WillRunPage(self.pages[0])
results.AddValue(v0)
results.DidRunPage(self.pages[0])
results.WillRunPage(self.pages[1])
results.AddValue(v1)
results.DidRunPage(self.pages[1])
results.CleanUp()
self.assertFalse(results.FindAllTraceValues())
def testCleanUpCleansUpTraceValues(self):
results = page_test_results.PageTestResults()
v0 = trace.TraceValue(
None, trace_data.CreateTraceDataFromRawData([{
'test': 1
}]))
v1 = trace.TraceValue(
None, trace_data.CreateTraceDataFromRawData([{
'test': 2
}]))
results.WillRunPage(self.pages[0])
results.AddValue(v0)
results.DidRunPage(self.pages[0])
results.WillRunPage(self.pages[1])
results.AddValue(v1)
results.DidRunPage(self.pages[1])
results.CleanUp()
self.assertTrue(v0.cleaned_up)
self.assertTrue(v1.cleaned_up)
def testTraceValue(self):
results = page_test_results.PageTestResults()
results.WillRunPage(self.pages[0])
results.AddValue(
trace.TraceValue(
None, trace_data.CreateTraceDataFromRawData([[{
'test': 1
}]])))
results.DidRunPage(self.pages[0])
results.WillRunPage(self.pages[1])
results.AddValue(
trace.TraceValue(
None, trace_data.CreateTraceDataFromRawData([[{
'test': 2
}]])))
results.DidRunPage(self.pages[1])
results.PrintSummary()
values = results.FindAllTraceValues()
self.assertEquals(2, len(values))
def testMultiplePagesAndValues(self, cs_insert_mock):
cs_insert_mock.return_value = 'https://cloud_storage_url/foo'
trace_value = trace.TraceValue(
None, trace_data.CreateTraceDataFromRawData('{"traceEvents": []}'))
trace_value.UploadToCloud(bucket='foo')
self.SimulateBenchmarkRun([
(self._story_set[0], [
scalar.ScalarValue(
None,
'foo',
'seconds',
4,
improvement_direction=improvement_direction.DOWN)
]),
(self._story_set[1], [
scalar.ScalarValue(
None,
'foo',
'seconds',
3.4,
improvement_direction=improvement_direction.DOWN),
trace_value,
scalar.ScalarValue(
None,
'bar',
'km',
10,
improvement_direction=improvement_direction.DOWN),
scalar.ScalarValue(
None,
'baz',
'count',
5,
improvement_direction=improvement_direction.DOWN)
])
])
# Parse CSV output into list of lists.
csv_string = self.Format()
lines = csv_string.split(self._LINE_SEPARATOR)
values = [s.split(',') for s in lines[1:-1]]
self.assertEquals(len(values), 5) # We expect 5 value in total.
self.assertEquals(len(set((v[1] for v in values))), 2) # 2 pages.
self.assertEquals(len(set((v[2] for v in values))),
4) # 4 value names.
self.assertEquals(values[2], [
'story_set', 'http://www.bar.com/', 'trace',
'https://cloud_storage_url/foo', '', '1'
])
def testTraceSerializationContainStoryName(self):
tempdir = tempfile.mkdtemp()
try:
v = trace.TraceValue(
self.pages[0],
trace_data.CreateTraceDataFromRawData([{
'test': 1
}]))
fh = v.Serialize(tempdir)
self.assertTrue(
os.path.basename(
fh.GetAbsPath()).startswith('http___www_bar_com'))
finally:
shutil.rmtree(tempdir)
def testAsChartDictWithTraceValuesThatHasTirLabel(self):
v = trace.TraceValue(
self._story_set[0],
trace_data.CreateTraceDataFromRawData([{
'test': 1
}]))
v.tir_label = 'background'
d = chart_json_output_formatter.ResultsAsChartDict(
self._benchmark_metadata,
page_specific_values=[v],
summary_values=[v])
self.assertTrue('trace' in d['charts'])
self.assertTrue('http://www.foo.com/' in d['charts']['trace'],
msg=d['charts']['trace'])
self.assertTrue(d['enabled'])
def testAsDictWhenTraceSerializedAndUploaded(self):
tempdir = tempfile.mkdtemp()
try:
v = trace.TraceValue(
None, trace_data.CreateTraceDataFromRawData([{
'test': 1
}]))
fh = v.Serialize(tempdir)
# pylint: disable=no-member
trace.cloud_storage.SetCalculatedHashesForTesting(
{fh.GetAbsPath(): 123})
# pylint: enable=no-member
bucket = trace.cloud_storage.PUBLIC_BUCKET
cloud_url = v.UploadToCloud(bucket)
d = v.AsDict()
self.assertEqual(d['file_id'], fh.id)
self.assertEqual(d['cloud_url'], cloud_url)
finally:
shutil.rmtree(tempdir)
def testSerializeZip(self):
data = trace_data.CreateTraceDataFromRawData({
'traceEvents': [1, 2, 3],
'powerTraceAsString':
'battor_data'
})
tf = tempfile.NamedTemporaryFile(delete=False)
temp_name = tf.name
tf.close()
try:
data.Serialize(temp_name, gzip_result=True)
self.assertTrue(zipfile.is_zipfile(temp_name))
z = zipfile.ZipFile(temp_name, 'r')
self.assertIn('powerTraceAsString', z.namelist())
self.assertIn('traceEvents', z.namelist())
z.close()
finally:
os.remove(temp_name)
def testAsDictWhenTraceIsNotSerializedAndUploaded(self):
test_temp_file = tempfile.NamedTemporaryFile(delete=False)
try:
v = trace.TraceValue(
None, trace_data.CreateTraceDataFromRawData([{
'test': 1
}]))
# pylint: disable=no-member
trace.cloud_storage.SetCalculatedHashesForTesting(
TestDefaultDict(123))
# pylint: enable=no-member
bucket = trace.cloud_storage.PUBLIC_BUCKET
cloud_url = v.UploadToCloud(bucket)
d = v.AsDict()
self.assertEqual(d['cloud_url'], cloud_url)
finally:
if os.path.exists(test_temp_file.name):
test_temp_file.close()
os.remove(test_temp_file.name)
def testAsDictWithTraceValue(self):
tempdir = tempfile.mkdtemp()
try:
results = page_test_results.PageTestResults()
results.WillRunPage(self._story_set[0])
v0 = trace.TraceValue(
results.current_page,
trace_data.CreateTraceDataFromRawData([{'event': 'test'}]))
results.AddValue(v0)
results.DidRunPage(self._story_set[0])
results._SerializeTracesToDirPath(tempdir)
d = json_output_formatter.ResultsAsDict(results,
self._formatter.benchmark_metadata)
self.assertTrue(_HasPage(d['pages'], self._story_set[0]))
self.assertTrue(_HasValueNamed(d['per_page_values'], 'trace'))
self.assertEquals(len(d['files']), 1)
output_trace_path = d['files'].values()[0]
self.assertTrue(output_trace_path.startswith(tempdir))
self.assertTrue(os.path.exists(output_trace_path))
finally:
shutil.rmtree(tempdir)
def testFindTraceParts(self):
raw_data = {
'powerTraceAsString': 'BattOr Data',
'traceEvents': [{
'trace': 1
}],
'tabIds': 'Tab Data',
}
data = trace_data.CreateTraceDataFromRawData(raw_data)
v = trace.TraceValue(None, data)
tempdir = tempfile.mkdtemp()
temp_path = os.path.join(tempdir, 'test.json')
battor_seen = False
chrome_seen = False
tabs_seen = False
try:
with codecs.open(v.filename, mode='r', encoding='utf-8') as f:
trace_files = html2trace.CopyTraceDataFromHTMLFilePath(
f, temp_path)
for f in trace_files:
with open(f, 'r') as trace_file:
d = trace_file.read()
print d
if d == raw_data['powerTraceAsString']:
self.assertFalse(battor_seen)
battor_seen = True
elif d == json.dumps(
{'traceEvents': raw_data['traceEvents']}):
self.assertFalse(chrome_seen)
chrome_seen = True
elif d == raw_data['tabIds']:
self.assertFalse(tabs_seen)
tabs_seen = True
self.assertTrue(battor_seen)
self.assertTrue(chrome_seen)
self.assertTrue(tabs_seen)
finally:
shutil.rmtree(tempdir)
os.remove(v.filename)
def testInvalidTrace(self):
with self.assertRaises(AssertionError):
trace_data.CreateTraceDataFromRawData({'hello': 1})
def testStringForm(self):
d = trace_data.CreateTraceDataFromRawData('[{"ph": "B"}]')
self.assertTrue(d.HasTracesFor(trace_data.CHROME_TRACE_PART))
events = d.GetTracesFor(trace_data.CHROME_TRACE_PART)[0].get(
'traceEvents', [])
self.assertEquals(1, len(events))
def testListForm(self):
d = trace_data.CreateTraceDataFromRawData([{'ph': 'B'}])
self.assertTrue(d.HasTracesFor(trace_data.CHROME_TRACE_PART))
events = d.GetTracesFor(trace_data.CHROME_TRACE_PART)[0].get(
'traceEvents', [])
self.assertEquals(1, len(events))
def testEmptyImport(self):
model_module.TimelineModel(trace_data.CreateTraceDataFromRawData({}))
def testEmptyArrayValue(self):
# We can import empty lists and empty string.
d = trace_data.CreateTraceDataFromRawData([])
self.assertFalse(d.HasTracesFor(trace_data.CHROME_TRACE_PART))
