tools/telemetry/telemetry/internal/story_runner_unittest.py - Issue 1126443002: Move user_story.user_story_set to story.story_set

Unified Diff: tools/telemetry/telemetry/internal/story_runner_unittest.py

Issue 1126443002: Move user_story.user_story_set to story.story_set (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: rebase Created 5 years, 7 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: tools/telemetry/telemetry/internal/story_runner_unittest.py

diff --git a/tools/telemetry/telemetry/internal/story_runner_unittest.py b/tools/telemetry/telemetry/internal/story_runner_unittest.py

index 65959c76279993ba25746024c109d046028d2074..3a33782e1dce3de8378bce8e75f1ac2ef6932f93 100644

--- a/tools/telemetry/telemetry/internal/story_runner_unittest.py

+++ b/tools/telemetry/telemetry/internal/story_runner_unittest.py

@@ -14,11 +14,11 @@ from telemetry.page import page as page_module

from telemetry.page import page_test

from telemetry.page import test_expectations

from telemetry.results import results_options

+from telemetry import story

from telemetry.story import shared_state

from telemetry.unittest_util import options_for_unittests

from telemetry.unittest_util import system_stub

-from telemetry import user_story

-from telemetry.user_story import user_story_set

+from telemetry import user_story as user_story_module

from telemetry.util import cloud_storage

from telemetry.util import exception_formatter as exception_formatter_module

from telemetry.value import scalar

@@ -42,9 +42,9 @@ class TestSharedState(shared_state.SharedState):

def SetTestPlatform(cls, platform):

cls._platform = platform

- def __init__(self, test, options, user_story_setz):

+ def __init__(self, test, options, story_set):

super(TestSharedState, self).__init__(

- test, options, user_story_setz)

+ test, options, story_set)

self._test = test

self._current_user_story = None

@@ -52,8 +52,8 @@ class TestSharedState(shared_state.SharedState):

def platform(self):

return self._platform

- def WillRunUserStory(self, user_storyz):

- self._current_user_story = user_storyz

+ def WillRunUserStory(self, user_story):

+ self._current_user_story = user_story

def GetTestExpectationAndSkipValue(self, expectations):

return 'pass', None

@@ -73,11 +73,11 @@ class TestSharedPageState(TestSharedState):

self._test.RunPage(self._current_user_story, None, results)

-class FooUserStoryState(TestSharedPageState):

+class FooStoryState(TestSharedPageState):

pass

-class BarUserStoryState(TestSharedPageState):

+class BarStoryState(TestSharedPageState):

pass

@@ -94,7 +94,7 @@ class EmptyMetadataForTest(benchmark.BenchmarkMetadata):

super(EmptyMetadataForTest, self).__init__('')

-class DummyLocalUserStory(user_story.UserStory):

+class DummyLocalUserStory(user_story_module.UserStory):

def __init__(self, shared_state_class, name=''):

super(DummyLocalUserStory, self).__init__(

shared_state_class, name=name)

@@ -103,19 +103,19 @@ class DummyLocalUserStory(user_story.UserStory):

def is_local(self):

return True

-class MixedStateStorySet(user_story_set.UserStorySet):

+class MixedStateStorySet(story.StorySet):

@property

def allow_mixed_story_states(self):

return True

-def SetupUserStorySet(allow_multiple_user_story_states, user_story_state_list):

+def SetupStorySet(allow_multiple_user_story_states, user_story_state_list):

if allow_multiple_user_story_states:

- us = MixedStateStorySet()

+ story_set = MixedStateStorySet()

else:

- us = user_story_set.UserStorySet()

+ story_set = story.StorySet()

for user_story_state in user_story_state_list:

- us.AddUserStory(DummyLocalUserStory(user_story_state))

- return us

+ story_set.AddUserStory(DummyLocalUserStory(user_story_state))

+ return story_set

def _GetOptionForUnittest():

options = options_for_unittests.GetCopy()

@@ -168,33 +168,33 @@ class StoryRunnerTest(unittest.TestCase):

self.RestoreExceptionFormatter()

def testStoriesGroupedByStateClass(self):

- foo_states = [FooUserStoryState, FooUserStoryState, FooUserStoryState,

- FooUserStoryState, FooUserStoryState]

- mixed_states = [FooUserStoryState, FooUserStoryState, FooUserStoryState,

- BarUserStoryState, FooUserStoryState]

- # UserStorySet's are only allowed to have one SharedState.

