Split out the big chromite shell 'main.py' into lots of subfiles.

shell/main_unittest.py

 #!/usr/bin/python
 #
 # Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Unit tests for main.py."""
 
 import doctest
 import os
 import re
 import unittest
 
+import chromite.lib.cros_build_lib as cros_lib
 from chromite.lib import text_menu
 from chromite.shell import main
+from chromite.shell import utils
 import mox
 
 
 class _DeathException(Exception):
-  """A bogus exception used by the mock out of Die."""
+  """A bogus exception used by the mock out of cros_lib.Die."""
   pass
 
 
 class TestFindCommand(unittest.TestCase):
   """Test main._FindCommand."""
   # TODO(dianders): Add a test where I override main._COMMAND_HANDLERS
   # and main._COMMAND_STRS so that I can test more of _FindCommand().
 
   def setUp(self):
     """Test initialization."""
     # Create our mox and stub out function calls used by _FindCommand()...
     self.mox = mox.Mox()
-    self.mox.StubOutWithMock(main, 'Die')
-    self.mox.StubOutWithMock(main, 'Info')
+    self.mox.StubOutWithMock(cros_lib, 'Die')
+    self.mox.StubOutWithMock(cros_lib, 'Info')
     self.mox.StubOutWithMock(text_menu, 'TextMenu')
 
   def tearDown(self):
     """Test cleanup."""
     # Unset stubs...
     self.mox.UnsetStubs()
 
   def testInvalidCommand(self):
-    """Test that _FindCommand('implode') causes Die()."""
-    # Should be a call to Die.  We'll have it fake a _DeathException...
-    main.Die(mox.IsA(basestring)).AndRaise(_DeathException)
+    """Test that _FindCommand('implode') causes cros_lib.Die()."""
+    # Should be a call to cros_lib.Die.  We'll have it fake a _DeathException...
+    cros_lib.Die(mox.IsA(basestring)).AndRaise(_DeathException)
 
     # Run the command and verify proper mocks were called...
     self.mox.ReplayAll()
     self.assertRaises(_DeathException, main._FindCommand, 'implode')
     self.mox.VerifyAll()
 
   def testBlankCommandWithQuit(self):
     """Test that _FindCommand('') shows menu, mocking quit.
 
     This tests the case that the user quit out of the menu without choosing
     anything.
     """
     # Should be one call to TextMenu, which will return None for quit.
     text_menu.TextMenu(mox.IsA(list),
                        mox.IsA(basestring),
                        menu_width=0).AndReturn(None)
 
     # Should die in response to the quit.
