def testAsDict(self):
mtl0 = function_handle.ModuleToLoad(href='/foo')
mtl1 = function_handle.ModuleToLoad(filename='foo.html')
self.assertEquals(mtl0.AsDict(), {'href': '/foo'})
self.assertEquals(mtl1.AsDict(), {'filename': 'foo.html'})
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 testRepr(self):
module = function_handle.ModuleToLoad(href='/foo')
handle = function_handle.FunctionHandle([module], 'Bar')
self.assertEquals(
str(handle),
'FunctionHandle(modules_to_load=[ModuleToLoad(href="/foo")], '
'function_name="Bar")')
def testAsDict(self):
module = function_handle.ModuleToLoad(href='/foo')
handle = function_handle.FunctionHandle([module], 'Bar')
self.assertEquals(handle.AsDict(), {
'modules_to_load': [{
'href': '/foo'
}],
'function_name': 'Bar'
})
def _GetMetricRunnerHandle(metrics):
assert isinstance(metrics, list)
for metric in metrics:
assert isinstance(metric, StringTypes)
metrics_dir = _GetMetricsDir()
metric_mapper_path = os.path.join(metrics_dir, _METRIC_MAP_FUNCTION_FILENAME)
modules_to_load = [function_handle.ModuleToLoad(filename=metric_mapper_path)]
options = {'metrics': metrics}
map_function_handle = function_handle.FunctionHandle(
modules_to_load, _METRIC_MAP_FUNCTION_NAME, options)
return job_module.Job(map_function_handle, None)
def ExecuteTraceMappingCode(trace_file_path,
process_trace_func_code,
extra_import_options=None,
trace_canonical_url=None):
"""Execute |process_trace_func_code| on the input |trace_file_path|.
process_trace_func_code must contain a function named 'process_trace' with
signature as follows:
function processTrace(results, model) {
// call results.addPair(<key>, <value>) to add data to results object.
}
Whereas results is an instance of tr.mre.MreResult, and model is an instance
of tr.model.Model which was resulted from parsing the input trace.
Returns:
This function returns the dictionay that represents data collected in
|results|.
Raises:
RuntimeError if there is any error with execute trace mapping code.
"""
with TemporaryMapScript("""
//# sourceURL=processTrace
%s;
tr.mre.FunctionRegistry.register(processTrace);
""" % process_trace_func_code) as map_script:
handle = function_handle.FunctionHandle(
[function_handle.ModuleToLoad(filename=map_script.filename)],
function_name='processTrace')
mapping_job = job_module.Job(handle)
trace_file_path = os.path.abspath(trace_file_path)
if not trace_canonical_url:
trace_canonical_url = 'file://%s' % trace_file_path
trace_handle = file_handle.URLFileHandle(trace_file_path,
trace_canonical_url)
results = MapSingleTrace(trace_handle, mapping_job,
extra_import_options)
if results.failures:
raise RuntimeError('Failures mapping trace:\n%s' %
('\n'.join(str(f) for f in results.failures)))
return results.pairs
def _Handle(filename):
module = function_handle.ModuleToLoad(filename=filename)
map_handle = function_handle.FunctionHandle(modules_to_load=[module],
function_name='MyMapFunction')
return job_module.Job(map_handle, None)
def _SingleFileFunctionHandle(filename, function_name, guid):
return function_handle.FunctionHandle(
modules_to_load=[function_handle.ModuleToLoad(filename=filename)],
function_name=function_name,
guid=guid)
def testRepr(self):
mtl0 = function_handle.ModuleToLoad(href='/foo')
mtl1 = function_handle.ModuleToLoad(filename='foo.html')
self.assertEquals(str(mtl0), 'ModuleToLoad(href="/foo")')
self.assertEquals(str(mtl1), 'ModuleToLoad(filename="foo.html")')
def testExactlyOneHrefOrFilename(self):
with self.assertRaises(Exception):
function_handle.ModuleToLoad()
with self.assertRaises(Exception):
function_handle.ModuleToLoad('foo', 'foo')