- us = SetupUserStorySet(False, foo_states)

+ foo_states = [FooStoryState, FooStoryState, FooStoryState,

+ FooStoryState, FooStoryState]

+ mixed_states = [FooStoryState, FooStoryState, FooStoryState,

+ BarStoryState, FooStoryState]

+ # StorySet's are only allowed to have one SharedState.

+ story_set = SetupStorySet(False, foo_states)

story_groups = (

story_runner.StoriesGroupedByStateClass(

- us, False))

+ story_set, False))

self.assertEqual(len(story_groups), 1)

- us = SetupUserStorySet(False, mixed_states)

+ story_set = SetupStorySet(False, mixed_states)

self.assertRaises(

ValueError,

story_runner.StoriesGroupedByStateClass,

- us, False)

- # BaseUserStorySets are allowed to have multiple SharedStates.

- bus = SetupUserStorySet(True, mixed_states)

+ story_set, False)

+ # BaseStorySets are allowed to have multiple SharedStates.

+ mixed_story_set = SetupStorySet(True, mixed_states)

story_groups = (

story_runner.StoriesGroupedByStateClass(

- bus, True))

+ mixed_story_set, True))

self.assertEqual(len(story_groups), 3)

self.assertEqual(story_groups[0].shared_state_class,

- FooUserStoryState)

+ FooStoryState)

self.assertEqual(story_groups[1].shared_state_class,

- BarUserStoryState)

+ BarStoryState)

self.assertEqual(story_groups[2].shared_state_class,

- FooUserStoryState)

+ FooStoryState)

def RunUserStoryTest(self, us, expected_successes):

test = DummyTest()

@@ -205,17 +205,17 @@ class StoryRunnerTest(unittest.TestCase):

GetNumberOfSuccessfulPageRuns(self.results))

def testUserStoryTest(self):

- all_foo = [FooUserStoryState, FooUserStoryState, FooUserStoryState]

- one_bar = [FooUserStoryState, FooUserStoryState, BarUserStoryState]

- us = SetupUserStorySet(True, one_bar)

- self.RunUserStoryTest(us, 3)

- us = SetupUserStorySet(True, all_foo)

- self.RunUserStoryTest(us, 6)

- us = SetupUserStorySet(False, all_foo)

- self.RunUserStoryTest(us, 9)

- us = SetupUserStorySet(False, one_bar)

+ all_foo = [FooStoryState, FooStoryState, FooStoryState]

+ one_bar = [FooStoryState, FooStoryState, BarStoryState]

+ story_set = SetupStorySet(True, one_bar)

+ self.RunUserStoryTest(story_set, 3)

+ story_set = SetupStorySet(True, all_foo)

+ self.RunUserStoryTest(story_set, 6)

+ story_set = SetupStorySet(False, all_foo)

+ self.RunUserStoryTest(story_set, 9)

+ story_set = SetupStorySet(False, one_bar)

test = DummyTest()

- self.assertRaises(ValueError, story_runner.Run, test, us,

+ self.assertRaises(ValueError, story_runner.Run, test, story_set,

self.expectations, self.options, self.results)

def testSuccessfulTimelineBasedMeasurementTest(self):

@@ -230,12 +230,12 @@ class StoryRunnerTest(unittest.TestCase):

test = timeline_based_measurement.TimelineBasedMeasurement(

timeline_based_measurement.Options())

- us = user_story_set.UserStorySet()

- us.AddUserStory(DummyLocalUserStory(TestSharedTbmState))

+ story_set = story.StorySet()

+ story_set.AddUserStory(DummyLocalUserStory(TestSharedTbmState))

story_runner.Run(

- test, us, self.expectations, self.options, self.results)

+ test, story_set, self.expectations, self.options, self.results)

self.assertEquals(0, len(self.results.failures))

self.assertEquals(3, GetNumberOfSuccessfulPageRuns(self.results))

@@ -245,18 +245,18 @@ class StoryRunnerTest(unittest.TestCase):

fooz_tear_down_call_counter = [0]

barz_init_call_counter = [0]

barz_tear_down_call_counter = [0]

- class FoozUserStoryState(FooUserStoryState):

- def __init__(self, test, options, user_story_setz):

- super(FoozUserStoryState, self).__init__(

- test, options, user_story_setz)

+ class FoozStoryState(FooStoryState):

+ def __init__(self, test, options, storyz):

+ super(FoozStoryState, self).__init__(

+ test, options, storyz)

