def SetUpCycler(self, args, setup_memory_module=False):
cycler = page_cycler.PageCycler()
options = browser_options.BrowserFinderOptions()
options.browser_options.platform = FakePlatform()
parser = options.CreateParser()
page_runner.AddCommandLineArgs(parser)
cycler.AddCommandLineArgs(parser)
cycler.SetArgumentDefaults(parser)
parser.parse_args(args)
page_runner.ProcessCommandLineArgs(parser, options)
cycler.ProcessCommandLineArgs(parser, options)
cycler.CustomizeBrowserOptions(options.browser_options)
if setup_memory_module:
# Mock out memory metrics; the real ones require a real browser.
mock_memory_metric = MockMemoryMetric()
mock_memory_module = simple_mock.MockObject()
mock_memory_module.ExpectCall('MemoryMetric').WithArgs(
simple_mock.DONT_CARE).WillReturn(mock_memory_metric)
real_memory_module = page_cycler.memory
try:
page_cycler.memory = mock_memory_module
browser = FakeBrowser()
cycler.WillStartBrowser(options.browser_options.platform)
cycler.DidStartBrowser(browser)
finally:
page_cycler.memory = real_memory_module
return cycler
def RunMeasurement(self,
measurement,
ps,
expectations=test_expectations.TestExpectations(),
options=None):
"""Runs a measurement against a pageset, returning the rows its outputs."""
if options is None:
options = options_for_unittests.GetCopy()
assert options
temp_parser = options.CreateParser()
page_runner.AddCommandLineArgs(temp_parser)
measurement.AddCommandLineArgs(temp_parser)
measurement.SetArgumentDefaults(temp_parser)
defaults = temp_parser.get_default_values()
for k, v in defaults.__dict__.items():
if hasattr(options, k):
continue
setattr(options, k, v)
measurement.CustomizeBrowserOptions(options)
options.output_file = None
options.output_format = 'none'
options.output_trace_tag = None
page_runner.ProcessCommandLineArgs(temp_parser, options)
measurement.ProcessCommandLineArgs(temp_parser, options)
return page_runner.Run(measurement, ps, expectations, options)
def ParseCommandLine(self, args, env):
self._options = browser_options.BrowserFinderOptions()
self._parser = self._options.CreateParser(
'%%prog [options] %s page_set' % self.test_class_name)
test_constructors = self.FindTestConstructors(env.base_paths)
test_name = self.FindTestName(test_constructors, args)
test = None
if test_name:
test = test_constructors[test_name]()
if isinstance(test, test_module.Test):
page_test = test.test()
test.AddCommandLineArgs(self._parser)
else:
page_test = test
page_test.AddCommandLineArgs(self._parser)
page_runner.AddCommandLineArgs(self._parser)
_, self._args = self._parser.parse_args()
if len(self._args) < 1:
error_message = 'No %s specified.\nAvailable %ss:\n' % (
self.test_class_name, self.test_class_name)
test_list_string = ',\n'.join(sorted(test_constructors.keys()))
self.PrintParseError(error_message + test_list_string)
if not test:
error_message = 'No %s named %s.\nAvailable %ss:\n' % (
self.test_class_name, self._args[0], self.test_class_name)
test_list_string = ',\n'.join(sorted(test_constructors.keys()))
self.PrintParseError(error_message + test_list_string)
if isinstance(test, test_module.Test):
ps = test.CreatePageSet(self._options)
expectations = test.CreateExpectations(ps)
test.ProcessCommandLineArgs(self._parser, self._options)
else:
ps = self.GetPageSet(env)
expectations = test.CreateExpectations(ps)
page_test.ProcessCommandLineArgs(self._parser, self._options)
page_runner.ProcessCommandLineArgs(self._parser, self._options)
if len(self._args) > 2:
self.PrintParseError('Too many arguments.')
return page_test, ps, expectations
def ProcessCommandLineArgs(parser, args):
page_runner.ProcessCommandLineArgs(parser, args)
if not args.profile_type_to_generate:
parser.error("Must specify --profile-type-to-generate option.")
profile_creators = _DiscoverProfileCreatorClasses().keys()
if args.profile_type_to_generate not in profile_creators:
legal_profile_creators = '|'.join(profile_creators)
parser.error("Invalid profile type, legal values are: %s." %
legal_profile_creators)
if not args.browser_type:
parser.error("Must specify --browser option.")
if not args.output_dir:
parser.error("Must specify --output-dir option.")
if args.browser_options.dont_override_profile:
parser.error("Can't use existing profile when generating profile.")
def SetUpPageRunnerArguments(options):
parser = options.CreateParser()
page_runner.AddCommandLineArgs(parser)
options.MergeDefaultValues(parser.get_default_values())
page_runner.ProcessCommandLineArgs(parser, options)
def Main(base_dir):
measurements = {
n: cls
for n, cls in discover.DiscoverClasses(
base_dir, base_dir, page_measurement.PageMeasurement).items()
# Filter out unneeded ProfileCreators (crbug.com/319573).
if not issubclass(cls, profile_creator.ProfileCreator)
}
tests = discover.DiscoverClasses(base_dir,
base_dir,
test.Test,
index_by_class_name=True)
options = browser_options.BrowserFinderOptions()
parser = options.CreateParser('%prog <PageSet|Test|URL>')
page_runner.AddCommandLineArgs(parser)
recorder = RecordPage(measurements)
recorder.AddCommandLineArgs(parser)
quick_args = [a for a in sys.argv[1:] if not a.startswith('-')]
if len(quick_args) != 1:
parser.print_usage()
sys.exit(1)
target = quick_args[0]
if target in tests:
recorder.test = tests[target]().test()
recorder.test.AddCommandLineArgs(parser)
recorder.test.SetArgumentDefaults(parser)
parser.parse_args()
recorder.test.ProcessCommandLineArgs(parser, options)
ps = tests[target]().CreatePageSet(options)
elif discover.IsPageSetFile(target):
parser.parse_args()
ps = page_set.PageSet.FromFile(target)
else:
parser.print_usage()
sys.exit(1)
page_runner.ProcessCommandLineArgs(parser, options)
recorder.ProcessCommandLineArgs(parser, options)
expectations = test_expectations.TestExpectations()
# Set the archive path to something temporary.
temp_target_wpr_file_path = tempfile.mkstemp()[1]
ps.wpr_archive_info.AddNewTemporaryRecording(temp_target_wpr_file_path)
# Do the actual recording.
options.browser_options.wpr_mode = wpr_modes.WPR_RECORD
options.browser_options.no_proxy_server = True
recorder.CustomizeBrowserOptions(options)
results = page_runner.Run(recorder, ps, expectations, options)
if results.errors or results.failures:
logging.warning(
'Some pages failed. The recording has not been updated for '
'these pages.')
logging.warning('Failed pages:\n%s',
'\n'.join(zip(*results.errors + results.failures)[0]))
if results.skipped:
logging.warning('Some pages were skipped. The recording has not been '
'updated for these pages.')
logging.warning('Skipped pages:\n%s',
'\n'.join(zip(*results.skipped)[0]))
if results.successes:
# Update the metadata for the pages which were recorded.
ps.wpr_archive_info.AddRecordedPages(results.successes)
else:
os.remove(temp_target_wpr_file_path)
return min(255, len(results.failures))
def _ProcessCommandLineArgs(self):
page_runner.ProcessCommandLineArgs(self._parser, self._options)
if self._benchmark is not None:
self._benchmark.ProcessCommandLineArgs(self._parser, self._options)
def ProcessCommandLineArgs(parser, args):
page_runner.ProcessCommandLineArgs(parser, args)
