[Findit] A huge refactoring and some bug fixing.

appengine/findit/model/test/wf_analysis_test.py

Index: appengine/findit/model/test/wf_analysis_test.py
diff --git a/appengine/findit/model/test/wf_analysis_test.py b/appengine/findit/model/test/wf_analysis_test.py
index e948fa830afcf51f088926f5623de402d631b3ef..6f9eb78f1288fa004842f62317ccea32365dae6a 100644
--- a/appengine/findit/model/test/wf_analysis_test.py
+++ b/appengine/findit/model/test/wf_analysis_test.py
@@ -7,108 +7,108 @@ from datetime import datetime
 import unittest
 
 from model.wf_analysis import WfAnalysis
-from model import wf_analysis_status
-from model import wf_analysis_result_status
+from model import analysis_status
+from model import result_status
 
 
 class WfAnalysisTest(unittest.TestCase):
   def testWfAnalysisStatusIsCompleted(self):
-    for status in (wf_analysis_status.ANALYZED, wf_analysis_status.ERROR):
+    for status in (analysis_status.COMPLETED, analysis_status.ERROR):
       analysis = WfAnalysis.Create('m', 'b', 123)
       analysis.status = status
       self.assertTrue(analysis.completed)
 
   def testWfAnalysisStatusIsNotCompleted(self):
-    for status in (wf_analysis_status.PENDING, wf_analysis_status.ANALYZING):
+    for status in (analysis_status.PENDING, analysis_status.RUNNING):
       analysis = WfAnalysis.Create('m', 'b', 123)
       analysis.status = status
       self.assertFalse(analysis.completed)
 
   def testWfAnalysisDurationWhenNotCompleted(self):
     analysis = WfAnalysis.Create('m', 'b', 123)
-    analysis.status = wf_analysis_status.ANALYZING
+    analysis.status = analysis_status.RUNNING
     self.assertIsNone(analysis.duration)
 
   def testWfAnalysisDurationWhenStartTimeNotSet(self):
     analysis = WfAnalysis.Create('m', 'b', 123)
-    analysis.status = wf_analysis_status.ANALYZED
+    analysis.status = analysis_status.COMPLETED
     analysis.end_time = datetime(2015, 07, 30, 21, 15, 30, 40)
     self.assertIsNone(analysis.duration)
 
   def testWfAnalysisDurationWhenEndTimeNotSet(self):
     analysis = WfAnalysis.Create('m', 'b', 123)
-    analysis.status = wf_analysis_status.ANALYZED
+    analysis.status = analysis_status.COMPLETED
     analysis.start_time = datetime(2015, 07, 30, 21, 15, 30, 40)
     self.assertIsNone(analysis.duration)
 
   def testWfAnalysisDurationWhenCompleted(self):
     analysis = WfAnalysis.Create('m', 'b', 123)
-    analysis.status = wf_analysis_status.ANALYZED
+    analysis.status = analysis_status.COMPLETED
     analysis.start_time = datetime(2015, 07, 30, 21, 15, 30, 40)
     analysis.end_time = datetime(2015, 07, 30, 21, 16, 15, 50)
     self.assertEqual(45, analysis.duration)
 
   def testWfAnalysisStatusIsFailed(self):
     analysis = WfAnalysis.Create('m', 'b', 123)
-    analysis.status = wf_analysis_status.ERROR
+    analysis.status = analysis_status.ERROR
     self.assertTrue(analysis.failed)
 
   def testWfAnalysisStatusIsNotFailed(self):
-    for status in (wf_analysis_status.PENDING, wf_analysis_status.ANALYZING,
-                   wf_analysis_status.ANALYZED):
+    for status in (analysis_status.PENDING, analysis_status.RUNNING,
+                   analysis_status.COMPLETED):
       analysis = WfAnalysis.Create('m', 'b', 123)
       analysis.status = status
       self.assertFalse(analysis.failed)
 
   def testWfAnalysisStatusDescription(self):
     analysis = WfAnalysis.Create('m', 'b', 123)
