Revert of [Telemetry] Ensure that story display names are unique

telemetry/telemetry/internal/story_runner_unittest.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import math
 import os
 import StringIO
 import sys
 import unittest
 
@@ skipping 116 matching lines @@
 class MixedStateStorySet(story_module.StorySet):
   @property
   def allow_mixed_story_states(self):
     return True
 
 def SetupStorySet(allow_multiple_story_states, story_state_list):
   if allow_multiple_story_states:
     story_set = MixedStateStorySet()
   else:
     story_set = story_module.StorySet()
-  for i, story_state in enumerate(story_state_list):
-    story_set.AddStory(DummyLocalStory(story_state,
-                                       name='story%d' % i))
+  for story_state in story_state_list:
+    story_set.AddStory(DummyLocalStory(story_state))
   return story_set
 
 def _GetOptionForUnittest():
   options = options_for_unittests.GetCopy()
   options.output_formats = ['none']
   options.suppress_gtest_report = False
   parser = options.CreateParser()
   story_runner.AddCommandLineArgs(parser)
   options.MergeDefaultValues(parser.get_default_values())
   story_runner.ProcessCommandLineArgs(parser, options)
@@ skipping 140 matching lines @@
 
     manager = mock.MagicMock()
     test.WillRunStory = mock.MagicMock()
     test.Measure = mock.MagicMock()
     test.DidRunStory = mock.MagicMock()
     manager.attach_mock(test.WillRunStory, TEST_WILL_RUN_STORY)
     manager.attach_mock(test.Measure, TEST_MEASURE)
     manager.attach_mock(test.DidRunStory, TEST_DID_RUN_STORY)
 
     story_set = story_module.StorySet()
