def CreateAndNavigateToPageFromUnittestDataDir(
self, filename, page_attributes):
self._browser.SetHTTPServerDirectories(util.GetUnittestDataDir())
page = page_module.Page(
self._browser.http_server.UrlOf(filename),
None, # In this test, we don't need a page set.
attributes=page_attributes)
self._tab.Navigate(page.url)
self._tab.WaitForDocumentReadyStateToBeComplete()
return page
def testGetMemoryStatsNoHWM(self):
if not proc_supporting_platform_backend.resource:
logging.warning('Test not supported')
return
backend = TestBackend()
backend.SetMockFile(
'/proc/1/stat',
open(os.path.join(util.GetUnittestDataDir(), 'stat')).read())
backend.SetMockFile(
'/proc/1/status',
open(os.path.join(util.GetUnittestDataDir(),
'status_nohwm')).read())
result = backend.GetMemoryStats(1)
self.assertEquals(
result, {
'VM': 1025978368,
'VMPeak': 1025978368,
'WorkingSetSize': 84000768,
'WorkingSetSizePeak': 84000768
})
def testArchiveWithMissingStory(self):
# This test file has a recording for a 'http://www.testurl.com' story only.
archive_data_file = os.path.join(util.GetUnittestDataDir(),
'archive_files', 'test.json')
story_set = test_stories.DummyStorySet(
['http://www.testurl.com', 'http://www.google.com'],
archive_data_file=archive_data_file)
with self.assertRaises(story_runner.ArchiveError):
story_runner._UpdateAndCheckArchives(story_set.archive_data_file,
story_set.wpr_archive_info,
story_set.stories,
self._mock_story_filter)
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(options) as b:
if b.supports_extensions:
self.assertRaises(KeyError,
lambda: b.extensions[load_extension])
def Run(self, args):
possible_browser = browser_finder.FindBrowser(args)
runner = typ.Runner()
if self.stream:
runner.host.stdout = self.stream
# Telemetry seems to overload the system if we run one test per core,
# so we scale things back a fair amount. Many of the telemetry tests
# are long-running, so there's a limit to how much parallelism we
# can effectively use for now anyway.
#
# It should be possible to handle multiple devices if we adjust the
# browser_finder code properly, but for now we only handle one on ChromeOS.
if possible_browser.platform.GetOSName() == 'chromeos':
runner.args.jobs = 1
elif possible_browser.platform.GetOSName() == 'android':
runner.args.jobs = len(
device_finder.GetDevicesMatchingOptions(args))
print 'Running tests with %d Android device(s).' % runner.args.jobs
elif possible_browser.platform.GetOSVersionName() == 'xp':
# For an undiagnosed reason, XP falls over with more parallelism.
# See crbug.com/388256
runner.args.jobs = max(int(args.jobs) // 4, 1)
else:
runner.args.jobs = max(int(args.jobs) // 2, 1)
runner.args.metadata = args.metadata
runner.args.passthrough = args.passthrough
runner.args.path = args.path
runner.args.retry_limit = args.retry_limit
runner.args.test_results_server = args.test_results_server
runner.args.test_type = args.test_type
# Always print out test's timing info.
runner.args.timing = True
runner.args.top_level_dir = args.top_level_dir
runner.args.verbose = args.verbosity
runner.args.write_full_results_to = args.write_full_results_to
runner.args.write_trace_to = args.write_trace_to
runner.args.path.append(util.GetUnittestDataDir())
runner.classifier = GetClassifier(args, possible_browser)
runner.context = args
runner.setup_fn = _SetUpProcess
runner.teardown_fn = _TearDownProcess
runner.win_multiprocessing = typ.WinMultiprocessing.importable
try:
ret, _, _ = runner.run()
except KeyboardInterrupt:
print >> sys.stderr, "interrupted, exiting"
ret = 130
return ret
def testGetMemoryStatsBasic(self):
if not proc_supporting_platform_backend.resource:
logging.warning('Test not supported')
return
backend = TestBackend()
with open(os.path.join(util.GetUnittestDataDir(), 'stat')) as f:
backend.SetMockFile('/proc/1/stat', f.read())
with open(os.path.join(util.GetUnittestDataDir(), 'status')) as f:
backend.SetMockFile('/proc/1/status', f.read())
with open(os.path.join(util.GetUnittestDataDir(), 'smaps')) as f:
backend.SetMockFile('/proc/1/smaps', f.read())
result = backend.GetMemoryStats(1)
self.assertEquals(
result, {
'PrivateDirty': 5324800,
'VM': 1025978368,
'VMPeak': 1050099712,
'WorkingSetSize': 84000768,
'WorkingSetSizePeak': 144547840
})
def testTrafficSettings(self):
story_set = story.StorySet()
slow_page = page_module.Page(
'file://green_rect.html', story_set, base_dir=util.GetUnittestDataDir(),
name='slow',
traffic_setting=traffic_setting_module.REGULAR_2G)
fast_page = page_module.Page(
'file://green_rect.html', story_set, base_dir=util.GetUnittestDataDir(),
name='fast',
traffic_setting=traffic_setting_module.WIFI)
story_set.AddStory(slow_page)
story_set.AddStory(fast_page)
latencies_by_page_in_ms = {}
class MeasureLatency(legacy_page_test.LegacyPageTest):
def __init__(self):
super(MeasureLatency, self).__init__()
self._will_navigate_time = None
def WillNavigateToPage(self, page, tab):
del page, tab # unused
self._will_navigate_time = time.time() * 1000
def ValidateAndMeasurePage(self, page, tab, results):
del results # unused
latencies_by_page_in_ms[page.name] = (
time.time() * 1000 - self._will_navigate_time)
test = MeasureLatency()
options = options_for_unittests.GetCopy()
options.output_formats = ['none']
options.suppress_gtest_report = True
SetUpStoryRunnerArguments(options)
results = results_options.CreateResults(EmptyMetadataForTest(), options)
story_runner.Run(test, story_set, options, results)
# Slow page should be slower than fast page by at least 300 ms (roundtrip
# time of 2G) - 2 ms (roundtrip time of Wifi)
self.assertGreater(latencies_by_page_in_ms['slow'],
latencies_by_page_in_ms['fast'] + 300 - 2)
def testRaiseBrowserGoneExceptionFromRestartBrowserBeforeEachPage(self):
self.CaptureFormattedException()
story_set = story.StorySet()
story_set.AddStory(
page_module.Page('file://blank.html',
story_set,
base_dir=util.GetUnittestDataDir()))
story_set.AddStory(
page_module.Page('file://blank.html',
story_set,
base_dir=util.GetUnittestDataDir()))
class Test(page_test.PageTest):
def __init__(self, *args):
super(Test, self).__init__(
*args, needs_browser_restart_after_each_page=True)
self.run_count = 0
def RestartBrowserBeforeEachPage(self):
old_run_count = self.run_count
self.run_count += 1
if old_run_count == 0:
raise exceptions.BrowserGoneException(None)
return self._needs_browser_restart_after_each_page
def ValidateAndMeasurePage(self, page, tab, results):
pass
options = options_for_unittests.GetCopy()
options.output_formats = ['none']
options.suppress_gtest_report = True
test = Test()
SetUpStoryRunnerArguments(options)
results = results_options.CreateResults(EmptyMetadataForTest(),
options)
story_runner.Run(test, story_set, options, results)
self.assertEquals(2, test.run_count)
self.assertEquals(1, len(GetSuccessfulPageRuns(results)))
self.assertEquals(1, len(results.failures))
self.assertFormattedExceptionIsEmpty()
def runCredentialsTest(self, credentials_backend):
story_set = story.StorySet()
did_run = [False]
try:
class TestSharedState(shared_page_state.SharedPageState):
def ShouldStopBrowserAfterStoryRun(self, _):
# Do not close browser for LoginNoLongerNeeded to get called.
return False
with tempfile.NamedTemporaryFile(delete=False) as f:
page = page_module.Page(
'file://blank.html',
story_set,
base_dir=util.GetUnittestDataDir(),
shared_page_state_class=TestSharedState,
credentials_path=f.name,
name='blank.html')
page.credentials = "test"
story_set.AddStory(page)
f.write(SIMPLE_CREDENTIALS_STRING)
class TestThatInstallsCredentialsBackend(
legacy_page_test.LegacyPageTest):
def __init__(self, credentials_backend):
super(TestThatInstallsCredentialsBackend, self).__init__()
self._credentials_backend = credentials_backend
def DidStartBrowser(self, browser):
browser.credentials.AddBackend(self._credentials_backend)
def ValidateAndMeasurePage(self, *_):
did_run[0] = True
test = TestThatInstallsCredentialsBackend(credentials_backend)
options = options_for_unittests.GetCopy()
options.output_formats = ['none']
options.suppress_gtest_report = True
SetUpStoryRunnerArguments(options)
results = results_options.CreateResults(EmptyMetadataForTest(),
options)
story_runner.Run(test,
story_set,
options,
results,
metadata=EmptyMetadataForTest())
finally:
os.remove(f.name)
return did_run[0]
def run(self, test, progress_reporters, repeat_count, args):
util.AddDirToPythonPath(util.GetUnittestDataDir())
result = TestResult(progress_reporters)
result.startTestRun()
try:
options_for_unittests.Push(args)
for _ in xrange(repeat_count):
test(result)
finally:
options_for_unittests.Pop()
result.stopTestRun()
return result
def testGetOSVersionNameArch(self):
path = os.path.join(util.GetUnittestDataDir(), 'arch-lsb-release')
with open(path) as f:
arch_lsb_release_content = f.read()
with mock.patch.object(
linux_platform_backend.LinuxPlatformBackend, 'GetFileContents',
return_value=arch_lsb_release_content) as mock_method:
backend = linux_platform_backend.LinuxPlatformBackend()
# a distribution may not have a codename or a release number. We just
# check that GetOSVersionName doesn't raise an exception
backend.GetOSVersionName()
mock_method.assert_called_once_with('/etc/lsb-release')
def testGetOSVersionNameSaucy(self):
path = os.path.join(util.GetUnittestDataDir(),
'ubuntu-saucy-lsb-release')
with open(path) as f:
unbuntu_saucy_lsb_release_content = f.read()
with mock.patch.object(
linux_platform_backend.LinuxPlatformBackend,
'GetFileContents',
return_value=unbuntu_saucy_lsb_release_content) as mock_method:
backend = linux_platform_backend.LinuxPlatformBackend()
self.assertEqual(backend.GetOSVersionName(), 'saucy')
mock_method.assert_called_once_with('/etc/lsb-release')
def testWaitAction(self):
self._browser.SetHTTPServerDirectories(util.GetUnittestDataDir())
self._tab.Navigate(self._browser.http_server.UrlOf('blank.html'))
self._tab.WaitForDocumentReadyStateToBeComplete()
self.assertEquals(
self._tab.EvaluateJavaScript('document.location.pathname;'),
'/blank.html')
i = wait.WaitAction({'condition': 'duration', 'seconds': 1})
start_time = time.time()
i.RunAction(None, self._tab, None)
self.assertTrue(time.time() - start_time >= 1.0)
def testBrowserRestartsAfterEachPage(self):
self.CaptureFormattedException()
story_set = story.StorySet()
story_set.AddStory(
page_module.Page('file://blank.html',
story_set,
base_dir=util.GetUnittestDataDir(),
name='foo'))
story_set.AddStory(
page_module.Page('file://blank.html',
story_set,
base_dir=util.GetUnittestDataDir(),
name='bar'))
class Test(legacy_page_test.LegacyPageTest):
def __init__(self):
super(Test, self).__init__()
self.browser_starts = 0
self.platform_name = None
def DidStartBrowser(self, browser):
super(Test, self).DidStartBrowser(browser)
self.browser_starts += 1
self.platform_name = browser.platform.GetOSName()
def ValidateAndMeasurePage(self, page, tab, results):
pass
test = Test()
results = RunStorySet(test, story_set, self.options)
self.assertEquals(len(story_set), results.num_successful)
# Browser is started once per story run, except in ChromeOS where a single
# instance is reused for all stories.
if test.platform_name == 'chromeos':
self.assertEquals(1, test.browser_starts)
else:
self.assertEquals(len(story_set), test.browser_starts)
self.assertFormattedExceptionIsEmpty()
def testSharedPageStateCannotRunOnBrowser(self):
story_set = story.StorySet()
class UnrunnableSharedState(shared_page_state.SharedPageState):
def CanRunOnBrowser(self, browser_info, page):
del browser_info, page # unused
return False
def ValidateAndMeasurePage(self, _):
pass
story_set.AddStory(page_module.Page(
url='file://blank.html', page_set=story_set,
base_dir=util.GetUnittestDataDir(),
shared_page_state_class=UnrunnableSharedState,
name='blank.html'))
class Test(legacy_page_test.LegacyPageTest):
def __init__(self, *args, **kwargs):
super(Test, self).__init__(*args, **kwargs)
self.will_navigate_to_page_called = False
def ValidateAndMeasurePage(self, *args):
del args # unused
raise Exception('Exception should not be thrown')
def WillNavigateToPage(self, page, tab):
del page, tab # unused
self.will_navigate_to_page_called = True
test = Test()
options = options_for_unittests.GetCopy()
options.output_formats = ['none']
options.suppress_gtest_report = True
SetUpStoryRunnerArguments(options)
results = results_options.CreateResults(EmptyMetadataForTest(), options)
possible_browser = browser_finder.FindBrowser(options)
story_runner.RunStorySet(
test=test,
story_set=story_set,
possible_browser=possible_browser,
expectations=None,
browser_options=options.browser_options,
finder_options=options,
results=results,
)
self.assertFalse(test.will_navigate_to_page_called)
self.assertEquals(1, len(GetSuccessfulPageRuns(results)))
self.assertEquals(1, len(results.skipped_values))
self.assertFalse(results.had_failures)
def testVideoFileFrameGeneratorSkipFrames(self):
vid = os.path.join(util.GetUnittestDataDir(),
'screen_3_frames.mov')
fg = self.VideoFileFrameGenerator(vid, 2)
self.assertEqual(fg.CurrentFrameNumber, 1)
self.assertAlmostEqual(fg.CurrentTimestamp, 33.367, 3)
self.assertEqual(fg.Dimensions, (432, 320))
next(fg.Generator)
try:
next(fg.Generator)
stopped = False
except StopIteration:
stopped = True
self.assertTrue(stopped)
def testSuccesfulPythonPageSetLoading(self):
test_pps_dir = os.path.join(util.GetUnittestDataDir(), 'test_page_set.py')
pps = page_set.PageSet.FromFile(test_pps_dir)
self.assertEqual('TestPageSet', pps.__class__.__name__)
self.assertEqual('A pageset for testing purpose', pps.description)
self.assertEqual('data/test.json', pps.archive_data_file)
self.assertEqual('data/credential', pps.credentials_path)
self.assertEqual('desktop', pps.user_agent_type)
self.assertEqual(test_pps_dir, pps.file_path)
self.assertEqual(3, len(pps.pages))
google_page = pps.pages[0]
self.assertEqual('https://www.google.com', google_page.url)
self.assertIs(pps, google_page.page_set)
self.assertTrue(5, google_page.RunGetActionRunner(action_runner=5))
def testArchiveWithMissingWprFile(self):
# This test file claims to have recordings for both
# 'http://www.testurl.com' and 'http://www.google.com'; but the file with
# the wpr recording for the later story is actually missing.
archive_data_file = os.path.join(
util.GetUnittestDataDir(), 'archive_files',
'test_missing_wpr_file.json')
story_set = test_stories.DummyStorySet(
['http://www.testurl.com', 'http://www.google.com'],
archive_data_file=archive_data_file)
with self.assertRaises(story_runner.ArchiveError):
story_runner._UpdateAndCheckArchives(
story_set.archive_data_file, story_set.wpr_archive_info,
story_set.stories, self._mock_story_filter)
def testFindPythonDependenciesWithNestedImport(self):
moose_module_path = os.path.join(util.GetUnittestDataDir(),
'dependency_test_dir',
'other_animals', 'moose', 'moose')
moose_object_path = os.path.join(moose_module_path, 'moose_object.py')
horn_module_path = os.path.join(moose_module_path, 'horn')
horn_module_init_path = os.path.join(horn_module_path, '__init__.py')
horn_object_path = os.path.join(horn_module_path, 'horn_object.py')
self.assertEquals(
set(p for p in find_dependencies.FindPythonDependencies(
moose_object_path)), {
moose_object_path, horn_module_path, horn_module_init_path,
horn_object_path
})
def testNeedsBrowserRestartAfterEachPage(self):
self.CaptureFormattedException()
story_set = story.StorySet()
story_set.AddStory(
page_module.Page('file://blank.html',
story_set,
base_dir=util.GetUnittestDataDir(),
name='foo'))
story_set.AddStory(
page_module.Page('file://blank.html',
story_set,
base_dir=util.GetUnittestDataDir(),
name='bar'))
class Test(legacy_page_test.LegacyPageTest):
def __init__(self, *args, **kwargs):
super(Test, self).__init__(*args, **kwargs)
self.browser_starts = 0
def DidStartBrowser(self, *args):
super(Test, self).DidStartBrowser(*args)
self.browser_starts += 1
def ValidateAndMeasurePage(self, page, tab, results):
pass
options = options_for_unittests.GetCopy()
options.output_formats = ['none']
options.suppress_gtest_report = True
test = Test(needs_browser_restart_after_each_page=True)
SetUpStoryRunnerArguments(options)
results = results_options.CreateResults(EmptyMetadataForTest(),
options)
story_runner.Run(test, story_set, options, results)
self.assertEquals(2, len(GetSuccessfulPageRuns(results)))
self.assertEquals(2, test.browser_starts)
self.assertFormattedExceptionIsEmpty()
def testHandlingOfTestThatRaisesWithNonFatalUnknownExceptions(self):
ps = page_set.PageSet()
expectations = test_expectations.TestExpectations()
ps.pages.append(
page_module.Page('file://blank.html',
ps,
base_dir=util.GetUnittestDataDir()))
ps.pages.append(
page_module.Page('file://blank.html',
ps,
base_dir=util.GetUnittestDataDir()))
class ExpectedException(Exception):
pass
class Test(page_test.PageTest):
def __init__(self, *args):
super(Test, self).__init__(*args)
self.run_count = 0
def ValidatePage(self, *_):
old_run_count = self.run_count
self.run_count += 1
if old_run_count == 0:
raise ExpectedException()
options = options_for_unittests.GetCopy()
options.output_format = 'none'
options.suppress_gtest_report = True
test = Test()
SetUpPageRunnerArguments(options)
results = results_options.CreateResults(EmptyMetadataForTest(),
options)
page_runner.Run(test, ps, expectations, options, results)
self.assertEquals(2, test.run_count)
self.assertEquals(1, len(GetSuccessfulPageRuns(results)))
self.assertEquals(1, len(results.failures))
def testRunPageWithStartupUrl(self):
num_times_browser_closed = [0]
class TestSharedState(shared_page_state.SharedPageState):
def _StopBrowser(self):
if self._browser:
num_times_browser_closed[0] += 1
super(TestSharedState, self)._StopBrowser()
story_set = story.StorySet()
page = page_module.Page('file://blank.html',
story_set,
base_dir=util.GetUnittestDataDir(),
startup_url='about:blank',
shared_page_state_class=TestSharedState,
name='blank.html')
story_set.AddStory(page)
class Measurement(legacy_page_test.LegacyPageTest):
def __init__(self):
super(Measurement, self).__init__()
def ValidateAndMeasurePage(self, page, tab, results):
del page, tab, results # not used
options = options_for_unittests.GetCopy()
options.pageset_repeat = 2
options.output_formats = ['none']
options.suppress_gtest_report = True
if not browser_finder.FindBrowser(options):
return
with tempfile_ext.NamedTemporaryDirectory('page_E2E_tests') as tempdir:
options.output_dir = tempdir
test = Measurement()
SetUpStoryRunnerArguments(options)
results = results_options.CreateResults(EmptyMetadataForTest(),
options)
story_runner.Run(test,
story_set,
options,
results,
metadata=EmptyMetadataForTest())
self.assertEquals('about:blank',
options.browser_options.startup_url)
# _StopBrowser should be called 2 times:
# 1. browser restarts after page 1 run
# 2. in the TearDownState after all the pages have run.
self.assertEquals(num_times_browser_closed[0], 2)
def testRaiseBrowserGoneExceptionFromRestartBrowserBeforeEachPage(self):
self.SuppressExceptionFormatting()
ps = page_set.PageSet()
expectations = test_expectations.TestExpectations()
ps.pages.append(
page_module.Page('file://blank.html',
ps,
base_dir=util.GetUnittestDataDir()))
ps.pages.append(
page_module.Page('file://blank.html',
ps,
base_dir=util.GetUnittestDataDir()))
class Test(page_test.PageTest):
def __init__(self, *args):
super(Test, self).__init__(*args)
self.run_count = 0
def RestartBrowserBeforeEachPage(self):
old_run_count = self.run_count
self.run_count += 1
if old_run_count == 0:
raise exceptions.BrowserGoneException(None)
return self._needs_browser_restart_after_each_page
options = options_for_unittests.GetCopy()
options.output_formats = ['none']
options.suppress_gtest_report = True
test = Test()
SetUpUserStoryRunnerArguments(options)
results = results_options.CreateResults(EmptyMetadataForTest(),
options)
user_story_runner.Run(test, ps, expectations, options, results)
self.assertEquals(2, test.run_count)
self.assertEquals(1, len(GetSuccessfulPageRuns(results)))
self.assertEquals(1, len(results.failures))
def testGetOSVersionNameFedora(self):
path = os.path.join(util.GetUnittestDataDir(), 'fedora-os-release')
with open(path) as f:
fedora_os_release_content = f.read()
with mock.patch.object(os.path,
'exists',
side_effect=_PathMatches('/etc/os-release')):
with mock.patch.object(
linux_platform_backend.LinuxPlatformBackend,
'GetFileContents',
return_value=fedora_os_release_content) as mock_method:
backend = linux_platform_backend.LinuxPlatformBackend()
self.assertEqual(backend.GetOSVersionName(), 'fedora')
mock_method.assert_called_once_with('/etc/os-release')
def testPagesetRepeat(self):
ps = page_set.PageSet()
expectations = test_expectations.TestExpectations()
ps.pages.append(page_module.Page(
'file://blank.html', ps, base_dir=util.GetUnittestDataDir()))
ps.pages.append(page_module.Page(
'file://green_rect.html', ps, base_dir=util.GetUnittestDataDir()))
class Measurement(page_measurement.PageMeasurement):
i = 0
def MeasurePage(self, _, __, results):
self.i += 1
results.Add('metric', 'unit', self.i)
output_file = tempfile.NamedTemporaryFile(delete=False).name
try:
options = options_for_unittests.GetCopy()
options.output_format = 'buildbot'
options.output_file = output_file
options.reset_results = None
options.upload_results = None
options.results_label = None
options.repeat_options.page_repeat_iters = 1
options.repeat_options.pageset_repeat_iters = 2
results = page_runner.Run(Measurement(), ps, expectations, options)
results.PrintSummary()
self.assertEquals(4, len(results.successes))
self.assertEquals(0, len(results.failures))
stdout = open(output_file).read()
self.assertIn('RESULT metric_by_url: blank.html= [1,3] unit', stdout)
self.assertIn('RESULT metric_by_url: green_rect.html= [2,4] unit', stdout)
self.assertIn('*RESULT metric: metric= [1,2,3,4] unit', stdout)
finally:
results._output_stream.close() # pylint: disable=W0212
os.remove(output_file)
def testGetDOMStats(self):
self._browser.SetHTTPServerDirectories(util.GetUnittestDataDir())
# Due to an issue with CrOS, we create a new tab here rather than
# using self._tab to get a consistent starting page on all platforms
tab = self._browser.tabs.New()
tab.Navigate(
self._browser.http_server.UrlOf('dom_counter_sample.html'))
tab.WaitForDocumentReadyStateToBeComplete()
counts = tab.dom_stats
self.assertEqual(counts['document_count'], 2)
self.assertEqual(counts['node_count'], 18)
self.assertEqual(counts['event_listener_count'], 2)
def CreateBrowserWithExtension(self, ext_path):
extension_path = os.path.join(util.GetUnittestDataDir(), ext_path)
options = options_for_unittests.GetCopy()
load_extension = extension_to_load.ExtensionToLoad(
extension_path, options.browser_type)
options.extensions_to_load = [load_extension]
browser_to_create = browser_finder.FindBrowser(options)
if not browser_to_create:
# May not find a browser that supports extensions.
return False
self._browser = browser_to_create.Create(options)
self._extension = self._browser.extensions[load_extension]
self._extension_id = load_extension.extension_id
self.assertTrue(self._extension)
return True
def testVideoFileFrameGeneratorFailure(self):
vid = os.path.join(util.GetUnittestDataDir(),
'screen_3_frames.mov')
try:
self.VideoFileFrameGenerator(vid, 4)
fail = False
except frame_generator.FrameReadError:
fail = True
self.assertTrue(fail)
try:
self.VideoFileFrameGenerator('not_a_file', 0)
fail = False
except frame_generator.FrameReadError:
fail = True
self.assertTrue(fail)
def _testMaxFailuresOptionIsRespectedAndOverridable(
self, max_failures=None):
self.SuppressExceptionFormatting()
class TestPage(page_module.Page):
def __init__(self, *args, **kwargs):
super(TestPage, self).__init__(*args, **kwargs)
self.was_run = False
def RunNavigateSteps(self, action_runner): # pylint: disable=W0613
self.was_run = True
raise Exception('Test exception')
class Test(page_test.PageTest):
def ValidatePage(self, *args):
pass
ps = page_set.PageSet()
expectations = test_expectations.TestExpectations()
for ii in range(5):
ps.pages.append(
TestPage('file://blank.html',
ps,
base_dir=util.GetUnittestDataDir()))
options = options_for_unittests.GetCopy()
options.output_formats = ['none']
options.suppress_gtest_report = True
expected_max_failures = 2
if not max_failures is None:
options.max_failures = max_failures
expected_max_failures = max_failures
SetUpUserStoryRunnerArguments(options)
results = results_options.CreateResults(EmptyMetadataForTest(),
options)
user_story_runner.Run(Test(max_failures=2), ps, expectations, options,
results)
self.assertEquals(0, len(GetSuccessfulPageRuns(results)))
# Runs up to max_failures+1 failing tests before stopping, since
# every tests after max_failures failures have been encountered
# may all be passing.
self.assertEquals(expected_max_failures + 1, len(results.failures))
for ii in range(len(ps.pages)):
if ii <= expected_max_failures:
self.assertTrue(ps.pages[ii].was_run)
else:
self.assertFalse(ps.pages[ii].was_run)
def setUp(self):
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)
options.extensions_to_load = [load_extension]
browser_to_create = browser_finder.FindBrowser(options)
self._browser = None
self._extension = None
if not browser_to_create:
# May not find a browser that supports extensions.
return
self._browser = browser_to_create.Create()
self._browser.Start()
self._extension = self._browser.extensions[load_extension]
self.assertTrue(self._extension)
