test: promote --train to its own subcommand

unittests/test_test.py

 #!/usr/bin/env python
 # Copyright 2017 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
 import json
 import os
 import shutil
 import subprocess
 import sys
@@ skipping 539 matching lines @@
     self.assertEqual(
         self.json_generator
             .coverage_failure('recipe_modules/foo_module/api.py', [10]).get(),
         self.json_contents)
 
   def test_train_basic(self):
     rw = RecipeWriter(os.path.join(self._root_dir, 'recipes'), 'foo')
     rw.RunStepsLines = ['pass']
     rw.add_expectation('basic')
     rw.write()
-    self._run_recipes('test', 'run', '--train', '--json', self.json_path)
+    self._run_recipes('test', 'train', '--json', self.json_path)
     self.assertEqual(self.json_generator.get(), self.json_contents)
 
   def test_train_missing(self):
     rw = RecipeWriter(os.path.join(self._root_dir, 'recipes'), 'foo')
     rw.RunStepsLines = ['pass']
     rw.write()
     self.assertFalse(os.path.exists(rw.expect_dir))
-    self._run_recipes('test', 'run', '--train', '--json', self.json_path)
+    self._run_recipes('test', 'train', '--json', self.json_path)
     self.assertTrue(os.path.exists(rw.expect_dir))
     expect_path = os.path.join(rw.expect_dir, 'basic.json')
     self.assertTrue(os.path.exists(expect_path))
     with open(expect_path) as f:
       expect_contents = json.load(f)
     self.assertEqual(
         [{u'status_code': 0, u'recipe_result': None, u'name': u'$result'}],
         expect_contents)
     self.assertEqual(self.json_generator.get(), self.json_contents)
 
@@ skipping 10 matching lines @@
     rw.DEPS = ['recipe_engine/step']
     rw.RunStepsLines = ['api.step("test", ["echo", "bar"])']
     rw.write()
     with self.assertRaises(subprocess.CalledProcessError) as cm:
       self._run_recipes('test', 'run', '--json', self.json_path)
     self.assertIn('foo.basic failed', cm.exception.output)
     self.assertEqual(self.json_generator.diff_failure('foo.basic').get(),
                      self.json_contents)
 
     # 3. Make sure training the recipe succeeds and produces correct results.
-    self._run_recipes('test', 'run', '--train', '--json', self.json_path)
+    self._run_recipes('test', 'train', '--json', self.json_path)
     expect_path = os.path.join(rw.expect_dir, 'basic.json')
     with open(expect_path) as f:
       expect_contents = json.load(f)
     self.assertEqual(
         [{u'cmd': [u'echo', u'bar'], u'name': u'test'},
          {u'status_code': 0, u'recipe_result': None, u'name': u'$result'}],
         expect_contents)
     self.assertEqual(self.json_generator.get(), self.json_contents)
 
   def test_train_checks_coverage(self):
     rw = RecipeWriter(os.path.join(self._root_dir, 'recipes'), 'foo')
     rw.RunStepsLines = ['if False:', '  pass']
     rw.add_expectation('basic')
     rw.write()
     with self.assertRaises(subprocess.CalledProcessError) as cm:
-      self._run_recipes('test', 'run', '--train', '--json', self.json_path)
+      self._run_recipes('test', 'train', '--json', self.json_path)
     self.assertIn('FATAL: Insufficient coverage', cm.exception.output)
     self.assertNotIn('CHECK(FAIL)', cm.exception.output)
     self.assertNotIn('foo.basic failed', cm.exception.output)
     self.assertEqual(
         self.json_generator.coverage_failure('recipes/foo.py', [7]).get(),
         self.json_contents)
 
   def test_train_runs_checks(self):
     rw = RecipeWriter(os.path.join(self._root_dir, 'recipes'), 'foo')
     rw.RunStepsLines = ['pass']
     rw.GenTestsLines = [
         'yield api.test("basic") + \\',
         '  api.post_process(post_process.MustRun, "bar")'
     ]
     rw.add_expectation('basic')
     rw.write()
     with self.assertRaises(subprocess.CalledProcessError) as cm:
-      self._run_recipes('test', 'run', '--train', '--json', self.json_path)
+      self._run_recipes('test', 'train', '--json', self.json_path)
     self.assertNotIn('FATAL: Insufficient coverage', cm.exception.output)
     self.assertIn('CHECK(FAIL)', cm.exception.output)
     self.assertIn('foo.basic failed', cm.exception.output)
     self.assertEqual(
         self.json_generator.check_failure(
             'foo.basic', 'recipes/foo.py', 10,
             'MustRun', args=['\'bar\'']).get(),
         self.json_contents)
 
   def test_unused_expectation_file_test(self):
@@ skipping 16 matching lines @@
         self.json_contents)
 
   def test_unused_expectation_file_train(self):
     rw = RecipeWriter(os.path.join(self._root_dir, 'recipes'), 'foo')
     rw.RunStepsLines = ['pass']
     rw.add_expectation('basic')
     rw.add_expectation('unused')
     rw.write()
     expectation_file = os.path.join(rw.expect_dir, 'unused.json')
     self.assertTrue(os.path.exists(expectation_file))
