def Run(self, args):
if args.json_output_file:
possible_browser = browser_finder.FindBrowser(args)
if args.browser_type in (
'exact', 'release', 'release_x64', 'debug', 'debug_x64', 'canary'):
args.browser_type = 'reference'
possible_reference_browser = browser_finder.FindBrowser(args)
else:
possible_reference_browser = None
with open(args.json_output_file, 'w') as f:
f.write(_GetJsonTestList(possible_browser, possible_reference_browser,
args.tests, args.num_shards))
else:
_PrintTestList(args.tests)
return 0
def testOneTab(self):
ps = page_set.PageSet()
page = page_module.Page(
'file:///' +
os.path.join('..', '..', 'unittest_data', 'blank.html'),
ps,
base_dir=os.path.dirname(__file__))
ps.pages.append(page)
class TestOneTab(page_test.PageTest):
def __init__(self,
test_method_name,
action_name_to_run='',
needs_browser_restart_after_each_run=False):
super(TestOneTab,
self).__init__(test_method_name, action_name_to_run,
needs_browser_restart_after_each_run)
self._browser = None
def SetUpBrowser(self, browser):
self._browser = browser
self._browser.tabs.New()
def RunTest(self, page, tab, results): # pylint: disable=W0613,R0201
assert len(self._browser.tabs) == 1
test = TestOneTab('RunTest')
with page_runner.PageRunner(ps) as runner:
options = options_for_unittests.GetCopy()
possible_browser = browser_finder.FindBrowser(options)
results = page_test.PageTestResults()
runner.Run(options, possible_browser, test, results)
def testUserAgent(self):
ps = page_set.PageSet()
page = page_module.Page(
'file:///' +
os.path.join('..', '..', 'unittest_data', 'blank.html'),
ps,
base_dir=os.path.dirname(__file__))
ps.pages.append(page)
ps.user_agent_type = 'tablet'
class TestUserAgent(page_test.PageTest):
def RunTest(self, page, tab, results): # pylint: disable=W0613,R0201
actual_user_agent = tab.EvaluateJavaScript(
'window.navigator.userAgent')
expected_user_agent = user_agent.UA_TYPE_MAPPING['tablet']
assert actual_user_agent.strip() == expected_user_agent
# This is so we can check later that the test actually made it into this
# function. Previously it was timing out before even getting here, which
# should fail, but since it skipped all the asserts, it slipped by.
self.hasRun = True # pylint: disable=W0201
test = TestUserAgent('RunTest')
with page_runner.PageRunner(ps) as runner:
options = options_for_unittests.GetCopy()
possible_browser = browser_finder.FindBrowser(options)
results = page_test.PageTestResults()
runner.Run(options, possible_browser, test, results)
self.assertTrue(hasattr(test, 'hasRun') and test.hasRun)
def runCredentialsTest(
self, # pylint: disable=R0201
credentials_backend,
results):
ps = page_set.PageSet()
page = page_module.Page('http://www.google.com', ps)
page.credentials = "test"
ps.pages.append(page)
did_run = [False]
with tempfile.NamedTemporaryFile() as f:
f.write(SIMPLE_CREDENTIALS_STRING)
f.flush()
ps.credentials_path = f.name
class TestThatInstallsCredentialsBackend(page_test.PageTest):
def __init__(self, credentials_backend):
super(TestThatInstallsCredentialsBackend,
self).__init__('RunTest')
self._credentials_backend = credentials_backend
def SetUpBrowser(self, browser):
browser.credentials.AddBackend(self._credentials_backend)
def RunTest(self, page, tab, results): # pylint: disable=W0613,R0201
did_run[0] = True
test = TestThatInstallsCredentialsBackend(credentials_backend)
with page_runner.PageRunner(ps) as runner:
options = options_for_unittests.GetCopy()
possible_browser = browser_finder.FindBrowser(options)
runner.Run(options, possible_browser, test, results)
return did_run[0]
def testRunPageWithStartupUrl(self):
ps = page_set.PageSet()
expectations = test_expectations.TestExpectations()
expectations = test_expectations.TestExpectations()
page = page_module.Page(
'file://blank.html', ps, base_dir=util.GetUnittestDataDir(),
startup_url='about:blank')
ps.pages.append(page)
class Measurement(page_test.PageTest):
def __init__(self):
super(Measurement, self).__init__()
self.browser_restarted = False
def CustomizeBrowserOptionsForSinglePage(self, ps, options):
self.browser_restarted = True
super(Measurement, self).CustomizeBrowserOptionsForSinglePage(ps,
options)
def ValidateAndMeasurePage(self, page, tab, results):
pass
options = options_for_unittests.GetCopy()
options.page_repeat = 2
options.output_formats = ['none']
options.suppress_gtest_report = True
if not browser_finder.FindBrowser(options):
return
test = Measurement()
SetUpStoryRunnerArguments(options)
results = results_options.CreateResults(EmptyMetadataForTest(), options)
story_runner.Run(test, ps, expectations, options, results)
self.assertEquals('about:blank', options.browser_options.startup_url)
self.assertTrue(test.browser_restarted)
def ProcessCommandLineArgs(cls, parser, args):
if not args.positional_args:
possible_browser = (browser_finder.FindBrowser(args)
if args.browser_type else None)
_PrintBenchmarkList(_Benchmarks(), possible_browser)
sys.exit(-1)
input_benchmark_name = args.positional_args[0]
matching_benchmarks = _MatchBenchmarkName(input_benchmark_name)
if not matching_benchmarks:
print >> sys.stderr, 'No benchmark named "%s".' % input_benchmark_name
print >> sys.stderr
_PrintBenchmarkList(_Benchmarks(), None)
sys.exit(-1)
if len(matching_benchmarks) > 1:
print >> sys.stderr, ('Multiple benchmarks named "%s".' %
input_benchmark_name)
print >> sys.stderr, 'Did you mean one of these?'
print >> sys.stderr
_PrintBenchmarkList(matching_benchmarks, None)
sys.exit(-1)
benchmark_class = matching_benchmarks.pop()
if len(args.positional_args) > 1:
parser.error('Too many arguments.')
assert issubclass(
benchmark_class,
benchmark.Benchmark), ('Trying to run a non-Benchmark?!')
benchmark.ProcessCommandLineArgs(parser, args)
benchmark_class.ProcessCommandLineArgs(parser, args)
cls._benchmark = benchmark_class
def _CreateBrowser(self,
autotest_ext=False,
auto_login=True,
gaia_login=False,
username=None,
password=None):
"""Finds and creates a browser for tests. if autotest_ext is True,
also loads the autotest extension"""
options = options_for_unittests.GetCopy()
if autotest_ext:
extension_path = os.path.join(util.GetUnittestDataDir(),
'autotest_ext')
assert os.path.isdir(extension_path)
self._load_extension = extension_to_load.ExtensionToLoad(
path=extension_path,
browser_type=options.browser_type,
is_component=True)
options.extensions_to_load = [self._load_extension]
browser_to_create = browser_finder.FindBrowser(options)
self.assertTrue(browser_to_create)
browser_options = options.browser_options
browser_options.create_browser_with_oobe = True
browser_options.auto_login = auto_login
browser_options.gaia_login = gaia_login
if username is not None:
browser_options.username = username
if password is not None:
browser_options.password = password
return browser_to_create.Create(options)
def Main(args, start_dir, top_level_dir, runner=None):
"""Unit test suite that collects all test cases for telemetry."""
# Add unittest_data to the path so we can import packages from it.
util.AddDirToPythonPath(util.GetUnittestDataDir())
default_options = browser_options.BrowserFinderOptions()
default_options.browser_type = 'any'
parser = default_options.CreateParser('run_tests [options] [test names]')
parser.add_option('--repeat-count',
dest='run_test_repeat_count',
type='int',
default=1,
help='Repeats each a provided number of times.')
parser.add_option('-d',
'--also-run-disabled-tests',
dest='run_disabled_tests',
action='store_true',
default=False,
help='Ignore @Disabled and @Enabled restrictions.')
_, args = parser.parse_args(args)
if default_options.verbosity == 0:
logging.getLogger().setLevel(logging.WARN)
from telemetry.core import browser_finder
try:
browser_to_create = browser_finder.FindBrowser(default_options)
except browser_finder.BrowserFinderException, ex:
logging.error(str(ex))
return 1
def Main(args, start_dir, top_level_dir, runner=None):
"""Unit test suite that collects all test cases for telemetry."""
# Add unittest_data to the path so we can import packages from it.
unittest_data_dir = os.path.abspath(
os.path.join(os.path.dirname(__file__), '..', '..', 'unittest_data'))
sys.path.append(unittest_data_dir)
default_options = browser_options.BrowserOptions()
default_options.browser_type = 'any'
parser = default_options.CreateParser('run_tests [options] [test names]')
parser.add_option('--repeat-count',
dest='run_test_repeat_count',
type='int',
default=1,
help='Repeats each a provided number of times.')
parser.add_option('-d',
'--also-run-disabled-tests',
dest='run_disabled_tests',
action='store_true',
default=False,
help='Also run tests decorated with @DisabledTest.')
_, args = parser.parse_args(args)
logging_level = logging.getLogger().getEffectiveLevel()
if default_options.verbosity == 0:
logging.getLogger().setLevel(logging.WARN)
from telemetry.core import browser_finder
try:
browser_to_create = browser_finder.FindBrowser(default_options)
except browser_finder.BrowserFinderException, ex:
logging.error(str(ex))
return 1
def Main(args):
options = browser_options.BrowserFinderOptions()
parser = options.CreateParser('telemetry_perf_test.py')
options, args = parser.parse_args(args)
browser_to_create = browser_finder.FindBrowser(options)
assert browser_to_create
with browser_to_create.Create(options) as b:
tab = b.tabs[0]
# Measure round-trip-time for evaluate
times = []
for i in range(1000):
start = time.time()
tab.EvaluateJavaScript('%i * 2' % i)
times.append(time.time() - start)
N = float(len(times))
avg = sum(times, 0.0) / N
squared_diffs = [(t - avg) * (t - avg) for t in times]
stdev = sum(squared_diffs, 0.0) / (N - 1)
times.sort()
percentile_75 = times[int(0.75 * N)]
print "%s: avg=%f; stdev=%f; min=%f; 75th percentile = %f" % (
"Round trip time (seconds)", avg, stdev, min(times), percentile_75)
return 0
def testBasicHostingAndRangeRequests(self):
options = options_for_unittests.GetCopy()
browser_to_create = browser_finder.FindBrowser(options)
with browser_to_create.Create() as b:
b.Start()
b.SetHTTPServerDirectories(util.GetUnittestDataDir())
t = b.tabs[0]
t.Navigate(b.http_server.UrlOf('/blank.html'))
t.WaitForDocumentReadyStateToBeComplete()
x = t.EvaluateJavaScript('document.body.innerHTML')
x = x.strip()
# Test basic html hosting.
self.assertEquals(x, 'Hello world')
file_size = self.test_file_size
last_byte = file_size - 1
# Test byte range request: no end byte.
self.CheckContentHeaders(b, t, '0-', '0-%d' % last_byte, file_size)
# Test byte range request: greater than zero start byte.
self.CheckContentHeaders(b, t, '100-', '100-%d' % last_byte,
file_size - 100)
# Test byte range request: explicit byte range.
self.CheckContentHeaders(b, t, '2-500', '2-500', '499')
# Test byte range request: no start byte.
self.CheckContentHeaders(b, t, '-228',
'%d-%d' % (file_size - 228, last_byte),
'228')
# Test byte range request: end byte less than start byte.
self.CheckContentHeaders(b, t, '100-5', '100-%d' % last_byte,
file_size - 100)
def Run(self, options):
"""Kick off the process.
Args:
options: Instance of BrowserFinderOptions to search for proper browser.
Returns:
The path of generated profile or existing profile if --profile-dir
is given. Could be None if it's generated on default location
(e.g., crytohome on CrOS).
"""
possible_browser = browser_finder.FindBrowser(options)
is_cros = possible_browser.browser_type.startswith('cros')
out_dir = None
if is_cros:
self.Create(options, None)
else:
# Decide profile output path.
out_dir = (options.browser_options.profile_dir or
os.path.abspath(os.path.join(
tempfile.gettempdir(), self._profile_name, self._profile_name)))
if not os.path.exists(out_dir):
self.Create(options, out_dir)
return out_dir
def CreateBrowser(self, extra_browser_args=None, profile_type=None):
assert not self._browser
options = options_for_unittests.GetCopy()
if profile_type:
# TODO(jeremy): crbug.com/243912 profiles are only implemented on
# Desktop.
is_running_on_desktop = not (
options.browser_type.startswith('android')
or options.browser_type.startswith('cros'))
if not is_running_on_desktop:
logging.warn("Desktop-only test, skipping.")
return None
options.profile_type = profile_type
if extra_browser_args:
options.extra_browser_args.extend(extra_browser_args)
browser_to_create = browser_finder.FindBrowser(options)
if not browser_to_create:
raise Exception('No browser found, cannot continue test.')
self._browser = browser_to_create.Create()
unittest_data_dir = os.path.join(os.path.dirname(__file__), '..', '..',
'unittest_data')
self._browser.SetHTTPServerDirectories(unittest_data_dir)
return self._browser
def testLoginStatus(self):
extension_path = os.path.join(os.path.dirname(__file__),
'autotest_ext')
load_extension = extension_to_load.ExtensionToLoad(
extension_path, True)
options = options_for_unittests.GetCopy()
options.extensions_to_load = [load_extension]
browser_to_create = browser_finder.FindBrowser(options)
self.assertTrue(browser_to_create)
with browser_to_create.Create() as b:
extension = b.extensions[load_extension]
self.assertTrue(extension)
extension.ExecuteJavaScript('''
chrome.autotestPrivate.loginStatus(function(s) {
window.__autotest_result = s;
});
''')
login_status = extension.EvaluateJavaScript(
'window.__autotest_result')
self.assertEquals(type(login_status), dict)
self.assertEquals(not self._is_guest,
login_status['isRegularUser'])
self.assertEquals(self._is_guest, login_status['isGuest'])
self.assertEquals(login_status['email'], self._email)
self.assertFalse(login_status['isScreenLocked'])
def Run(self, args):
possible_browser = browser_finder.FindBrowser(args)
test_suite, result = self.RunOneSuite(possible_browser, args)
results = [result]
failed_tests = json_results.FailedTestNames(test_suite, result)
retry_limit = args.retry_limit
while retry_limit and failed_tests:
args.positional_args = failed_tests
args.exact_test_filter = True
_, result = self.RunOneSuite(possible_browser, args)
results.append(result)
failed_tests = json_results.FailedTestNames(test_suite, result)
retry_limit -= 1
full_results = json_results.FullResults(args, test_suite, results)
json_results.WriteFullResultsIfNecessary(args, full_results)
err_occurred, err_str = json_results.UploadFullResultsIfNecessary(
args, full_results)
if err_occurred:
for line in err_str.splitlines():
logging.error(line)
return 1
return json_results.ExitCodeFromFullResults(full_results)
def testRunPageWithStartupUrl(self):
ps = page_set.PageSet()
expectations = test_expectations.TestExpectations()
expectations = test_expectations.TestExpectations()
page = page_module.Page('file://blank.html',
ps,
base_dir=util.GetUnittestDataDir())
page.startup_url = 'about:blank'
ps.pages.append(page)
class Measurement(page_measurement.PageMeasurement):
def __init__(self):
super(Measurement, self).__init__()
self.browser_restarted = False
def CustomizeBrowserOptionsForSinglePage(self, ps, options):
self.browser_restarted = True
super(Measurement,
self).CustomizeBrowserOptionsForSinglePage(ps, options)
def MeasurePage(self, page, tab, results):
pass
options = options_for_unittests.GetCopy()
options.page_repeat = 2
options.output_format = 'none'
if not browser_finder.FindBrowser(options):
return
test = Measurement()
SetUpPageRunnerArguments(options)
page_runner.Run(test, ps, expectations, options)
self.assertEquals('about:blank', options.browser_options.startup_url)
self.assertTrue(test.browser_restarted)
def testTabCallByReference(self):
options = options_for_unittests.GetCopy()
browser_to_create = browser_finder.FindBrowser(options)
with browser_to_create.Create() as b:
tab = b.tabs[0]
tab.Navigate('http://www.google.com/')
b.tabs[0].WaitForDocumentReadyStateToBeInteractiveOrBetter()
def testVersionDetection(self):
options = options_for_unittests.GetCopy()
browser_to_create = browser_finder.FindBrowser(options)
with browser_to_create.Create() as b:
# pylint: disable=W0212
self.assertTrue(b._browser_backend._inspector_protocol_version > 0)
self.assertTrue(b._browser_backend._chrome_branch_number > 0)
self.assertTrue(b._browser_backend._webkit_base_revision > 0)
def setUpClass(cls):
cls._number_of_tabs = 4
cls._profile_dir = _GenerateBrowserProfile(cls._number_of_tabs)
cls._options = options_for_unittests.GetCopy()
cls._options.browser_options.AppendExtraBrowserArgs(
['--restore-last-session'])
cls._options.browser_options.profile_dir = cls._profile_dir
cls._browser_to_create = browser_finder.FindBrowser(cls._options)
def Main(benchmark_dir):
benchmarks = discover.DiscoverClasses(benchmark_dir,
os.path.join(benchmark_dir, '..'),
page_benchmark.PageBenchmark)
options = browser_options.BrowserOptions()
parser = options.CreateParser('%prog <page_set>')
page_runner.PageRunner.AddCommandLineOptions(parser)
recorder = RecordPage(benchmarks)
recorder.AddCommandLineOptions(parser)
_, args = parser.parse_args()
if len(args) != 1:
parser.print_usage()
sys.exit(1)
ps = page_set.PageSet.FromFile(args[0])
# 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.wpr_mode = wpr_modes.WPR_RECORD
recorder.CustomizeBrowserOptions(options)
possible_browser = browser_finder.FindBrowser(options)
if not possible_browser:
print >> sys.stderr, """No browser found.\n
Use --browser=list to figure out which are available.\n"""
sys.exit(1)
results = page_test.PageTestResults()
with page_runner.PageRunner(ps) as runner:
runner.Run(options, possible_browser, recorder, results)
if results.page_failures:
logging.warning(
'Some pages failed. The recording has not been updated for '
'these pages.')
logging.warning(
'Failed pages: %s', '\n'.join(
[failure['page'].url for failure in results.page_failures]))
if results.skipped_pages:
logging.warning('Some pages were skipped. The recording has not been '
'updated for these pages.')
logging.warning(
'Skipped pages: %s', '\n'.join(
[skipped['page'].url for skipped in results.skipped_pages]))
if results.page_successes:
# Update the metadata for the pages which were recorded.
ps.wpr_archive_info.AddRecordedPages(
[page['page'] for page in results.page_successes])
else:
os.remove(temp_target_wpr_file_path)
return min(255, len(results.page_failures))
def testCloseReferencedTab(self):
options = options_for_unittests.GetCopy()
browser_to_create = browser_finder.FindBrowser(options)
with browser_to_create.Create() as b:
b.tabs.New()
tab = b.tabs[0]
tab.Navigate('http://www.google.com/')
tab.Close()
self.assertEquals(1, len(b.tabs))
def Run(self, args):
if args.json_output_file:
possible_browser = browser_finder.FindBrowser(args)
with open(args.json_output_file, 'w') as f:
f.write(
_GetJsonTestList(possible_browser, args.tests,
args.num_shards))
else:
_PrintTestList(args.tests)
return 0
def testBrowserCreation(self):
options = options_for_unittests.GetCopy()
browser_to_create = browser_finder.FindBrowser(options)
if not browser_to_create:
raise Exception('No browser found, cannot continue test.')
with browser_to_create.Create() as b:
self.assertEquals(1, len(b.tabs))
# Different browsers boot up to different things
assert b.tabs[0].url
def ProcessCommandLineArgs(cls, parser, args):
# We retry failures by default unless we're running a list of tests
# explicitly.
if not args.retry_limit and not args.positional_args:
args.retry_limit = 3
try:
possible_browser = browser_finder.FindBrowser(args)
except browser_finder_exceptions.BrowserFinderException, ex:
parser.error(ex)
def Run(test, page_set, expectations, finder_options, results):
"""Runs a given test against a given page_set with the given options."""
test.ValidatePageSet(page_set)
# Create a possible_browser with the given options.
try:
possible_browser = browser_finder.FindBrowser(finder_options)
except browser_finder.BrowserTypeRequiredException, e:
sys.stderr.write(str(e) + '\n')
sys.exit(-1)
def testExtensionNotLoaded(self):
"""Querying an extension that was not loaded will return None"""
extension_path = os.path.join(util.GetUnittestDataDir(), 'simple_extension')
options = options_for_unittests.GetCopy()
load_extension = extension_to_load.ExtensionToLoad(
extension_path, options.browser_type)
browser_to_create = browser_finder.FindBrowser(options)
with browser_to_create.Create() as b:
if b.supports_extensions:
self.assertRaises(KeyError, lambda: b.extensions[load_extension])
def CustomizeBrowserOptions(self, options):
options.AppendExtraBrowserArgs([
'--disable-gesture-requirement-for-media-playback',
'--disable-domain-blocking-for-3d-apis',
'--disable-gpu-process-crash-limit', '--enable-unsafe-es3-apis'
])
target_os = browser_finder.FindBrowser(
options.finder_options).target_os
if target_os.startswith('win'):
options.AppendExtraBrowserArgs(['--use-gl=desktop'])
def RunTestOnPageSet(self, test, ps, results):
test.CustomizeBrowserOptions(self._options)
possible_browser = browser_finder.FindBrowser(self._options)
if not possible_browser:
self.PrintParseError(
'No browser found.\n'
'Use --browser=list to figure out which are available.')
with page_runner.PageRunner(ps) as runner:
runner.Run(self._options, possible_browser, test, results)
def testCryptohomeMounted(self):
options = options_for_unittests.GetCopy()
browser_to_create = browser_finder.FindBrowser(options)
if not browser_to_create:
raise Exception('No browser found, cannot continue test.')
with browser_to_create.Create() as b:
self.assertEquals(1, len(b.tabs))
self.assertTrue(b.tabs[0].url)
self.assertTrue(self._IsCryptohomeMounted())
self.assertFalse(self._IsCryptohomeMounted())
def _GetVariationsBrowserArgs(self, finder_options):
variations_dir = os.path.join(os.path.dirname(__file__), os.pardir,
os.pardir, os.pardir, 'testing',
'variations')
target_os = browser_finder.FindBrowser(finder_options).target_os
base_variations_path = os.path.join(variations_dir,
'fieldtrial_testing_config.json')
return fieldtrial_util.GenerateArgs(
base_variations_path,
os.path.join(
variations_dir, 'fieldtrial_testing_config_%s.json' %
self._FixupTargetOS(target_os)))