fooz_init_call_counter[0] += 1

def TearDownState(self):

fooz_tear_down_call_counter[0] += 1

- class BarzUserStoryState(BarUserStoryState):

- def __init__(self, test, options, user_story_setz):

- super(BarzUserStoryState, self).__init__(

- test, options, user_story_setz)

+ class BarzStoryState(BarStoryState):

+ def __init__(self, test, options, storyz):

+ super(BarzStoryState, self).__init__(

+ test, options, storyz)

barz_init_call_counter[0] += 1

def TearDownState(self):

barz_tear_down_call_counter[0] += 1

@@ -266,41 +266,42 @@ class StoryRunnerTest(unittest.TestCase):

fooz_init_call_counter[0] = 0

fooz_tear_down_call_counter[0] = 0

- uss1_list = [FoozUserStoryState, FoozUserStoryState, FoozUserStoryState,

- BarzUserStoryState, BarzUserStoryState]

- uss1 = SetupUserStorySet(True, uss1_list)

- self.RunUserStoryTest(uss1, 15)

+ story_set1_list = [FoozStoryState, FoozStoryState, FoozStoryState,

+ BarzStoryState, BarzStoryState]

+ story_set1 = SetupStorySet(True, story_set1_list)

+ self.RunUserStoryTest(story_set1, 15)

AssertAndCleanUpFoo()

self.assertEquals(1, barz_init_call_counter[0])

self.assertEquals(1, barz_tear_down_call_counter[0])

barz_init_call_counter[0] = 0

barz_tear_down_call_counter[0] = 0

- uss2_list = [FoozUserStoryState, FoozUserStoryState, FoozUserStoryState,

- FoozUserStoryState]

- uss2 = SetupUserStorySet(False, uss2_list)

- self.RunUserStoryTest(uss2, 27)

+ story_set2_list = [FoozStoryState, FoozStoryState, FoozStoryState,

+ FoozStoryState]

+ story_set2 = SetupStorySet(False, story_set2_list)

+ self.RunUserStoryTest(story_set2, 27)

AssertAndCleanUpFoo()

self.assertEquals(0, barz_init_call_counter[0])

self.assertEquals(0, barz_tear_down_call_counter[0])

def testAppCrashExceptionCausesFailureValue(self):

self.SuppressExceptionFormatting()

- us = user_story_set.UserStorySet()

+ story_set = story.StorySet()

class SharedUserStoryThatCausesAppCrash(TestSharedPageState):

- def WillRunUserStory(self, user_storyz):

+ def WillRunUserStory(self, user_story):

raise exceptions.AppCrashException('App Foo crashes')

- us.AddUserStory(DummyLocalUserStory(SharedUserStoryThatCausesAppCrash))

+ story_set.AddUserStory(DummyLocalUserStory(

+ SharedUserStoryThatCausesAppCrash))

story_runner.Run(

- DummyTest(), us, self.expectations, self.options, self.results)

+ DummyTest(), story_set, self.expectations, self.options, self.results)

self.assertEquals(1, len(self.results.failures))

self.assertEquals(0, GetNumberOfSuccessfulPageRuns(self.results))

self.assertIn('App Foo crashes', self.fake_stdout.getvalue())

def testUnknownExceptionIsFatal(self):

self.SuppressExceptionFormatting()

- uss = user_story_set.UserStorySet()

+ story_set = story.StorySet()

class UnknownException(Exception):

pass

@@ -323,19 +324,19 @@ class StoryRunnerTest(unittest.TestCase):

us1 = DummyLocalUserStory(TestSharedPageState)

us2 = DummyLocalUserStory(TestSharedPageState)

- uss.AddUserStory(us1)

- uss.AddUserStory(us2)

+ story_set.AddUserStory(us1)

+ story_set.AddUserStory(us2)

test = Test()

with self.assertRaises(UnknownException):

story_runner.Run(

- test, uss, self.expectations, self.options, self.results)

+ test, story_set, self.expectations, self.options, self.results)

self.assertEqual(set([us2]), self.results.pages_that_failed)

self.assertEqual(set([us1]), self.results.pages_that_succeeded)

self.assertIn('FooBarzException', self.fake_stdout.getvalue())

def testRaiseBrowserGoneExceptionFromRunPage(self):

self.SuppressExceptionFormatting()

- us = user_story_set.UserStorySet()

+ story_set = story.StorySet()

class Test(page_test.PageTest):

def __init__(self, *args):

