Add initial postprocess unit test thingy.

recipe_engine/third_party/expect_tests/handle_train.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 collections
 import os
 import sys
 import time
 
 from .type_definitions import DirSeen, Handler, MultiTest, Failure
 from .serialize import WriteNewData, DiffData, NonExistant, GetCurrentData
+from .handle_test import FailChecks
 
 
 ForcedWriteAction = collections.namedtuple('ForcedWriteAction', 'test')
 DiffWriteAction = collections.namedtuple('DiffWriteAction', 'test')
 SchemaDiffWriteAction = collections.namedtuple('SchemaDiffWriteAction', 'test')
 MissingWriteAction = collections.namedtuple('MissingWriteAction', 'test')
 NoAction = collections.namedtuple('NoAction', 'test')
 
 
 class TrainHandler(Handler):
@@ skipping 37 matching lines @@
       diff = DiffData(current, result.data)
       if diff is not None or not same_schema:
         WriteNewData(test, result.data)
         if current is NonExistant:
           put_next_stage(MissingWriteAction(test))
         elif diff:
           put_next_stage(DiffWriteAction(test))
         else:
           put_next_stage(SchemaDiffWriteAction(test))
       else:
-        put_next_stage(NoAction(test))
+        failed_checks = [check for check in result.checks if not check.passed]
+        if failed_checks:
+          put_next_stage(FailChecks(test, failed_checks))
+        else:
+          put_next_stage(NoAction(test))
 
   class ResultStageHandler(Handler.ResultStageHandler):
     def __init__(self, opts):
       super(TrainHandler.ResultStageHandler, self).__init__(opts)
       self.dirs_seen = set()
       self.files_expected = collections.defaultdict(set)
       self.start = time.time()
       self.num_tests = 0
       self.verbose_actions = []
       self.normal_actions = []
 
     def _record_expected(self, test, indicator):
       self.num_tests += 1
       if not self.opts.quiet:
         sys.stdout.write(indicator)
         sys.stdout.flush()
       if test.expect_path() is not None:
         head, tail = os.path.split(test.expect_path())
         self.files_expected[head].add(tail)
 
     def _record_write(self, test, indicator, why):
       self._record_expected(test, indicator)
       if test.expect_path() is not None:
         name = test.expect_path() if self.opts.verbose else test.name
         self.normal_actions.append('Wrote %s: %s' % (name, why))
 
     def handle_DirSeen(self, dirseen):
       self.dirs_seen.add(dirseen.dir)
 
+    def handle_FailChecks(self, fc):
+      self._record_expected(fc.test, 'C')
+      self.normal_actions.append(
+        ('%r failed checks!\n' % fc.test.name) + fc.format(2))
+      return Failure()
+
     def handle_NoAction(self, result):
       self._record_expected(result.test, '.')
       self.verbose_actions.append('%s did not change' % result.test.name)
 
     def handle_ForcedWriteAction(self, result):
       self._record_write(result.test, 'F', 'forced')
 
     def handle_DiffWriteAction(self, result):
       self._record_write(result.test, 'D', 'diff')
 
@@ skipping 31 matching lines @@
         if self.normal_actions:
           print '\n'.join(self.normal_actions)
         if self.opts.verbose:
           if self.verbose_actions:
             print '\n'.join(self.verbose_actions)
 
         trained = sum(len(x) for x in self.files_expected.itervalues())
         print '-' * 70
         print 'Trained %d tests in %0.3fs (ran %d tests)' % (
             trained, time.time() - self.start, self.num_tests)