Aggregate tests now passes. Moved various unit test code that ran on import into setup and teardown functions that are called at the appropriate time when run with other tests.

tuf/tests/repository_setup.py

@@ -31,17 +31,21 @@
 import tuf.tests.unittest_toolbox as unittest_toolbox
 
 
-# Populating 'rsa_keystore' and 'rsa_passwords' dictionaries.
-# We will need them in creating keystore directory.
-unittest_toolbox.Modified_TestCase.bind_keys_to_roles()
-
 
 #  Role:keyids dictionary.
 role_keyids = {}
-for role in unittest_toolbox.Modified_TestCase.semi_roledict.keys():
-  role_keyids[role] = unittest_toolbox.Modified_TestCase.semi_roledict[role]['keyids']
 
 
+def _init_role_keyids():
+  # Populating 'rsa_keystore' and 'rsa_passwords' dictionaries.
+  # We will need them in creating keystore directory.
+  unittest_toolbox.Modified_TestCase.bind_keys_to_roles()
+
+  global role_keyids
+
+  for role in unittest_toolbox.Modified_TestCase.semi_roledict.keys():
+    role_keyids[role] = unittest_toolbox.Modified_TestCase.semi_roledict[role]['keyids']
+
 
 
 
@@ -54,6 +58,7 @@ def _create_keystore(keystore_directory):
   _rsa_keystore = unittest_toolbox.Modified_TestCase.rsa_keystore
   _rsa_passwords = unittest_toolbox.Modified_TestCase.rsa_passwords
   if not _rsa_keystore or not _rsa_passwords:
+    import pdb; pdb.set_trace()
     msg = 'Populate \'rsa_keystore\' and \'rsa_passwords\''+\
           ' before invoking this method.'
     sys.exit(msg)