@@ -351,18 +352,18 @@ class StoryRunnerTest(unittest.TestCase):

def ValidateAndMeasurePage(self, page, tab, results):

pass

- us.AddUserStory(DummyLocalUserStory(TestSharedPageState))

+ story_set.AddUserStory(DummyLocalUserStory(TestSharedPageState))

test = Test()

story_runner.Run(

- test, us, self.expectations, self.options, self.results)

+ test, story_set, self.expectations, self.options, self.results)

self.assertEquals(2, test.run_count)

self.assertEquals(1, len(self.results.failures))

self.assertEquals(1, GetNumberOfSuccessfulPageRuns(self.results))

def testAppCrashThenRaiseInTearDownFatal(self):

self.SuppressExceptionFormatting()

- us = user_story_set.UserStorySet()

+ story_set = story.StorySet()

unit_test_events = [] # track what was called when

class DidRunTestError(Exception):

@@ -389,21 +390,23 @@ class StoryRunnerTest(unittest.TestCase):

def ValidateAndMeasurePage(self, page, tab, results):

pass

- us.AddUserStory(DummyLocalUserStory(TestTearDownSharedState))

+ story_set.AddUserStory(DummyLocalUserStory(TestTearDownSharedState))

test = Test()

with self.assertRaises(DidRunTestError):

story_runner.Run(

- test, us, self.expectations, self.options, self.results)

+ test, story_set, self.expectations, self.options, self.results)

self.assertEqual(['app-crash', 'tear-down-state'], unit_test_events)

# The AppCrashException gets added as a failure.

self.assertEquals(1, len(self.results.failures))

def testPagesetRepeat(self):

- us = user_story_set.UserStorySet()

- us.AddUserStory(DummyLocalUserStory(TestSharedPageState, name='blank'))

- us.AddUserStory(DummyLocalUserStory(TestSharedPageState, name='green'))

+ story_set = story.StorySet()

+ story_set.AddUserStory(

+ DummyLocalUserStory(TestSharedPageState, name='blank'))

+ story_set.AddUserStory(

+ DummyLocalUserStory(TestSharedPageState, name='green'))

class Measurement(page_test.PageTest):

i = 0

@@ -421,7 +424,7 @@ class StoryRunnerTest(unittest.TestCase):

results = results_options.CreateResults(

EmptyMetadataForTest(), self.options)

story_runner.Run(

- Measurement(), us, self.expectations, self.options, results)

+ Measurement(), story_set, self.expectations, self.options, results)

results.PrintSummary()

contents = self.fake_stdout.getvalue()

self.assertEquals(4, GetNumberOfSuccessfulPageRuns(results))

@@ -435,54 +438,63 @@ class StoryRunnerTest(unittest.TestCase):

usr_stub = system_stub.Override(story_runner, ['cloud_storage'])

wpr_stub = system_stub.Override(archive_info, ['cloud_storage'])

try:

- uss = user_story_set.UserStorySet()

- uss.AddUserStory(page_module.Page(

- 'http://www.testurl.com', uss, uss.base_dir))

+ story_set = story.StorySet()

+ story_set.AddUserStory(page_module.Page(

+ 'http://www.testurl.com', story_set, story_set.base_dir))

# Page set missing archive_data_file.

self.assertRaises(

story_runner.ArchiveError,

story_runner._UpdateAndCheckArchives,

- uss.archive_data_file, uss.wpr_archive_info, uss.user_stories)

+ story_set.archive_data_file,

+ story_set.wpr_archive_info,

+ story_set.user_stories)

- uss = user_story_set.UserStorySet(

+ story_set = story.StorySet(

archive_data_file='missing_archive_data_file.json')

- uss.AddUserStory(page_module.Page(

- 'http://www.testurl.com', uss, uss.base_dir))

+ story_set.AddUserStory(page_module.Page(

+ 'http://www.testurl.com', story_set, story_set.base_dir))

# Page set missing json file specified in archive_data_file.

self.assertRaises(

story_runner.ArchiveError,

story_runner._UpdateAndCheckArchives,

- uss.archive_data_file, uss.wpr_archive_info, uss.user_stories)

+ story_set.archive_data_file,

+ story_set.wpr_archive_info,

+ story_set.user_stories)