-    main.Die(mox.IsA(basestring)).AndRaise(_DeathException)
+    cros_lib.Die(mox.IsA(basestring)).AndRaise(_DeathException)
 
     # Run the command and verify proper mocks were called...
     self.mox.ReplayAll()
     self.assertRaises(_DeathException, main._FindCommand, '')
     self.mox.VerifyAll()
 
   def testBlankCommandWithChoice0(self):
     """Test that _FindCommand('') shows menu, mocking choice 0.
 
     This tests the case that the user chose choice 0 for the menu.
@@ skipping 47 matching lines @@
   def testShCommand(self):
     """Test that _FindCommand('sh') returns 'shell'.
 
     This serves two purposes:
     1. Test the 'prefix' feature of _FindCommand
     2. Validate that nobody has introduced another command that starts with
        'sh', since it's expected that many people will use this to invoke the
        shell.
     """
     # _FindCommand should give us a message that it has interpreted sh as shell.
-    main.Info(mox.IsA(basestring))
+    cros_lib.Info(mox.IsA(basestring))
 
     # Run the command and verify proper mocks were called...
     self.mox.ReplayAll()
     cmd_str = main._FindCommand('sh')
     self.mox.VerifyAll()
 
     self.assertEqual(cmd_str, 'shell',
                      '_FindCommand("sh") should return "shell" back.')
 
 
 class TestFindSpec(unittest.TestCase):
-  """Test main._FindSpec."""
+  """Test utils.FindSpec."""
 
   def setUp(self):
     """Test initialization."""
     # Create our mox and stub out function calls used by _FindSpec()...
     self.mox = mox.Mox()
     self.mox.StubOutWithMock(os, 'listdir')
     self.mox.StubOutWithMock(os.path, 'isfile')
-    self.mox.StubOutWithMock(main, 'Die')
-    self.mox.StubOutWithMock(main, 'Info')
+    self.mox.StubOutWithMock(cros_lib, 'Die')
+    self.mox.StubOutWithMock(cros_lib, 'Info')
     self.mox.StubOutWithMock(text_menu, 'TextMenu')
 
   def tearDown(self):
     """Test cleanup."""
     # Unset stubs...
     self.mox.UnsetStubs()
 
   def testInvalidSpec(self):
-    """Test that _FindSpec('bogusSpec') causes Die()."""
+    """Test that _FindSpec('bogusSpec') causes cros_lib.Die()."""
     # Pass this spec name...
     spec_name = 'bogusSpec'
 
     # We'll tell mox to say that these specs exist...
     dir_list = ['x87-toadstool.spec', 'x87-luigi.SPeC', 'x88-princess.spec',
                 '_default']
 
     # This spec doesn't represent any full path.
     os.path.isfile(spec_name).AndReturn(False)
 
     # This spec isn't found in our search path.
     os.path.isfile(mox.Regex('^/.*%s.spec$' % spec_name)).MultipleTimes(
         ).AndReturn(False)
 
     # Give the fake directory listing...
     os.listdir(mox.IsA(basestring)).MultipleTimes().AndReturn(dir_list)
 
-    # Should be a call to Die.  We'll have it fake a _DeathException...
-    main.Die(mox.IsA(basestring)).AndRaise(_DeathException)
+    # Should be a call to cros_lib.Die.  We'll have it fake a _DeathException...
+    cros_lib.Die(mox.IsA(basestring)).AndRaise(_DeathException)
 
     # Run the command and verify proper mocks were called...
     self.mox.ReplayAll()
-    self.assertRaises(_DeathException, main._FindSpec, 'bogusSpec')
+    self.assertRaises(_DeathException, utils.FindSpec, 'bogusSpec')
     self.mox.VerifyAll()
 
   def testFullPath(self):
     """Test that _FindSpec(full_path) returns full_path.
 
     _FindSpec is defined so that if you pass a full file path to it, it
     should just return that.  It doesn't need to have any special suffix or
     live in a spec folder.
     """
     # Pass this spec name...
     spec_name = __file__
 
     # Just say that this is a full path...
     os.path.isfile(spec_name).AndReturn(True)
 
     # Run the command and verify proper mocks were called...
     self.mox.ReplayAll()
-    path = main._FindSpec(spec_name)
+    path = utils.FindSpec(spec_name)
     self.mox.VerifyAll()
 
     self.assertEqual(path, spec_name,
                      '_FindSpec() should just return param if full path.')
 
   def testExactSpecName(self):
     """Test that _FindSpec(exact_spec_name) returns the path for the spec."""
     # We'll search for this bogus spec; we'll use mox to pretend it exists in
     # the search path.
     spec_name = 'y87-luigi'
 
     # This spec doesn't represent any full path
     os.path.isfile(spec_name).AndReturn(False)
 
     # When we look through the search path for this spec (with .spec at
     # the end), we will consider the spec to be found.
     os.path.isfile(mox.Regex('^/.*%s.spec$' % spec_name)).AndReturn(True)
 
     # Run the command and verify proper mocks were called...
     self.mox.ReplayAll()
-    spec_path = main._FindSpec(spec_name)
+    spec_path = utils.FindSpec(spec_name)
     self.mox.VerifyAll()
 
     self.assertTrue(re.search('^/.*%s.spec$' % spec_name, spec_path),
                     '_FindSpec() should have returned absolute path for spec.')
 
   def testUniqueSpecName(self):
     """Test that _FindSpec(unique_part_name) returns the path for the spec."""
     # We'll search for this spec.  Weird capitalization on purpose to test
     # case sensitiveness.
     spec_name = 'ToaDSTooL'
@@ skipping 17 matching lines @@
 
     # Return our directory listing.
     # TODO(dianders): How to make first mocked call return dir_list and
     # subsequent return []
     os.listdir(mox.IsA(basestring)).AndReturn(dir_list)
 
     os.path.isfile(mox.Regex('^/.*%s$' % expected_result)).AndReturn(True)
 
     # Run the command and verify proper mocks were called...
     self.mox.ReplayAll()
-    spec_path = main._FindSpec(spec_name)
+    spec_path = utils.FindSpec(spec_name)
     self.mox.VerifyAll()
 
     self.assertTrue(re.search('^/.*%s$' % expected_result, spec_path),
                     '_FindSpec("%s") incorrectly returned "%s".' %
                     (spec_name, spec_path))
 
   def _TestBlankSpecName(self, menu_return):
     """Helper for tests passing a blank spec name.
 
     Args:
@@ skipping 32 matching lines @@
       adjusted_menu_return = menu_return
     else:
       adjusted_menu_return = menu_return + 1
 
     # Should be one call to TextMenu, which will return menu_return.
     text_menu.TextMenu(mox.And(mox.IsA(list), mox.Func(check_num_items_fn)),
                        mox.IsA(basestring)).AndReturn(adjusted_menu_return)
 
     # Should die in response to the quit if directed to quit.
     if menu_return is None:
-      main.Die(mox.IsA(basestring)).AndRaise(_DeathException)
+      cros_lib.Die(mox.IsA(basestring)).AndRaise(_DeathException)
 
     # Run the command and verify proper mocks were called...
     self.mox.ReplayAll()
     if menu_return is None:
-      self.assertRaises(_DeathException, main._FindSpec, spec_name)
+      self.assertRaises(_DeathException, utils.FindSpec, spec_name)
     else:
-      spec_path = main._FindSpec(spec_name)
+      spec_path = utils.FindSpec(spec_name)
     self.mox.VerifyAll()
 
     if menu_return is not None:
       expected_result = dir_list[menu_return]
       self.assertTrue(re.search('^/.*%s$' % expected_result, spec_path),
                       '_FindSpec("%s") incorrectly returned "%s".' %
                       (spec_name, spec_path))
 
   def testBlankSpecNameWithQuit(self):
     """Test that _FindSpec('') shows menu, mocking quit."""
@@ skipping 35 matching lines @@
     for i in xrange(num_match):
       os.path.isfile(mox.Regex('^/.*%s$' % matches[i])).AndReturn(True)
 
     # Should be one call to TextMenu, which will return 0.
     text_menu.TextMenu(mox.And(mox.IsA(list),
                                mox.Func(lambda items: len(items) == num_match)),
                        mox.IsA(basestring)).AndReturn(0)
 
     # Run the command and verify proper mocks were called...
     self.mox.ReplayAll()
-    spec_path = main._FindSpec(spec_name)
+    spec_path = utils.FindSpec(spec_name)
     self.mox.VerifyAll()
 
     self.assertTrue(re.search('^/.*%s$' % expected_result, spec_path),
                     '_FindSpec("%s") incorrectly returned "%s".' %
                     (spec_name, spec_path))
 
 
 if __name__ == '__main__':
   doctest.testmod(main)
   unittest.main()