@@ -275,6 +280,7 @@ def create_repositories():
 
   """
 
+  _init_role_keyids()
 
   #  Make a temporary general repository directory.
   repository_dir = tempfile.mkdtemp()

tuf/tests/test_signercli.py

@@ -56,9 +56,6 @@ class guarantees the order of unit tests.  So that, 'test_something_A'
 
 logger = logging.getLogger('tuf.test_signercli')
 
-# Populating 'rsa_keystore' and 'rsa_passwords' dictionaries.
-# We will need them when creating keystore directories.
-unittest_toolbox.Modified_TestCase.bind_keys_to_roles()
 
 
 class TestSignercli(unittest_toolbox.Modified_TestCase):
@@ -1556,6 +1553,12 @@ def _mock_get_keyids(junk):
     signercli._get_metadata_directory = original_get_metadata_directory
 
 
+def setUpModule():
+  # Populating 'rsa_keystore' and 'rsa_passwords' dictionaries.
+  # We will need them when creating keystore directories.
+  unittest_toolbox.Modified_TestCase.bind_keys_to_roles()
+
+
 def tearDownModule():
   unittest_toolbox.Modified_TestCase.clear_toolbox()
 

tuf/tests/test_signerlib.py

@@ -68,8 +68,6 @@
 # 'unittest_toolbox.Modified_TestCase' is too long, I'll set it to 'unit_tbox'.
 unit_tbox = tuf.tests.unittest_toolbox.Modified_TestCase
 
-# Generate rsa keys and roles dictionary dictionaries.
-unit_tbox.bind_keys_to_roles()
 
 
 class TestSignerlib(unit_tbox):
@@ -972,6 +970,11 @@ def _get_signed_role_info(self, role, directory=None):
                                           filename)
     return signed_meta, role_info
 
+
+def setUpModule():
+  # Generate rsa keys and roles dictionary dictionaries.
+  unit_tbox.bind_keys_to_roles()
+
 def tearDownModule():
   unit_tbox.clear_toolbox()
   tuf.repo.keystore.clear_keystore()

tuf/tests/test_updater.py

@@ -56,10 +56,6 @@ class guarantees the order of unit tests.  So that, 'test_something_A'
 
 logger = logging.getLogger('tuf.test_updater')
 
-#  References to roledb and keydb dictionaries (improve readability).
-roledb = tuf.roledb
-keydb = tuf.keydb
-
 
 
 class TestUpdater_init_(unittest_toolbox.Modified_TestCase):
@@ -105,39 +101,43 @@ def test__init__exceptions(self):
         os.remove(role_filepath)
     updater.Updater('Repo_Name', self.mirrors)
 
-    #  Remove all created repositories.
+    #  Remove all created repositories and roles.
     setup.remove_all_repositories(repositories['main_repository'])
+    tuf.roledb.clear_roledb()
 
 
 
 
 class TestUpdater(unittest_toolbox.Modified_TestCase):
-  # Create repositories.  'repositories' is a tuple that looks like this:
-  # (repository_dir, client_repository_dir, server_repository_dir), see 
-  # repository_setup.py odule.
-  repositories = setup.create_repositories()
 
-  # Save references to repository directories and metadata.
-  #  Server side references.
-  server_repo_dir = repositories['server_repository']
-  server_meta_dir = os.path.join(server_repo_dir, 'metadata')
-  root_filepath = os.path.join(server_meta_dir, 'root.txt')
-  timestamp_filepath = os.path.join(server_meta_dir, 'timestamp.txt')
-  targets_filepath = os.path.join(server_meta_dir, 'targets.txt')
-  release_filepath = os.path.join(server_meta_dir, 'release.txt')
+  @classmethod
+  def setUpClass(cls):
+    # Create repositories.  'repositories' is a tuple that looks like this:
+    # (repository_dir, client_repository_dir, server_repository_dir), see 
+    # repository_setup.py odule.
+    cls.repositories = setup.create_repositories()
 
-  #  References to delegated metadata paths and directories.
-  delegated_dir1 = os.path.join(server_meta_dir, 'targets')
-  delegated_filepath1 = os.path.join(delegated_dir1, 'delegated_role1.txt')
-  delegated_dir2 = os.path.join(delegated_dir1, 'delegated_role1')
-  delegated_filepath2 = os.path.join(delegated_dir2, 'delegated_role2.txt')
-  targets_dir = os.path.join(server_repo_dir, 'targets')  
+    # Save references to repository directories and metadata.
+    #  Server side references.
+    cls.server_repo_dir = cls.repositories['server_repository']
+    cls.server_meta_dir = os.path.join(cls.server_repo_dir, 'metadata')
+    cls.root_filepath = os.path.join(cls.server_meta_dir, 'root.txt')
+    cls.timestamp_filepath = os.path.join(cls.server_meta_dir, 'timestamp.txt')
+    cls.targets_filepath = os.path.join(cls.server_meta_dir, 'targets.txt')
+    cls.release_filepath = os.path.join(cls.server_meta_dir, 'release.txt')
 
-  #  Client side references.
-  client_repo_dir = repositories['client_repository']
-  client_meta_dir = os.path.join(client_repo_dir, 'metadata')
-  client_current_dir = os.path.join(client_meta_dir, 'current')
-  client_previous_dir = os.path.join(client_meta_dir, 'previous')
+    #  References to delegated metadata paths and directories.
+    cls.delegated_dir1 = os.path.join(cls.server_meta_dir, 'targets')
+    cls.delegated_filepath1 = os.path.join(cls.delegated_dir1, 'delegated_role1.txt')
+    cls.delegated_dir2 = os.path.join(cls.delegated_dir1, 'delegated_role1')
+    cls.delegated_filepath2 = os.path.join(cls.delegated_dir2, 'delegated_role2.txt')
+    cls.targets_dir = os.path.join(cls.server_repo_dir, 'targets')  
+
+    #  Client side references.
+    cls.client_repo_dir = cls.repositories['client_repository']
+    cls.client_meta_dir = os.path.join(cls.client_repo_dir, 'metadata')
+    cls.client_current_dir = os.path.join(cls.client_meta_dir, 'current')
+    cls.client_previous_dir = os.path.join(cls.client_meta_dir, 'previous')
 
 
 
@@ -176,8 +176,8 @@ def tearDown(self):
     unittest_toolbox.Modified_TestCase.tearDown(self)
 
     #  Clear roledb and keydb dictionaries.
-    roledb.clear_roledb()
-    keydb.clear_keydb()
+    tuf.roledb.clear_roledb()
+    tuf.keydb.clear_keydb()
 
 
 
@@ -379,14 +379,14 @@ def test_1__rebuild_key_and_role_db(self):
     #  are populated.  'top_level_role_info' is a unittest_toolbox's dict
     #  that contains top level role information it corresponds to a
     #  ROLEDICT_SCHEMA where roles are keys and role information their values.
-    self.assertEqual(roledb._roledb_dict, self.top_level_role_info)
-    self.assertEqual(len(keydb._keydb_dict), 4)
+    self.assertEqual(tuf.roledb._roledb_dict, self.top_level_role_info)
+    self.assertEqual(len(tuf.keydb._keydb_dict), 4)
 
     #  Verify that keydb dictionary was updated.
     for role in self.role_list:
       keyids = self.top_level_role_info[role]['keyids']
       for keyid in keyids:
-        self.assertTrue(keyid in keydb._keydb_dict)
+        self.assertTrue(keyid in tuf.keydb._keydb_dict)
 
 
 
@@ -408,22 +408,22 @@ def test_2__import_delegations(self):
 
     #  Verify that there was no change in roledb and keydb dictionaries
     #  by checking the number of elements in the dictionaries.
-    self.assertEqual(len(roledb._roledb_dict), 5)       
-    self.assertEqual(len(keydb._keydb_dict), 5)
+    self.assertEqual(len(tuf.roledb._roledb_dict), 5)       
+    self.assertEqual(len(tuf.keydb._keydb_dict), 5)
 
     # Test: normal case, first level delegation.
     self.Repository._import_delegations('targets/delegated_role1')
 
-    self.assertEqual(len(roledb._roledb_dict), 6)
-    self.assertEqual(len(keydb._keydb_dict), 6)
+    self.assertEqual(len(tuf.roledb._roledb_dict), 6)
+    self.assertEqual(len(tuf.keydb._keydb_dict), 6)
 
     #  Verify that roledb dictionary was updated.
-    self.assertTrue('targets/delegated_role1' in roledb._roledb_dict)
+    self.assertTrue('targets/delegated_role1' in tuf.roledb._roledb_dict)
     
     #  Verify that keydb dictionary was updated.
     keyids = self.semi_roledict['targets/delegated_role1']['keyids']
     for keyid in keyids:
-      self.assertTrue(keyid in keydb._keydb_dict)
+      self.assertTrue(keyid in tuf.keydb._keydb_dict)