- uss = user_story_set.UserStorySet(

+ story_set = story.StorySet(

archive_data_file='../../unittest_data/archive_files/test.json',

cloud_storage_bucket=cloud_storage.PUBLIC_BUCKET)

- uss.AddUserStory(page_module.Page(

- 'http://www.testurl.com', uss, uss.base_dir))

+ story_set.AddUserStory(page_module.Page(

+ 'http://www.testurl.com', story_set, story_set.base_dir))

# Page set with valid archive_data_file.

self.assertTrue(story_runner._UpdateAndCheckArchives(

- uss.archive_data_file, uss.wpr_archive_info, uss.user_stories))

- uss.AddUserStory(page_module.Page(

- 'http://www.google.com', uss, uss.base_dir))

+ story_set.archive_data_file, story_set.wpr_archive_info,

+ story_set.user_stories))

+ story_set.AddUserStory(page_module.Page(

+ 'http://www.google.com', story_set, story_set.base_dir))

# Page set with an archive_data_file which exists but is missing a page.

self.assertRaises(

story_runner.ArchiveError,

story_runner._UpdateAndCheckArchives,

- uss.archive_data_file, uss.wpr_archive_info, uss.user_stories)

+ story_set.archive_data_file,

+ story_set.wpr_archive_info,

+ story_set.user_stories)

- uss = user_story_set.UserStorySet(

+ story_set = story.StorySet(

archive_data_file='../../unittest_data/test_missing_wpr_file.json',

cloud_storage_bucket=cloud_storage.PUBLIC_BUCKET)

- uss.AddUserStory(page_module.Page(

- 'http://www.testurl.com', uss, uss.base_dir))

- uss.AddUserStory(page_module.Page(

- 'http://www.google.com', uss, uss.base_dir))

+ story_set.AddUserStory(page_module.Page(

+ 'http://www.testurl.com', story_set, story_set.base_dir))

+ story_set.AddUserStory(page_module.Page(

+ 'http://www.google.com', story_set, story_set.base_dir))

# Page set with an archive_data_file which exists and contains all pages

# but fails to find a wpr file.

self.assertRaises(

story_runner.ArchiveError,

story_runner._UpdateAndCheckArchives,

- uss.archive_data_file, uss.wpr_archive_info, uss.user_stories)

+ story_set.archive_data_file,

+ story_set.wpr_archive_info,

+ story_set.user_stories)

finally:

usr_stub.Restore()

wpr_stub.Restore()

@@ -500,8 +512,8 @@ class StoryRunnerTest(unittest.TestCase):

def platform(self):

return self._fake_platform

- def WillRunUserStory(self, story):

- self._current_user_story = story

+ def WillRunUserStory(self, user_story):

+ self._current_user_story = user_story

def RunUserStory(self, results):

self._current_user_story.Run()

@@ -515,7 +527,7 @@ class StoryRunnerTest(unittest.TestCase):

def TearDownState(self):

pass

- class FailingUserStory(user_story.UserStory):

+ class FailingUserStory(user_story_module.UserStory):

def __init__(self):

super(FailingUserStory, self).__init__(

shared_state_class=SimpleSharedState,

@@ -528,9 +540,9 @@ class StoryRunnerTest(unittest.TestCase):

self.SuppressExceptionFormatting()

- uss = user_story_set.UserStorySet()

+ story_set = story.StorySet()

for _ in range(num_failing_user_stories):

- uss.AddUserStory(FailingUserStory())

+ story_set.AddUserStory(FailingUserStory())

options = _GetOptionForUnittest()

options.output_formats = ['none']

@@ -540,12 +552,12 @@ class StoryRunnerTest(unittest.TestCase):

results = results_options.CreateResults(EmptyMetadataForTest(), options)

story_runner.Run(

- DummyTest(), uss, test_expectations.TestExpectations(), options,

+ DummyTest(), story_set, test_expectations.TestExpectations(), options,

results, max_failures=runner_max_failures)

self.assertEquals(0, GetNumberOfSuccessfulPageRuns(results))

self.assertEquals(expected_num_failures, len(results.failures))

- for ii, story in enumerate(uss.user_stories):

- self.assertEqual(story.was_run, ii < expected_num_failures)

+ for ii, user_story in enumerate(story_set.user_stories):

+ self.assertEqual(user_story.was_run, ii < expected_num_failures)

def testMaxFailuresNotSpecified(self):

self._testMaxFailuresOptionIsRespectedAndOverridable(

« no previous file with comments | « tools/telemetry/telemetry/internal/story_runner.py ('k') | tools/telemetry/telemetry/page/page_set.py » ('j') | no next file with comments »