-    self._run_recipes('test', 'run', '--train', '--json', self.json_path)
+    self._run_recipes('test', 'train', '--json', self.json_path)
     self.assertFalse(os.path.exists(expectation_file))
     self.assertEqual(self.json_generator.get(), self.json_contents)
 
   def test_unused_expectation_dir_test(self):
     rw = RecipeWriter(os.path.join(self._root_dir, 'recipes'), 'foo')
     rw.RunStepsLines = ['pass']
     rw.add_expectation('basic')
     rw.write()
     expectation_dir = os.path.join(rw.expect_dir, 'dir')
     os.makedirs(expectation_dir)
     with self.assertRaises(subprocess.CalledProcessError) as cm:
       self._run_recipes('test', 'run', '--json', self.json_path)
     self.assertIn(
         'FATAL: unused expectations found:\n%s' % expectation_dir,
         cm.exception.output)
     self.assertTrue(os.path.exists(expectation_dir))
     self.assertEqual(
         self.json_generator
             .unused_expectation('recipes/foo.expected/dir').get(),
         self.json_contents)
 
   def test_unused_expectation_dir_train(self):
     rw = RecipeWriter(os.path.join(self._root_dir, 'recipes'), 'foo')
     rw.RunStepsLines = ['pass']
     rw.add_expectation('basic')
     rw.write()
     expectation_dir = os.path.join(rw.expect_dir, 'dir')
     os.makedirs(expectation_dir)
-    self._run_recipes('test', 'run', '--train', '--json', self.json_path)
+    self._run_recipes('test', 'train', '--json', self.json_path)
     self.assertFalse(os.path.exists(expectation_dir))
     self.assertEqual(self.json_generator.get(), self.json_contents)
 
   def test_drop_expectation_test(self):
     rw = RecipeWriter(os.path.join(self._root_dir, 'recipes'), 'foo')
     rw.RunStepsLines = ['pass']
     rw.GenTestsLines = [
         'yield api.test("basic") + \\',
         '  api.post_process(post_process.DropExpectation)'
     ]
     rw.write()
     expectation_file = os.path.join(rw.expect_dir, 'basic.json')
     self.assertFalse(os.path.exists(expectation_file))
     self._run_recipes('test', 'run', '--json', self.json_path)
     self.assertFalse(os.path.exists(expectation_file))
     self.assertEqual(self.json_generator.get(), self.json_contents)
 
   def test_drop_expectation_train(self):
     rw = RecipeWriter(os.path.join(self._root_dir, 'recipes'), 'foo')
     rw.RunStepsLines = ['pass']
     rw.GenTestsLines = [
         'yield api.test("basic") + \\',
         '  api.post_process(post_process.DropExpectation)'
     ]
     rw.write()
     expectation_file = os.path.join(rw.expect_dir, 'basic.json')
     self.assertFalse(os.path.exists(expectation_file))
-    self._run_recipes('test', 'run', '--train', '--json', self.json_path)
+    self._run_recipes('test', 'train', '--json', self.json_path)
     self.assertFalse(os.path.exists(expectation_file))
     self.assertEqual(self.json_generator.get(), self.json_contents)
 
   def test_drop_expectation_test_unused(self):
     rw = RecipeWriter(os.path.join(self._root_dir, 'recipes'), 'foo')
     rw.RunStepsLines = ['pass']
     rw.GenTestsLines = [
         'yield api.test("basic") + \\',
         '  api.post_process(post_process.DropExpectation)'
     ]
@@ skipping 18 matching lines @@
     rw = RecipeWriter(os.path.join(self._root_dir, 'recipes'), 'foo')
     rw.RunStepsLines = ['pass']
     rw.GenTestsLines = [
         'yield api.test("basic") + \\',
         '  api.post_process(post_process.DropExpectation)'
     ]
     rw.add_expectation('basic')
     rw.write()
     expectation_file = os.path.join(rw.expect_dir, 'basic.json')
     self.assertTrue(os.path.exists(expectation_file))
-    self._run_recipes('test', 'run', '--train', '--json', self.json_path)
+    self._run_recipes('test', 'train', '--json', self.json_path)
     self.assertFalse(os.path.exists(expectation_file))
     self.assertFalse(os.path.exists(rw.expect_dir))
     self.assertEqual(self.json_generator.get(), self.json_contents)
 
   def test_unused_expectation_preserves_owners_test(self):
     rw = RecipeWriter(os.path.join(self._root_dir, 'recipes'), 'foo')
     rw.RunStepsLines = ['pass']
     rw.add_expectation('basic')
     rw.write()
     owners_file = os.path.join(rw.expect_dir, 'OWNERS')
     with open(owners_file, 'w') as f:
       pass
     self.assertTrue(os.path.exists(owners_file))
     self._run_recipes('test', 'run', '--json', self.json_path)
     self.assertTrue(os.path.exists(owners_file))
     self.assertEqual(self.json_generator.get(), self.json_contents)
 
   def test_unused_expectation_preserves_owners_train(self):
     rw = RecipeWriter(os.path.join(self._root_dir, 'recipes'), 'foo')
     rw.RunStepsLines = ['pass']
     rw.add_expectation('basic')
     rw.write()
     owners_file = os.path.join(rw.expect_dir, 'OWNERS')
     with open(owners_file, 'w') as f:
       pass
     self.assertTrue(os.path.exists(owners_file))
-    self._run_recipes('test', 'run', '--train', '--json', self.json_path)
+    self._run_recipes('test', 'train', '--json', self.json_path)
     self.assertTrue(os.path.exists(owners_file))
     self.assertEqual(self.json_generator.get(), self.json_contents)
 
   def test_test_slash_in_name(self):
     test_name = 'bar/baz'
     rw = RecipeWriter(os.path.join(self._root_dir, 'recipes'), 'foo')
     rw.RunStepsLines = ['pass']
     rw.GenTestsLines = ['yield api.test(%r)' % test_name]
     rw.add_expectation(test_name)
     rw.write()
     self._run_recipes('test', 'run', '--json', self.json_path)
     self.assertEqual(self.json_generator.get(), self.json_contents)
 
 
 if __name__ == '__main__':
   sys.exit(unittest.main())