-    analysis.status = wf_analysis_status.PENDING
+    analysis.status = analysis_status.PENDING
     self.assertEqual("Pending", analysis.status_description)
-    analysis.status = wf_analysis_status.ANALYZING
-    self.assertEqual("Analyzing", analysis.status_description)
-    analysis.status = wf_analysis_status.ANALYZED
-    self.assertEqual("Analyzed", analysis.status_description)
-    analysis.status = wf_analysis_status.ERROR
+    analysis.status = analysis_status.RUNNING
+    self.assertEqual("Running", analysis.status_description)
+    analysis.status = analysis_status.COMPLETED
+    self.assertEqual("Completed", analysis.status_description)
+    analysis.status = analysis_status.ERROR
     self.assertEqual("Error", analysis.status_description)
 
   def testWfAnalysisResultStatusDescription(self):
     analysis = WfAnalysis.Create('m', 'b', 123)
 
     self.assertEqual('', analysis.result_status_description)
-    analysis.result_status = wf_analysis_result_status.FOUND_CORRECT
+    analysis.result_status = result_status.FOUND_CORRECT
     self.assertEqual("Correct - Found", analysis.result_status_description)
 
   def testWfAnalysisCorrectnessIsUnknownIfIncompletedOrFailed(self):
-    for status in (wf_analysis_status.PENDING, wf_analysis_status.ANALYZING,
-                   wf_analysis_status.ERROR):
+    for status in (analysis_status.PENDING, analysis_status.RUNNING,
+                   analysis_status.ERROR):
       analysis = WfAnalysis.Create('m', 'b', 123)
       analysis.status = status
       self.assertIsNone(analysis.correct)
 
   def testWfAnalysisCorrectnessIsUnknownIfUntriaged(self):
-    for result_status in (wf_analysis_result_status.FOUND_UNTRIAGED,
-                          wf_analysis_result_status.NOT_FOUND_UNTRIAGED):
+    for status in (result_status.FOUND_UNTRIAGED,
+                          result_status.NOT_FOUND_UNTRIAGED):
       analysis = WfAnalysis.Create('m', 'b', 123)
-      analysis.status = wf_analysis_status.ANALYZED
-      analysis.result_status = result_status
+      analysis.status = analysis_status.COMPLETED
+      analysis.result_status = status
       self.assertIsNone(analysis.correct)
 
   def testWfAnalysisHasCorrectResult(self):
-    for result_status in (
-        wf_analysis_result_status.FOUND_CORRECT,
-        wf_analysis_result_status.NOT_FOUND_CORRECT,
-        wf_analysis_result_status.FOUND_CORRECT_DUPLICATE):
+    for status in (
+        result_status.FOUND_CORRECT,
+        result_status.NOT_FOUND_CORRECT,
+        result_status.FOUND_CORRECT_DUPLICATE):
       analysis = WfAnalysis.Create('m', 'b', 123)
-      analysis.status = wf_analysis_status.ANALYZED
-      analysis.result_status = result_status
+      analysis.status = analysis_status.COMPLETED
+      analysis.result_status = status
       self.assertTrue(analysis.correct)
 
   def testWfAnalysisHasIncorrectResult(self):
-    for result_status in (
-        wf_analysis_result_status.FOUND_INCORRECT,
-        wf_analysis_result_status.NOT_FOUND_INCORRECT,
-        wf_analysis_result_status.FOUND_INCORRECT_DUPLICATE):
+    for status in (
+        result_status.FOUND_INCORRECT,
+        result_status.NOT_FOUND_INCORRECT,
+        result_status.FOUND_INCORRECT_DUPLICATE):
       analysis = WfAnalysis.Create('m', 'b', 123)
-      analysis.status = wf_analysis_status.ANALYZED
-      analysis.result_status = result_status
+      analysis.status = analysis_status.COMPLETED
+      analysis.result_status = status
       self.assertFalse(analysis.correct)