def testAsDict(self):
result = mre_result.MreResult()
with map_single_trace.TemporaryMapScript("""
tr.mre.FunctionRegistry.register(
function MyMapFunction(result, model) {
var canonicalUrl = model.canonicalUrl;
result.addPair('result', {
numProcesses: model.getAllProcesses().length
});
});
""") as map_script:
module = function_handle.ModuleToLoad(filename=map_script.filename)
map_handle = function_handle.FunctionHandle(
modules_to_load=[module], function_name='MyMapFunction')
job = job_module.Job(map_handle, None)
failure = failure_module.Failure(job, '2', '3', 'err', 'desc',
'stack')
result.AddFailure(failure)
result.AddPair('foo', 'bar')
result_dict = result.AsDict()
self.assertEquals(result_dict['failures'], [failure.AsDict()])
self.assertEquals(result_dict['pairs'], {'foo': 'bar'})
def testAsDict(self):
map_function_handle = _SingleFileFunctionHandle('foo.html', 'Foo', '2')
job = job_module.Job(map_function_handle, '1')
failure = failure_module.Failure(job, 'foo.html:Foo',
'file://foo.html', 'err', 'desc',
'stack')
self.assertEquals(
failure.AsDict(), {
'job_guid': '1',
'function_handle_string': 'foo.html:Foo',
'trace_canonical_url': 'file://foo.html',
'type': 'err',
'description': 'desc',
'stack': 'stack'
})
def testComputeTBMv2MetricsFailure(self):
in_results = testing.IntermediateResults([
testing.TestResult(
'benchmark/story1',
output_artifacts={
compute_metrics.HTML_TRACE_NAME:
testing.Artifact('/trace1.html', 'gs://trace1.html')
},
tags=['tbmv2:metric1'],
),
])
metrics_result = mre_result.MreResult()
metrics_result.AddFailure(failure.Failure(job.Job(0), 0, 0, 0, 0, 0))
with mock.patch(GETSIZE_METHOD) as getsize_mock:
with mock.patch(RUN_METRICS_METHOD) as run_metrics_mock:
getsize_mock.return_value = 100
run_metrics_mock.return_value = metrics_result
histogram_dicts = compute_metrics.ComputeTBMv2Metrics(
in_results)
self.assertEqual(histogram_dicts, [])
self.assertEqual(in_results['testResults'][0]['status'], 'FAIL')
def MapSingleTrace(trace_handle, job, extra_import_options=None, timeout=None):
assert (isinstance(
extra_import_options,
(type(None),
dict))), ('extra_import_options should be a dict or None.')
project = tracing_project.TracingProject()
all_source_paths = list(project.source_paths)
all_source_paths.append(project.trace_processor_root_path)
result = mre_result.MreResult()
with trace_handle.PrepareFileForProcessing() as prepared_trace_handle:
js_args = [
json.dumps(prepared_trace_handle.AsDict()),
json.dumps(job.AsDict()),
]
if extra_import_options:
js_args.append(json.dumps(extra_import_options))
# Use 8gb heap space to make sure we don't OOM'ed on big trace, but not
# on ARM devices since we use 32-bit d8 binary.
if platform.machine() == 'armv7l' or platform.machine() == 'aarch64':
v8_args = None
else:
v8_args = ['--max-old-space-size=8192']
try:
res = vinn.RunFile(_MAP_SINGLE_TRACE_CMDLINE_PATH,
source_paths=all_source_paths,
js_args=js_args,
v8_args=v8_args,
timeout=timeout)
except RuntimeError as e:
result.AddFailure(
failure.Failure(job, trace_handle.canonical_url, 'Error',
'vinn runtime error while mapping trace.',
e.message, 'Unknown stack'))
return result
stdout = res.stdout
if not isinstance(stdout, str):
stdout = stdout.decode('utf-8', errors='replace')
if res.returncode != 0:
sys.stderr.write(stdout)
result.AddFailure(
failure.Failure(job, trace_handle.canonical_url, 'Error',
'vinn runtime error while mapping trace.',
'vinn runtime error while mapping trace.',
'Unknown stack'))
return result
for line in stdout.split('\n'):
m = re.match('^MRE_RESULT: (.+)', line, re.DOTALL)
if m:
found_dict = json.loads(m.group(1))
failures = [
failure.Failure.FromDict(f, job,
_FAILURE_NAME_TO_FAILURE_CONSTRUCTOR)
for f in found_dict['failures']
]
for f in failures:
result.AddFailure(f)
for k, v in found_dict['pairs'].items():
result.AddPair(k, v)
else:
if len(line) > 0:
sys.stderr.write(line)
sys.stderr.write('\n')
if not (len(result.pairs) or len(result.failures)):
raise InternalMapError('Internal error: No results were produced!')
return result
