Waterfall components of regression range finder.

appengine/findit/waterfall/test/process_flake_swarming_task_result_pipeline_test.py

Index: appengine/findit/waterfall/test/process_flake_swarming_task_result_pipeline_test.py
diff --git a/appengine/findit/waterfall/test/process_swarming_task_result_pipeline_test.py b/appengine/findit/waterfall/test/process_flake_swarming_task_result_pipeline_test.py
similarity index 62%
copy from appengine/findit/waterfall/test/process_swarming_task_result_pipeline_test.py
copy to appengine/findit/waterfall/test/process_flake_swarming_task_result_pipeline_test.py
index 1bd527fa40442da05f38c1e36f9bf0e5c09ab6d9..79c85685683e14eb84bc4655ecea8ea1236fd795 100644
--- a/appengine/findit/waterfall/test/process_swarming_task_result_pipeline_test.py
+++ b/appengine/findit/waterfall/test/process_flake_swarming_task_result_pipeline_test.py
@@ -5,11 +5,11 @@
 import datetime
 
 from model import analysis_status
-from model.wf_swarming_task import WfSwarmingTask
-from waterfall import process_swarming_task_result_pipeline
+from model.flake.flake_swarming_task import FlakeSwarmingTask
+from model.flake.master_flake_analysis import MasterFlakeAnalysis
 from waterfall import swarming_util
-from waterfall.process_swarming_task_result_pipeline import (
-    ProcessSwarmingTaskResultPipeline)
+from waterfall.process_flake_swarming_task_result_pipeline import (
+    ProcessFlakeSwarmingTaskResultPipeline)
 from waterfall.test import wf_testcase
 
 
@@ -98,13 +98,9 @@ _EXPECTED_TESTS_STATUESE = {
         'FAILURE': 6
     }
 }
-_EXPECTED_CLASSIFIED_TESTS = {
-    'flaky_tests': ['TestSuite1.test2', 'TestSuite1.test1'],
-    'reliable_tests': ['TestSuite1.test3']
-}
 
 
-class ProcessSwarmingTaskResultPipelineTest(wf_testcase.WaterfallTestCase):
+class ProcessFlakeSwarmingTaskResultPipelineTest(wf_testcase.WaterfallTestCase):
 
   def _MockedGetSwarmingTaskResultById(self, task_id, _):
     swarming_task_results = {
@@ -133,87 +129,116 @@ class ProcessSwarmingTaskResultPipelineTest(wf_testcase.WaterfallTestCase):
     return mocked_result
 
   def setUp(self):
-    super(ProcessSwarmingTaskResultPipelineTest, self).setUp()
+    super(ProcessFlakeSwarmingTaskResultPipelineTest, self).setUp()
+    self.pipeline = ProcessFlakeSwarmingTaskResultPipeline()
     self.master_name = 'm'
     self.builder_name = 'b'
     self.build_number = 121
     self.step_name = 'abc_tests on platform'
+    self.test_name = 'test'
     self.mock(swarming_util, 'GetSwarmingTaskResultById',
               self._MockedGetSwarmingTaskResultById)
 
   def testCheckTestsRunStatusesNoOutPutJson(self):
+    call_params = ProcessFlakeSwarmingTaskResultPipeline._GetArgs(
+        self.pipeline, self.master_name, self.builder_name,
+        self.build_number, self.step_name, self.build_number,
+        self.test_name)
     tests_statuses = (
-        process_swarming_task_result_pipeline._CheckTestsRunStatuses(None))
+        ProcessFlakeSwarmingTaskResultPipeline._CheckTestsRunStatuses(
+            self.pipeline, None, *call_params
+        ))
     self.assertEqual({}, tests_statuses)
 
   def testCheckTestsRunStatuses(self):
+    analysis = MasterFlakeAnalysis.Create(
+        self.master_name, self.builder_name,
+        self.build_number, self.step_name, self.test_name)
+    analysis.put()
+
+    task = FlakeSwarmingTask.Create(
+        self.master_name, self.builder_name,
+        self.build_number, self.step_name, self.test_name)
+    task.put()
+
+    call_params = ProcessFlakeSwarmingTaskResultPipeline._GetArgs(
+        self.pipeline, self.master_name, self.builder_name,
+        self.build_number, self.step_name, self.build_number,
+        self.test_name)
+
     tests_statuses = (
-        process_swarming_task_result_pipeline._CheckTestsRunStatuses(
-            _SAMPLE_FAILURE_LOG))
+        ProcessFlakeSwarmingTaskResultPipeline._CheckTestsRunStatuses(
+            self.pipeline,
+            _SAMPLE_FAILURE_LOG, *call_params))
     self.assertEqual(_EXPECTED_TESTS_STATUESE, tests_statuses)
 
   def _MockedGetSwarmingTaskFailureLog(self, *_):
     return _SAMPLE_FAILURE_LOG
 
-  def testProcessSwarmingTaskResultPipeline(self):
+  def testProcessFlakeSwarmingTaskResultPipeline(self):
 
     self.mock(swarming_util, 'GetSwarmingTaskFailureLog',
               self._MockedGetSwarmingTaskFailureLog)
 
-    task = WfSwarmingTask.Create(
+    task = FlakeSwarmingTask.Create(
         self.master_name, self.builder_name,
-        self.build_number, self.step_name)
+        self.build_number, self.step_name, self.test_name)
     task.task_id = 'task_id1'
     task.put()
 
