Move user_story.user_story_set to story.story_set

tools/telemetry/telemetry/internal/story_runner_unittest.py

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 681403b7ed7fb67f434c137f9dc1b9a8ab0facd6..cac4275d5aa61213039078d7aba599202830fa10 100644
--- a/tools/telemetry/telemetry/internal/story_runner_unittest.py
+++ b/tools/telemetry/telemetry/internal/story_runner_unittest.py
@@ -14,10 +14,10 @@ from telemetry.page import page_test
 from telemetry.page import test_expectations
 from telemetry.results import results_options
 from telemetry.story import shared_state
+from telemetry.story import story_set_module

[nednguyen, 2015/05/04 23:30:24]

Just use story or story_module is ok, I think

[aiolos (Not reviewing), 2015/05/09 03:53:58]

Done.

 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.util import cloud_storage
 from telemetry.util import exception_formatter as exception_formatter_module
 from telemetry.value import scalar
@@ -41,9 +41,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_modulez):
     super(TestSharedState, self).__init__(
-        test, options, user_story_setz)
+        test, options, story_set_modulez)
     self._test = test
     self._current_user_story = None
 
@@ -72,11 +72,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
 
 
@@ -102,16 +102,16 @@ class DummyLocalUserStory(user_story.UserStory):
   def is_local(self):
     return True
 
-class MixedStateStorySet(user_story_set.UserStorySet):
+class MixedStateStorySet(story_set_module.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()
   else:
-    us = user_story_set.UserStorySet()
+    us = story_set_module.StorySet()
   for user_story_state in user_story_state_list:
     us.AddUserStory(DummyLocalUserStory(user_story_state))
   return us
@@ -167,33 +167,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.
+    us = SetupStorySet(False, foo_states)
     story_groups = (
         story_runner.StoriesGroupedByStateClass(
             us, False))
     self.assertEqual(len(story_groups), 1)
-    us = SetupUserStorySet(False, mixed_states)
+    us = SetupStorySet(False, mixed_states)
     self.assertRaises(
         ValueError,
         story_runner.StoriesGroupedByStateClass,
         us, False)
-    # BaseUserStorySets are allowed to have multiple SharedStates.
-    bus = SetupUserStorySet(True, mixed_states)
+    # BaseStorySets are allowed to have multiple SharedStates.
+    bus = SetupStorySet(True, mixed_states)
     story_groups = (
         story_runner.StoriesGroupedByStateClass(
             bus, 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()
@@ -204,15 +204,15 @@ 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)
+    all_foo = [FooStoryState, FooStoryState, FooStoryState]
+    one_bar = [FooStoryState, FooStoryState, BarStoryState]
+    us = SetupStorySet(True, one_bar)
     self.RunUserStoryTest(us, 3)
-    us = SetupUserStorySet(True, all_foo)
+    us = SetupStorySet(True, all_foo)
     self.RunUserStoryTest(us, 6)
-    us = SetupUserStorySet(False, all_foo)
+    us = SetupStorySet(False, all_foo)
     self.RunUserStoryTest(us, 9)
-    us = SetupUserStorySet(False, one_bar)
+    us = SetupStorySet(False, one_bar)
     test = DummyTest()
     self.assertRaises(ValueError, story_runner.Run, test, us,
                       self.expectations, self.options, self.results)
@@ -229,7 +229,7 @@ class StoryRunnerTest(unittest.TestCase):
 
     test = timeline_based_measurement.TimelineBasedMeasurement(
         timeline_based_measurement.Options())
-    us = user_story_set.UserStorySet()
+    us = story_set_module.StorySet()
     us.AddUserStory(DummyLocalUserStory(TestSharedTbmState))
     us.AddUserStory(DummyLocalUserStory(TestSharedTbmState))
     us.AddUserStory(DummyLocalUserStory(TestSharedTbmState))
@@ -244,18 +244,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, story_set_modulez):
+        super(FoozStoryState, self).__init__(
+          test, options, story_set_modulez)
         fooz_init_call_counter[0] += 1
       def TearDownState(self, _results):
         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, story_set_modulez):
+        super(BarzStoryState, self).__init__(
+          test, options, story_set_modulez)
         barz_init_call_counter[0] += 1
       def TearDownState(self, _results):
         barz_tear_down_call_counter[0] += 1
@@ -265,27 +265,27 @@ 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()
+    us = story_set_module.StorySet()
     class SharedUserStoryThatCausesAppCrash(TestSharedPageState):
       def WillRunUserStory(self, user_storyz):
         raise exceptions.AppCrashException('App Foo crashes')
@@ -299,7 +299,7 @@ class StoryRunnerTest(unittest.TestCase):
 
   def testUnknownExceptionIsFatal(self):
     self.SuppressExceptionFormatting()
-    uss = user_story_set.UserStorySet()
+    story_set = story_set_module.StorySet()
 
     class UnknownException(Exception):
       pass
@@ -322,19 +322,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()
+    us = story_set_module.StorySet()
 
     class Test(page_test.PageTest):
       def __init__(self, *args):
@@ -361,7 +361,7 @@ class StoryRunnerTest(unittest.TestCase):
 
   def testAppCrashThenRaiseInTearDownFatal(self):
     self.SuppressExceptionFormatting()
-    us = user_story_set.UserStorySet()
+    us = story_set_module.StorySet()
 
     class DidRunTestError(Exception):
       pass
@@ -402,7 +402,7 @@ class StoryRunnerTest(unittest.TestCase):
     self.assertEquals(1, len(self.results.failures))
 
   def testPagesetRepeat(self):
-    us = user_story_set.UserStorySet()
+    us = story_set_module.StorySet()
     us.AddUserStory(DummyLocalUserStory(TestSharedPageState, name='blank'))
     us.AddUserStory(DummyLocalUserStory(TestSharedPageState, name='green'))
 
@@ -435,54 +435,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_set_module.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_set_module.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_set_module.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_set_module.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()
@@ -528,9 +537,9 @@ class StoryRunnerTest(unittest.TestCase):
 
     self.SuppressExceptionFormatting()
 
-    uss = user_story_set.UserStorySet()
+    story_set = story_set_module.StorySet()
     for _ in range(num_failing_user_stories):
-      uss.AddUserStory(FailingUserStory())
+      story_set.AddUserStory(FailingUserStory())
 
     options = _GetOptionForUnittest()
     options.output_formats = ['none']
@@ -540,11 +549,11 @@ 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):
+    for ii, story in enumerate(story_set.user_stories):
       self.assertEqual(story.was_run, ii < expected_num_failures)
 
   def testMaxFailuresNotSpecified(self):