-    story_set.AddStory(DummyLocalStory(TestSharedTbmState, name='foo'))
-    story_set.AddStory(DummyLocalStory(TestSharedTbmState, name='bar'))
-    story_set.AddStory(DummyLocalStory(TestSharedTbmState, name='baz'))
+    story_set.AddStory(DummyLocalStory(TestSharedTbmState))
+    story_set.AddStory(DummyLocalStory(TestSharedTbmState))
+    story_set.AddStory(DummyLocalStory(TestSharedTbmState))
     story_runner.Run(
         test, story_set, self.options, self.results)
     self.assertEquals(0, len(self.results.failures))
     self.assertEquals(3, GetNumberOfSuccessfulPageRuns(self.results))
 
     self.assertEquals(3*EXPECTED_CALLS_IN_ORDER,
                       [call[0] for call in manager.mock_calls])
 
   def testCallOrderBetweenStoryTestAndSharedState(self):
     """Check that the call order between StoryTest and SharedState is correct.
@@ skipping 55 matching lines @@
     class TestSharedStateForTearDown(TestSharedState):
       num_of_tear_downs = 0
 
       def RunStory(self, results):
         pass
 
       def TearDownState(self):
         TestSharedStateForTearDown.num_of_tear_downs += 1
 
     story_set = story_module.StorySet()
-    story_set.AddStory(DummyLocalStory(TestSharedStateForTearDown, name='foo'))
-    story_set.AddStory(DummyLocalStory(TestSharedStateForTearDown, name='bar'))
-    story_set.AddStory(DummyLocalStory(TestSharedStateForTearDown, name='baz'))
+    story_set.AddStory(DummyLocalStory(TestSharedStateForTearDown))
+    story_set.AddStory(DummyLocalStory(TestSharedStateForTearDown))
+    story_set.AddStory(DummyLocalStory(TestSharedStateForTearDown))
 
     TestSharedStateForTearDown.num_of_tear_downs = 0
     story_runner.Run(mock.MagicMock(), story_set, self.options, self.results)
     self.assertEquals(TestSharedStateForTearDown.num_of_tear_downs, 1)
 
     TestSharedStateForTearDown.num_of_tear_downs = 0
     story_runner.Run(mock.MagicMock(), story_set, self.options, self.results,
                      tear_down_after_story=True)
     self.assertEquals(TestSharedStateForTearDown.num_of_tear_downs, 3)
 
@@ skipping 92 matching lines @@
 
       def RunPage(self, *_):
         old_run_count = self.run_count
         self.run_count += 1
         if old_run_count == 1:
           raise UnknownException('FooBarzException')
 
       def ValidateAndMeasurePage(self, page, tab, results):
         pass
 
-    s1 = DummyLocalStory(TestSharedPageState, name='foo')
-    s2 = DummyLocalStory(TestSharedPageState, name='bar')
+    s1 = DummyLocalStory(TestSharedPageState)
+    s2 = DummyLocalStory(TestSharedPageState)
     story_set.AddStory(s1)
     story_set.AddStory(s2)
     test = Test()
     with self.assertRaises(UnknownException):
       story_runner.Run(
           test, story_set, self.options, self.results)
     self.assertEqual(set([s2]), self.results.pages_that_failed)
     self.assertEqual(set([s1]), self.results.pages_that_succeeded)
     self.assertIn('FooBarzException', self.fake_stdout.getvalue())
 
   def testRaiseBrowserGoneExceptionFromRunPage(self):
     self.SuppressExceptionFormatting()
     story_set = story_module.StorySet()
 
     class Test(legacy_page_test.LegacyPageTest):
       def __init__(self, *args):
         super(Test, self).__init__(*args)
         self.run_count = 0
 
       def RunPage(self, *_):
         old_run_count = self.run_count
         self.run_count += 1
         if old_run_count == 0:
           raise exceptions.BrowserGoneException(
               None, 'i am a browser crash message')
 
       def ValidateAndMeasurePage(self, page, tab, results):
         pass
 
-    story_set.AddStory(DummyLocalStory(TestSharedPageState, name='foo'))
-    story_set.AddStory(DummyLocalStory(TestSharedPageState, name='bar'))
+    story_set.AddStory(DummyLocalStory(TestSharedPageState))
+    story_set.AddStory(DummyLocalStory(TestSharedPageState))
     test = Test()
     story_runner.Run(
         test, story_set, 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()
     story_set = story_module.StorySet()
@@ skipping 19 matching lines @@
       def RunPage(self, *_):
         old_run_count = self.run_count
         self.run_count += 1
         if old_run_count == 0:
           unit_test_events.append('app-crash')
           raise exceptions.AppCrashException
 
       def ValidateAndMeasurePage(self, page, tab, results):
         pass
 
-    story_set.AddStory(DummyLocalStory(TestTearDownSharedState, name='foo'))
-    story_set.AddStory(DummyLocalStory(TestTearDownSharedState, name='bar'))
+    story_set.AddStory(DummyLocalStory(TestTearDownSharedState))
+    story_set.AddStory(DummyLocalStory(TestTearDownSharedState))
     test = Test()
 
     with self.assertRaises(DidRunTestError):
       story_runner.Run(
           test, story_set, self.options, self.results)
     self.assertEqual(['app-crash', 'dump-state', 'tear-down-state'],
                      unit_test_events)
     # The AppCrashException gets added as a failure.
     self.assertEquals(1, len(self.results.failures))
 
@@ skipping 139 matching lines @@
       def CanRunStory(self, story):
         return True
 
       def TearDownState(self):
         pass
 
       def DumpStateUponFailure(self, story, results):
         pass
 
     class FailingStory(story_module.Story):
-      def __init__(self, name):
+      def __init__(self):
         super(FailingStory, self).__init__(
             shared_state_class=SimpleSharedState,
-            is_local=True, name=name)
+            is_local=True)
         self.was_run = False
 
       def Run(self, shared_state):
         self.was_run = True
         raise legacy_page_test.Failure
 
       @property
       def url(self):
         return 'data:,'
 
     self.SuppressExceptionFormatting()
 
     story_set = story_module.StorySet()
-    for i in range(num_failing_stories):
-      story_set.AddStory(FailingStory(name='failing%d' % i))
+    for _ in range(num_failing_stories):
+      story_set.AddStory(FailingStory())
 
     options = _GetOptionForUnittest()
     options.output_formats = ['none']
     options.suppress_gtest_report = True
     if options_max_failures:
       options.max_failures = options_max_failures
 
     results = results_options.CreateResults(EmptyMetadataForTest(), options)
     story_runner.Run(
         DummyTest(), story_set, options,
@@ skipping 234 matching lines @@
       mock.call.test.WillRunStory(root_mock.state.platform),
       mock.call.state.WillRunStory(root_mock.story),
       mock.call.state.CanRunStory(root_mock.story),
       mock.call.state.RunStory(root_mock.results),
       mock.call.test.Measure(root_mock.state.platform, root_mock.results),
       mock.call.state.DumpStateUponFailure(root_mock.story, root_mock.results),
       mock.call.results.AddValue(FailureValueMatcher('foo')),
       mock.call.state.DidRunStory(root_mock.results),
       mock.call.test.DidRunStory(root_mock.state.platform)
     ])