-    pipeline = ProcessSwarmingTaskResultPipeline()
-    step_name, task_info = pipeline.run(
+    analysis = MasterFlakeAnalysis.Create(
         self.master_name, self.builder_name,
-        self.build_number, self.step_name)
+        self.build_number, self.step_name, self.test_name)
+    analysis.put()
 
+    pipeline = ProcessFlakeSwarmingTaskResultPipeline()
+    step_name, task_info = pipeline.run(
+        self.master_name, self.builder_name,
+        self.build_number, self.step_name,
+        'task_id1', self.build_number, self.test_name)
+    self.assertEqual('abc_tests', task_info)
     self.assertEqual(self.step_name, step_name)
-    self.assertEqual('abc_tests', task_info[0])
-    self.assertEqual(_EXPECTED_CLASSIFIED_TESTS, task_info[1])
 
-    task = WfSwarmingTask.Get(
-        self.master_name, self.builder_name, self.build_number, self.step_name)
+    task = FlakeSwarmingTask.Get(
+        self.master_name, self.builder_name, self.build_number,
+        self.step_name, self.test_name)
 
     self.assertEqual(analysis_status.COMPLETED, task.status)
     self.assertEqual(_EXPECTED_TESTS_STATUESE, task.tests_statuses)
-    self.assertEqual(_EXPECTED_CLASSIFIED_TESTS, task.classified_tests)
+
     self.assertEqual(datetime.datetime(2016, 2, 10, 18, 32, 6, 538220),
                      task.created_time)
     self.assertEqual(datetime.datetime(2016, 2, 10, 18, 32, 9, 90550),
                      task.started_time)
     self.assertEqual(datetime.datetime(2016, 2, 10, 18, 33, 9),
                      task.completed_time)
-
-  def testProcessSwarmingTaskResultPipelineTaskNotRunning(self):
-
-    task = WfSwarmingTask.Create(
+  def testProcessFlakeSwarmingTaskResultPipelineTaskNotRunning(self):
+    task = FlakeSwarmingTask.Create(
         self.master_name, self.builder_name,
-        self.build_number, self.step_name)
+        self.build_number, self.step_name, self.test_name)
     task.task_id = 'task_id2'
     task.put()
 
-    pipeline = ProcessSwarmingTaskResultPipeline()
-    step_name, task_info = pipeline.run(
+    analysis = MasterFlakeAnalysis.Create(
         self.master_name, self.builder_name,
-        self.build_number, self.step_name)
+        self.build_number, self.step_name, self.test_name)
+    analysis.put()
 
+    pipeline = ProcessFlakeSwarmingTaskResultPipeline()
+    step_name, task_info = pipeline.run(
+        self.master_name, self.builder_name,
+        self.build_number, self.step_name,
+        'task_id2', self.build_number, self.test_name)
+    self.assertEqual(None, task_info)
     self.assertEqual(self.step_name, step_name)
-    self.assertIsNone(task_info[0])
-    self.assertEqual({}, task_info[1])
 
-    task = WfSwarmingTask.Get(
-        self.master_name, self.builder_name, self.build_number, self.step_name)
+    task = FlakeSwarmingTask.Get(
+        self.master_name, self.builder_name,
+        self.build_number, self.step_name, self.test_name)
 
     self.assertEqual(analysis_status.ERROR, task.status)
-    self.assertEqual({}, task.tests_statuses)
-    self.assertEqual({}, task.classified_tests)
-
-  def testProcessSwarmingTaskResultPipelineTaskTimeOut(self):
 
+  def testProcessFlakeSwarmingTaskResultPipelineTaskTimeOut(self):
     # Override swarming config settings to force a timeout.
     override_swarming_settings = {
         'task_timeout_hours': -1
@@ -221,24 +246,22 @@ class ProcessSwarmingTaskResultPipelineTest(wf_testcase.WaterfallTestCase):
     self.UpdateUnitTestConfigSettings(
         'swarming_settings', override_swarming_settings)
 
-    task = WfSwarmingTask.Create(
+    task = FlakeSwarmingTask.Create(
         self.master_name, self.builder_name,
-        self.build_number, self.step_name)
+        self.build_number, self.step_name, self.test_name)
     task.task_id = 'task_id1'
     task.put()
 
-    pipeline = ProcessSwarmingTaskResultPipeline()
+    pipeline = ProcessFlakeSwarmingTaskResultPipeline()
     step_name, task_info = pipeline.run(
         self.master_name, self.builder_name,
-        self.build_number, self.step_name)
-
+        self.build_number, self.step_name,
+        'task_id1', self.build_number, self.test_name)
+    self.assertEqual('abc_tests', task_info)
     self.assertEqual(self.step_name, step_name)
-    self.assertEqual('abc_tests', task_info[0])
-    self.assertEqual({}, task_info[1])
-
-    task = WfSwarmingTask.Get(
-        self.master_name, self.builder_name, self.build_number, self.step_name)
 
+    task = FlakeSwarmingTask.Get(
+        self.master_name, self.builder_name, self.build_number,
+        self.step_name, self.test_name)
     self.assertEqual(analysis_status.ERROR, task.status)
     self.assertEqual({}, task.tests_statuses)
-    self.assertEqual({}, task.classified_tests)