From ddd8b6bfd0f1ced07940df6b3f8126efff3f1fcf Mon Sep 17 00:00:00 2001
From: vladdd <vladimir.v.diaz@gmail.com>
Date: Mon, 7 Apr 2014 15:28:46 -0400
Subject: [PATCH 01/10] Add test_repository_tool.py

Add 'test_repository_tool.py' (initial incomplete commit)
Add test cases for the top-level metadata objects (Root(), Targets(), etc.)
Add test case for Repository()
Add test case for get_target_hash()
Minor update to 'repository_tool.py': add default rolename for Targets() and call tuf.util.get_target_hash() in the
repository tool's get_target_hash()
---
 tests/unit/test_repository_tool.py | 308 +++++++++++++++++++++++++++++
 tuf/repository_tool.py             |  32 +--
 2 files changed, 313 insertions(+), 27 deletions(-)
 create mode 100755 tests/unit/test_repository_tool.py

diff --git a/tests/unit/test_repository_tool.py b/tests/unit/test_repository_tool.py
new file mode 100755
index 00000000..cb6f61a5
--- /dev/null
+++ b/tests/unit/test_repository_tool.py
@@ -0,0 +1,308 @@
+"""
+<Program Name>
+  test_repository_tool.py
+
+<Author> 
+  Vladimir Diaz <vladimir.v.diaz@gmail.com>
+
+<Started>
+  April 7, 2014. 
+
+<Copyright>
+  See LICENSE for licensing information.
+
+<Purpose>
+  Unit test for 'repository_tool.py'.
+"""
+
+import unittest
+import logging
+
+import tuf
+import tuf.log
+import tuf.formats
+import tuf.roledb
+import tuf.keydb
+import tuf.repository_tool as repo_tool
+
+logger = logging.getLogger('tuf.test_repository_tool')
+
+
+
+class TestRepository(unittest.TestCase):
+  def setUp(self):
+    pass
+
+
+
+  def tearDown(self):
+    tuf.roledb.clear_roledb() 
+    tuf.keydb.clear_keydb()
+
+
+  def test_init(self):
+    
+    # Test normal case.
+    repository = repo_tool.Repository('repository_directory/',
+                                      'metadata_directory/',
+                                      'targets_directory/')
+    self.assertTrue(isinstance(repository.root, repo_tool.Root))
+    self.assertTrue(isinstance(repository.snapshot, repo_tool.Snapshot))
+    self.assertTrue(isinstance(repository.timestamp, repo_tool.Timestamp))
+    self.assertTrue(isinstance(repository.targets, repo_tool.Targets))
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, repo_tool.Repository, 3,
+                      'metadata_directory/', 'targets_directory')
+    self.assertRaises(tuf.FormatError, repo_tool.Repository,
+                      'repository_directory', 3, 'targets_directory')
+    self.assertRaises(tuf.FormatError, repo_tool.Repository,
+                      'repository_directory', 'metadata_directory', 3)
+
+
+
+class TestMetadata(unittest.TestCase):
+  def setUp(self):
+    pass
+
+
+
+  def tearDown(self):
+    pass
+
+
+
+
+
+class TestRoot(unittest.TestCase):
+  def setUp(self):
+    pass
+
+
+
+  def tearDown(self):
+    tuf.roledb.clear_roledb() 
+    tuf.keydb.clear_keydb()
+
+
+  
+  def test_init(self):
+    
+    # Test normal case.
+    # Root() subclasses Metadata(), and creates a 'root' role in 'tuf.roledb'.
+    root_object = repo_tool.Root()
+    self.assertTrue(isinstance(root_object, repo_tool.Metadata))
+    self.assertTrue(tuf.roledb.role_exists('root'))
+
+
+
+class TestTimestamp(unittest.TestCase):
+  def setUp(self):
+    pass
+
+
+
+  def tearDown(self):
+    tuf.roledb.clear_roledb() 
+    tuf.keydb.clear_keydb()
+  
+  
+  
+  def test_init(self):
+    
+    # Test normal case.
+    # Timestamp() subclasses Metadata(), and creates a 'timestamp' role in
+    # 'tuf.roledb'.
+    timestamp_object = repo_tool.Timestamp()
+    self.assertTrue(isinstance(timestamp_object, repo_tool.Metadata))
+    self.assertTrue(tuf.roledb.role_exists('timestamp'))
+
+
+
+
+
+class TestSnapshot(unittest.TestCase):
+  def setUp(self):
+    pass
+
+
+
+  def tearDown(self):
+    tuf.roledb.clear_roledb() 
+    tuf.keydb.clear_keydb()
+  
+  
+  
+  def test_init(self):
+    
+    # Test normal case.
+    # Snapshot() subclasses Metadata(), and creates a 'snapshot' role in
+    # 'tuf.roledb'.
+    snapshot_object = repo_tool.Snapshot()
+    self.assertTrue(isinstance(snapshot_object, repo_tool.Metadata))
+    self.assertTrue(tuf.roledb.role_exists('snapshot'))
+
+
+
+
+
+class TestTargets(unittest.TestCase):
+  def setUp(self):
+    pass
+
+
+
+  def tearDown(self):
+    tuf.roledb.clear_roledb() 
+    tuf.keydb.clear_keydb()
+  
+  
+  
+  def test_init(self):
+    
+    # Test normal case.
+    # Snapshot() subclasses Metadata(), and creates a 'snapshot' role in
+    # 'tuf.roledb'.
+    targets_object = repo_tool.Targets('targets_directory/')
+    self.assertTrue(isinstance(targets_object, repo_tool.Metadata))
+    self.assertTrue(tuf.roledb.role_exists('targets'))
+
+    # Custom Targets object rolename.
+    targets_object = repo_tool.Targets('targets_directory/', 'project') 
+    self.assertTrue(isinstance(targets_object, repo_tool.Metadata))
+    self.assertTrue(tuf.roledb.role_exists('project'))
+
+    # Custom roleinfo object (i.e., tuf.formats.ROLEDB_SCHEMA).  'keyids' and
+    # 'threshold' are required, the rest are optional.
+    roleinfo = {'keyids': 
+          ['66c4cb5fef5e4d62b7013ef1cab4b8a827a36c14056d5603c3a970e21eb30e6f'],
+                'threshold': 8}
+    self.assertTrue(tuf.formats.ROLEDB_SCHEMA.matches(roleinfo))
+    
+    targets_object = repo_tool.Targets('targets_directory/', 'package', roleinfo)
+    self.assertTrue(isinstance(targets_object, repo_tool.Metadata))
+    self.assertTrue(tuf.roledb.role_exists('package'))
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, repo_tool.Targets, 3)
+    self.assertRaises(tuf.FormatError, repo_tool.Targets, 'targets_directory/', 3)
+    self.assertRaises(tuf.FormatError, repo_tool.Targets, 'targets_directory/',
+                      'targets', 3)
+
+
+
+class TestRepositoryToolFunctions(unittest.TestCase):
+  def setUp(self):
+    pass
+
+
+  def tearDown(self):
+    pass
+
+
+
+  def test_create_new_repository(self):
+    pass
+
+
+
+  def test_load_repository(self):
+    pass
+
+
+
+  def test_generate_and_write_rsa_keypair(self):
+    pass
+
+
+
+  def test_import_rsa_privatekey_from_file(self):
+    pass
+
+
+
+  def test_import_rsa_publickey_from_file(self):
+    pass
+
+
+
+  def test_generate_and_write_ed25519_keypair(self):
+    pass
+
+
+
+  def test_import_ed25519_publickey_from_file(self):
+    pass
+
+
+
+  def test_import_ed25519_privatekey_from_file(self):
+    pass
+
+
+
+  def test_get_metadata_filenames(self):
+    pass
+
+
+
+  def test_get_metadata_file_info(self):
+    pass
+
+
+
+  def test_get_target_hash(self):
+    # Test normal case. 
+    expected_target_hashes = {
+      '/file1.txt': 'e3a3d89eb3b70ce3fbce6017d7b8c12d4abd5635427a0e8a238f53157df85b3d',
+      '/README.txt': '8faee106f1bb69f34aaf1df1e3c2e87d763c4d878cb96b91db13495e32ceb0b0',
+      '/packages/file2.txt': 'c9c4a5cdd84858dd6a23d98d7e6e6b2aec45034946c16b2200bc317c75415e92'  
+    }
+    for filepath, target_hash in expected_target_hashes.items():
+      self.assertTrue(tuf.formats.RELPATH_SCHEMA.matches(filepath))
+      self.assertTrue(tuf.formats.HASH_SCHEMA.matches(target_hash))
+      self.assertEqual(repo_tool.get_target_hash(filepath), target_hash)
+   
+    # Test for improperly formatted argument.
+    self.assertRaises(tuf.FormatError, repo_tool.get_target_hash, 8)
+
+
+
+  def test_generate_root_metadata(self):
+    pass
+
+
+
+  def test_generate_targets_metadata(self):
+    pass
+
+
+
+  def test_generate_snapshot_metadata(self):
+    pass
+
+
+
+  def test_generate_timestamp_metadata(self):
+    pass
+
+
+
+  def test_sign_metadata(self):
+    pass
+
+
+
+  def test_write_metadata_file(self):
+    pass
+
+
+
+  def test_create_tuf_client_directory(self):
+    pass
+
+
+# Run the test cases.
+if __name__ == '__main__':
+  unittest.main()
diff --git a/tuf/repository_tool.py b/tuf/repository_tool.py
index 69211c4e..32408475 100755
--- a/tuf/repository_tool.py
+++ b/tuf/repository_tool.py
@@ -188,7 +188,7 @@ def write(self, write_partial=False, consistent_snapshot=False):
       private keys, etc.
     
     <Arguments>
-      write_partial:
+      mrite_partial:
         A boolean indicating whether partial metadata should be written to
         disk.  Partial metadata may be written to allow multiple maintainters
         to independently sign and update role metadata.  write() raises an
@@ -1479,13 +1479,14 @@ class Targets(Metadata):
     tuf.FormatError, if the arguments are improperly formatted.
 
   <Side Effects>
-    Modifies the roleinfo of the targets role in 'tuf.roledb'.
+    Modifies the roleinfo of the targets role in 'tuf.roledb', or creates
+    a default one named 'targets'.
   
   <Returns>
     None.
   """
   
-  def __init__(self, targets_directory, rolename, roleinfo=None):
+  def __init__(self, targets_directory, rolename='targets', roleinfo=None):
    
     # Do the arguments have the correct format?
     # Ensure the arguments have the appropriate number of objects and object
@@ -3831,30 +3832,7 @@ def get_target_hash(target_filepath):
     The hash of 'target_filepath'.
   """
   
-  # Does 'target_filepath' have the correct format?
-  # Ensure the arguments have the appropriate number of objects and object
-  # types, and that all dict keys are properly named.
-  # Raise 'tuf.FormatError' if there is a mismatch.
-  tuf.formats.RELPATH_SCHEMA.check_match(target_filepath)
-
-  # Calculate the hash of the filepath to determine which bin to find the 
-  # target.  The client currently assumes the repository uses
-  # 'HASH_FUNCTION' to generate hashes.
-  digest_object = tuf.hash.digest(HASH_FUNCTION)
-
-  try:
-    digest_object.update(target_filepath)
-  
-  except UnicodeEncodeError:
-    # Sometimes, there are Unicode characters in target paths. We assume a
-    # UTF-8 encoding and try to hash that.
-    digest_object = tuf.hash.digest(HASH_FUNCTION)
-    encoded_target_filepath = target_filepath.encode('utf-8')
-    digest_object.update(encoded_target_filepath)
-
-  target_filepath_hash = digest_object.hexdigest() 
-
-  return target_filepath_hash
+  return tuf.util.get_target_hash(target_filepath)
 
 
 

From 0f3cdd9f61bbf612da2a8d200f2367a351de3b09 Mon Sep 17 00:00:00 2001
From: vladdd <vladimir.v.diaz@gmail.com>
Date: Mon, 7 Apr 2014 20:21:39 -0400
Subject: [PATCH 02/10] Continue updating test_repository_tool.py.

Add test cases for the crypto funtions (e.g., generate_and_write_ed25519_keypair()).
Add test case for get_metadata_filenames().
Add test case for get_metadata_fileinfo().
Add setUpClass() and tearDownClass().
Update affected functions that failed testing, and any that needed modifying (such as util.py).
---
 tests/unit/test_repository_tool.py | 272 ++++++++++++++++++++++++++++-
 tests/unit/test_updater.py         |   2 +-
 tuf/pycrypto_keys.py               |  10 +-
 tuf/repository_tool.py             |  48 ++---
 tuf/util.py                        |  13 +-
 5 files changed, 308 insertions(+), 37 deletions(-)

diff --git a/tests/unit/test_repository_tool.py b/tests/unit/test_repository_tool.py
index cb6f61a5..4cd58723 100755
--- a/tests/unit/test_repository_tool.py
+++ b/tests/unit/test_repository_tool.py
@@ -15,14 +15,18 @@
   Unit test for 'repository_tool.py'.
 """
 
+import os
 import unittest
 import logging
+import tempfile
+import shutil
 
 import tuf
 import tuf.log
 import tuf.formats
 import tuf.roledb
 import tuf.keydb
+import tuf.hash
 import tuf.repository_tool as repo_tool
 
 logger = logging.getLogger('tuf.test_repository_tool')
@@ -193,6 +197,30 @@ def test_init(self):
 
 
 class TestRepositoryToolFunctions(unittest.TestCase):
+  @classmethod
+  def setUpClass(cls):
+    
+    # setUpClass() is called before tests in an individual class are executed.
+    
+    # Create a temporary directory to store the repository, metadata, and target
+    # files.  'temporary_directory' must be deleted in TearDownClass() so that
+    # temporary files are always removed, even when exceptions occur. 
+    cls.temporary_directory = tempfile.mkdtemp(dir=os.getcwd())
+    
+
+
+  @classmethod 
+  def tearDownClass(cls):
+    
+    # tearDownModule() is called after all the tests have run.
+    # http://docs.python.org/2/library/unittest.html#class-and-module-fixtures
+   
+    # Remove the temporary repository directory, which should contain all the
+    # metadata, targets, and key files generated for the test cases.
+    shutil.rmtree(cls.temporary_directory)
+
+
+
   def setUp(self):
     pass
 
@@ -213,42 +241,268 @@ def test_load_repository(self):
 
 
   def test_generate_and_write_rsa_keypair(self):
-    pass
+  
+    # Test normal case.
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory) 
+    test_keypath = os.path.join(temporary_directory, 'rsa_key')
+
+    repo_tool.generate_and_write_rsa_keypair(test_keypath, password='pw')
+    self.assertTrue(os.path.exists(test_keypath))
+    self.assertTrue(os.path.exists(test_keypath + '.pub'))
+    
+    # Ensure the generated key files are importable.
+    imported_pubkey = \
+      repo_tool.import_rsa_publickey_from_file(test_keypath + '.pub')
+    self.assertTrue(tuf.formats.RSAKEY_SCHEMA.matches(imported_pubkey))
+    
+    imported_privkey = \
+      repo_tool.import_rsa_privatekey_from_file(test_keypath, 'pw')
+    self.assertTrue(tuf.formats.RSAKEY_SCHEMA.matches(imported_privkey))
+
+    # Custom 'bits' argument.
+    os.remove(test_keypath)
+    os.remove(test_keypath + '.pub')
+    repo_tool.generate_and_write_rsa_keypair(test_keypath, bits=2048,
+                                             password='pw')
+    self.assertTrue(os.path.exists(test_keypath))
+    self.assertTrue(os.path.exists(test_keypath + '.pub'))
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, repo_tool.generate_and_write_rsa_keypair,
+                      3, bits=2048, password='pw')
+    self.assertRaises(tuf.FormatError, repo_tool.generate_and_write_rsa_keypair,
+                      test_keypath, bits='bad', password='pw')
+    self.assertRaises(tuf.FormatError, repo_tool.generate_and_write_rsa_keypair,
+                      test_keypath, bits=2048, password=3)
+
+
+    # Test invalid 'bits' argument.
+    self.assertRaises(tuf.FormatError, repo_tool.generate_and_write_rsa_keypair,
+                      test_keypath, bits=1024, password='pw')
 
 
 
   def test_import_rsa_privatekey_from_file(self):
-    pass
+    # Test normal case.
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory)
+    
+    # Load one of the pre-generated key files from 'tuf/tests/repository_data'.
+    # 'password' unlocks the pre-generated key files.
+    key_filepath = os.path.join(os.pardir, 'repository_data', 'keystore',
+                                'root_key')
+    self.assertTrue(os.path.exists(key_filepath))
+    
+    imported_rsa_key = repo_tool.import_rsa_privatekey_from_file(key_filepath,
+                                                                 'password')
+    self.assertTrue(tuf.formats.RSAKEY_SCHEMA.matches(imported_rsa_key))
+
+    
+    # Test improperly formatted argument.
+    self.assertRaises(tuf.FormatError,
+                      repo_tool.import_rsa_privatekey_from_file, 3, 'pw')
+
+
+    # Test invalid argument.
+    # Non-existent key file.
+    nonexistent_keypath = os.path.join(temporary_directory,
+                                       'nonexistent_keypath') 
+    self.assertRaises(IOError, repo_tool.import_rsa_privatekey_from_file,
+                      nonexistent_keypath, 'pw')
+    
+    # Invalid key file argument. 
+    invalid_keyfile = os.path.join(temporary_directory, 'invalid_keyfile') 
+    with open(invalid_keyfile, 'wb') as file_object:
+      file_object.write('bad keyfile')
+    self.assertRaises(tuf.CryptoError, repo_tool.import_rsa_privatekey_from_file,
+                      invalid_keyfile, 'pw')
 
 
 
   def test_import_rsa_publickey_from_file(self):
-    pass
+    # Test normal case.
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory)
+    
+    # Load one of the pre-generated key files from 'tuf/tests/repository_data'.
+    key_filepath = os.path.join(os.pardir, 'repository_data', 'keystore',
+                                'root_key.pub')
+    self.assertTrue(os.path.exists(key_filepath))
+    
+    imported_rsa_key = repo_tool.import_rsa_publickey_from_file(key_filepath)
+    self.assertTrue(tuf.formats.RSAKEY_SCHEMA.matches(imported_rsa_key))
+
+    
+    # Test improperly formatted argument.
+    self.assertRaises(tuf.FormatError,
+                      repo_tool.import_rsa_privatekey_from_file, 3)
+
+
+    # Test invalid argument.
+    # Non-existent key file.
+    nonexistent_keypath = os.path.join(temporary_directory,
+                                       'nonexistent_keypath')
+    self.assertRaises(IOError, repo_tool.import_rsa_publickey_from_file,
+                      nonexistent_keypath)
+    
+    # Invalid key file argument. 
+    invalid_keyfile = os.path.join(temporary_directory, 'invalid_keyfile') 
+    with open(invalid_keyfile, 'wb') as file_object:
+      file_object.write('bad keyfile')
+    self.assertRaises(tuf.Error, repo_tool.import_rsa_publickey_from_file,
+                      invalid_keyfile)
 
 
 
   def test_generate_and_write_ed25519_keypair(self):
-    pass
+    
+    # Test normal case.
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory) 
+    test_keypath = os.path.join(temporary_directory, 'ed25519_key')
+
+    repo_tool.generate_and_write_ed25519_keypair(test_keypath, password='pw')
+    self.assertTrue(os.path.exists(test_keypath))
+    self.assertTrue(os.path.exists(test_keypath + '.pub'))
+
+    # Ensure the generated key files are importable.
+    imported_pubkey = \
+      repo_tool.import_ed25519_publickey_from_file(test_keypath + '.pub')
+    self.assertTrue(tuf.formats.ED25519KEY_SCHEMA.matches(imported_pubkey))
+    
+    imported_privkey = \
+      repo_tool.import_ed25519_privatekey_from_file(test_keypath, 'pw')
+    self.assertTrue(tuf.formats.ED25519KEY_SCHEMA.matches(imported_privkey))
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError,
+                      repo_tool.generate_and_write_ed25519_keypair,
+                      3, password='pw')
+    self.assertRaises(tuf.FormatError, repo_tool.generate_and_write_rsa_keypair,
+                      test_keypath, password=3)
 
 
 
   def test_import_ed25519_publickey_from_file(self):
-    pass
+    # Test normal case.
+    # Generate ed25519 keys that can be imported.
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory)
+    ed25519_keypath = os.path.join(temporary_directory, 'ed25519_key') 
+    repo_tool.generate_and_write_ed25519_keypair(ed25519_keypath, password='pw')
+     
+    imported_ed25519_key = \
+      repo_tool.import_ed25519_publickey_from_file(ed25519_keypath + '.pub')
+    self.assertTrue(tuf.formats.ED25519KEY_SCHEMA.matches(imported_ed25519_key))
+    
+    
+    # Test improperly formatted argument.
+    self.assertRaises(tuf.FormatError,
+                      repo_tool.import_ed25519_publickey_from_file, 3)
+
+
+    # Test invalid argument.
+    # Non-existent key file.
+    nonexistent_keypath = os.path.join(temporary_directory,
+                                       'nonexistent_keypath')
+    self.assertRaises(IOError, repo_tool.import_ed25519_publickey_from_file,
+                      nonexistent_keypath)
+    
+    # Invalid key file argument. 
+    invalid_keyfile = os.path.join(temporary_directory, 'invalid_keyfile') 
+    with open(invalid_keyfile, 'wb') as file_object:
+      file_object.write('bad keyfile')
+    
+    self.assertRaises(tuf.Error, repo_tool.import_ed25519_publickey_from_file,
+                      invalid_keyfile)
 
 
 
   def test_import_ed25519_privatekey_from_file(self):
-    pass
+    # Test normal case.
+    # Generate ed25519 keys that can be imported.
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory)
+    ed25519_keypath = os.path.join(temporary_directory, 'ed25519_key') 
+    repo_tool.generate_and_write_ed25519_keypair(ed25519_keypath, password='pw')
+     
+    imported_ed25519_key = \
+      repo_tool.import_ed25519_privatekey_from_file(ed25519_keypath, 'pw')
+    self.assertTrue(tuf.formats.ED25519KEY_SCHEMA.matches(imported_ed25519_key))
+    
+    
+    # Test improperly formatted argument.
+    self.assertRaises(tuf.FormatError,
+                      repo_tool.import_ed25519_privatekey_from_file, 3, 'pw')
+
+
+    # Test invalid argument.
+    # Non-existent key file.
+    nonexistent_keypath = os.path.join(temporary_directory,
+                                       'nonexistent_keypath')
+    self.assertRaises(IOError, repo_tool.import_ed25519_privatekey_from_file,
+                      nonexistent_keypath, 'pw')
+    
+    # Invalid key file argument. 
+    invalid_keyfile = os.path.join(temporary_directory, 'invalid_keyfile') 
+    with open(invalid_keyfile, 'wb') as file_object:
+      file_object.write('bad keyfile')
+    
+    self.assertRaises(tuf.Error, repo_tool.import_ed25519_privatekey_from_file,
+                      invalid_keyfile, 'pw')
 
 
 
   def test_get_metadata_filenames(self):
-    pass
+   
+    # Test normal case.
+    metadata_directory = os.path.join('metadata/')
+    filenames = {'root.json': metadata_directory + 'root.json',
+                 'targets.json': metadata_directory + 'targets.json',
+                 'snapshot.json': metadata_directory + 'snapshot.json',
+                 'timestamp.json': metadata_directory + 'timestamp.json'}
+    
+    self.assertEqual(filenames, repo_tool.get_metadata_filenames('metadata/'))
+
+    # If a directory argument is not specified, the current working directory
+    # is used.
+    metadata_directory = os.getcwd()
+    filenames = {'root.json': os.path.join(metadata_directory, 'root.json'),
+                 'targets.json': os.path.join(metadata_directory, 'targets.json'),
+                 'snapshot.json': os.path.join(metadata_directory, 'snapshot.json'),
+                 'timestamp.json': os.path.join(metadata_directory,  'timestamp.json')}
+    self.assertEqual(filenames, repo_tool.get_metadata_filenames())
+
+
+    # Test improperly formatted argument.
+    self.assertRaises(tuf.FormatError, repo_tool.get_metadata_filenames, 3)
 
 
 
-  def test_get_metadata_file_info(self):
-    pass
+  def test_get_metadata_fileinfo(self):
+    # Test normal case. 
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory)
+    test_filepath = os.path.join(temporary_directory, 'file.txt')
+    
+    with open(test_filepath, 'wb') as file_object:
+      file_object.write('test file')
+  
+    # Generate test fileinfo object.  It is assumed SHA256 hashes are computed
+    # by get_metadata_fileinfo().
+    file_length = os.path.getsize(test_filepath)
+    digest_object = tuf.hash.digest_filename(test_filepath)
+    file_hashes = {'sha256': digest_object.hexdigest()}
+    fileinfo = {'length': file_length, 'hashes': file_hashes}
+    self.assertTrue(tuf.formats.FILEINFO_SCHEMA.matches(fileinfo))
+    
+    self.assertEqual(fileinfo, repo_tool.get_metadata_fileinfo(test_filepath))
+
+
+    # Test improperly formatted argument.
+    self.assertRaises(tuf.FormatError, repo_tool.get_metadata_fileinfo, 3)
+
+
+    # Test non-existent file.
+    nonexistent_filepath = os.path.join(temporary_directory, 'oops.txt')
+    self.assertRaises(tuf.Error, repo_tool.get_metadata_fileinfo,
+                      nonexistent_filepath)
 
 
 
diff --git a/tests/unit/test_updater.py b/tests/unit/test_updater.py
index 95476a34..d8e1a5b4 100755
--- a/tests/unit/test_updater.py
+++ b/tests/unit/test_updater.py
@@ -5,7 +5,7 @@
   test_updater.py
 
 <Author>
-  Konstantin Andrianov
+  Konstantin Andrianov.
 
 <Started>
   October 15, 2012.
diff --git a/tuf/pycrypto_keys.py b/tuf/pycrypto_keys.py
index a5b59f03..def95632 100755
--- a/tuf/pycrypto_keys.py
+++ b/tuf/pycrypto_keys.py
@@ -894,9 +894,15 @@ def _decrypt(file_contents, password):
   # from 'file_contents'.  These five values are delimited by
   # '_ENCRYPTION_DELIMITER'.  This delimiter is arbitrarily chosen and should
   # not occur in the hexadecimal representations of the fields it is separating.
-  salt, iterations, hmac, iv, ciphertext = \
-    file_contents.split(_ENCRYPTION_DELIMITER)
+  # Raise 'tuf.CryptoError', if 'file_contents' does not contains the expected
+  # data layout.
+  try: 
+    salt, iterations, hmac, iv, ciphertext = \
+      file_contents.split(_ENCRYPTION_DELIMITER)
   
+  except ValueError:
+    raise tuf.CryptoError('Invalid encrypted file.') 
+
   # Ensure we have the expected raw data for the delimited cryptographic data. 
   salt = binascii.unhexlify(salt)
   iterations = int(binascii.unhexlify(iterations))
diff --git a/tuf/repository_tool.py b/tuf/repository_tool.py
index 32408475..0db27b22 100755
--- a/tuf/repository_tool.py
+++ b/tuf/repository_tool.py
@@ -3380,6 +3380,8 @@ def import_rsa_privatekey_from_file(filepath, password=None):
   <Exceptions>
     tuf.FormatError, if the arguments are improperly formatted.
 
+    tuf.CryptoError, if 'filepath' is not a valid encrypted key file.
+
   <Side Effects>
     The contents of 'filepath' is read, decrypted, and the key stored.
 
@@ -3409,7 +3411,8 @@ def import_rsa_privatekey_from_file(filepath, password=None):
   with open(filepath, 'rb') as file_object:
     encrypted_pem = file_object.read()
 
-  # Convert 'encrypted_pem' to 'tuf.formats.RSAKEY_SCHEMA' format.
+  # Convert 'encrypted_pem' to 'tuf.formats.RSAKEY_SCHEMA' format.  Raise
+  # 'tuf.CryptoError' if 'encrypted_pem' is invalid.
   rsa_key = tuf.keys.import_rsakey_from_encrypted_pem(encrypted_pem, password)
   
   return rsa_key
@@ -3692,13 +3695,13 @@ def get_metadata_filenames(metadata_directory=None):
     If 'metadata_directory' is set to 'metadata', the dictionary
     returned would contain:
 
-    filenames = {'root': 'metadata/root.json',
-                 'targets': 'metadata/targets.json',
-                 'snapshot': 'metadata/snapshot.json',
-                 'timestamp': 'metadata/timestamp.json'}
+    filenames = {'root.json': 'metadata/root.json',
+                 'targets.json': 'metadata/targets.json',
+                 'snapshot.json': 'metadata/snapshot.json',
+                 'timestamp.json': 'metadata/timestamp.json'}
 
-    If the metadata directory is not set by the caller, the current
-    directory is used.
+    If 'metadata_directory' is not set by the caller, the current directory is
+    used.
 
   <Arguments>
     metadata_directory:
@@ -3715,19 +3718,15 @@ def get_metadata_filenames(metadata_directory=None):
     metadata files, such as 'root.json' and 'snapshot.json'.
   """
   
+  if metadata_directory is None:
+    metadata_directory = os.getcwd()
+  
   # Does 'metadata_directory' have the correct format?
   # Ensure the arguments have the appropriate number of objects and object
   # types, and that all dict keys are properly named.
   # Raise 'tuf.FormatError' if there is a mismatch.
   tuf.formats.PATH_SCHEMA.check_match(metadata_directory)
 
-  if metadata_directory is None:
-    metadata_directory = '.'
-
-  # Does 'metadata_directory' have the correct format?
-  # Raise 'tuf.FormatError' if there is a mismatch. 
-  tuf.formats.PATH_SCHEMA.check_match(metadata_directory)
-
   # Store the filepaths of the top-level roles, including the
   # 'metadata_directory' for each one.
   filenames = {}
@@ -3750,13 +3749,14 @@ def get_metadata_filenames(metadata_directory=None):
 
 
 
-def get_metadata_file_info(filename):
+def get_metadata_fileinfo(filename):
   """
   <Purpose>
     Retrieve the file information of 'filename'.  The object returned
     conforms to 'tuf.formats.FILEINFO_SCHEMA'.  The information
     generated for 'filename' is stored in metadata files like 'targets.json'.
     The fileinfo object returned has the form:
+    
     fileinfo = {'length': 1024,
                 'hashes': {'sha256': 1233dfba312, ...},
                 'custom': {...}}
@@ -3777,7 +3777,7 @@ def get_metadata_file_info(filename):
   <Returns>
     A dictionary conformant to 'tuf.formats.FILEINFO_SCHEMA'.  This
     dictionary contains the length, hashes, and custom data about the
-    'filename' metadata file.
+    'filename' metadata file.  SHA256 hashes are generated by default.
   """
 
   # Does 'filename' have the correct format?
@@ -4034,7 +4034,7 @@ def generate_targets_metadata(targets_directory, target_files, version,
         'targets metadata.'
       raise tuf.Error(message)
     
-    filedict[relative_targetpath] = get_metadata_file_info(target_path)
+    filedict[relative_targetpath] = get_metadata_fileinfo(target_path)
     
     if write_consistent_targets:
       for target_digest in filedict[relative_targetpath]['hashes'].values():
@@ -4123,8 +4123,8 @@ def generate_snapshot_metadata(metadata_directory, version, expiration_date,
   # Retrieve the fileinfo of 'root.json' and 'targets.json'.  This file
   # information includes data such as file length, hashes of the file, etc.
   filedict = {}
-  filedict[ROOT_FILENAME] = get_metadata_file_info(root_filename)
-  filedict[TARGETS_FILENAME] = get_metadata_file_info(targets_filename)
+  filedict[ROOT_FILENAME] = get_metadata_fileinfo(root_filename)
+  filedict[TARGETS_FILENAME] = get_metadata_fileinfo(targets_filename)
 
   # Add compressed versions of the 'targets.json' and 'root.json' metadata,
   # if they exist.
@@ -4136,10 +4136,10 @@ def generate_snapshot_metadata(metadata_directory, version, expiration_date,
     # add their file attributes to 'filedict'.
     if os.path.exists(compressed_root_filename):
       filedict[ROOT_FILENAME+extension] = \
-        get_metadata_file_info(compressed_root_filename)
+        get_metadata_fileinfo(compressed_root_filename)
     if os.path.exists(compressed_targets_filename): 
       filedict[TARGETS_FILENAME+extension] = \
-        get_metadata_file_info(compressed_targets_filename)
+        get_metadata_fileinfo(compressed_targets_filename)
 
   # Walk the 'targets/' directory and generate the fileinfo of all the role
   # files found.  This information is stored in the 'meta' field of the snapshot
@@ -4169,7 +4169,7 @@ def generate_snapshot_metadata(metadata_directory, version, expiration_date,
             # Obsolete role files may still be found.  Ensure only roles loaded
             # in the roledb are included in the snapshot metadata.
             if tuf.roledb.role_exists(rolename):
-              filedict[metadata_name] = get_metadata_file_info(metadata_path)
+              filedict[metadata_name] = get_metadata_fileinfo(metadata_path)
 
   # Generate the snapshot metadata object.
   snapshot_metadata = tuf.formats.SnapshotFile.make_metadata(version,
@@ -4232,7 +4232,7 @@ def generate_timestamp_metadata(snapshot_filename, version,
   # Retrieve the fileinfo of the snapshot metadata file.
   # This file information contains hashes, file length, custom data, etc.
   fileinfo = {}
-  fileinfo[SNAPSHOT_FILENAME] = get_metadata_file_info(snapshot_filename)
+  fileinfo[SNAPSHOT_FILENAME] = get_metadata_fileinfo(snapshot_filename)
 
   # Save the fileinfo of the compressed versions of 'timestamp.json'
   # in 'fileinfo'.  Log the files included in 'fileinfo'.
@@ -4242,7 +4242,7 @@ def generate_timestamp_metadata(snapshot_filename, version,
 
     compressed_filename = snapshot_filename + '.' + file_extension
     try:
-      compressed_fileinfo = get_metadata_file_info(compressed_filename)
+      compressed_fileinfo = get_metadata_fileinfo(compressed_filename)
     
     except:
       logger.warn('Cannot get fileinfo about '+str(compressed_filename))
diff --git a/tuf/util.py b/tuf/util.py
index a825175f..7c93668d 100755
--- a/tuf/util.py
+++ b/tuf/util.py
@@ -879,6 +879,8 @@ def load_json_file(filepath):
   <Exceptions>
     tuf.FormatError: If 'filepath' is improperly formatted.
 
+    tuf.Error: If 'filepath' cannot be deserialized to a Python object.
+
     IOError in case of runtime IO exceptions.
 
   <Side Effects>
@@ -892,6 +894,8 @@ def load_json_file(filepath):
   # tuf.FormatError is raised on incorrect format.
   tuf.formats.PATH_SCHEMA.check_match(filepath)
 
+  deserialized_object = None
+
   # The file is mostly likely gzipped.
   if filepath.endswith('.gz'):
     logger.debug('gzip.open('+str(filepath)+')')
@@ -902,7 +906,14 @@ def load_json_file(filepath):
     fileobject = open(filepath)
 
   try:
-    return json.load(fileobject)
+    deserialized_object = json.load(fileobject)
+  
+  except ValueError, TypeError:
+    message = 'Cannot deserialize to a Python object: '+repr(filepath)
+    raise tuf.Error(message)
+  
+  else:
+    return deserialized_object
   
   finally:
     fileobject.close()

From 4ad679062fae90e5572c5fc8aa0c7e0128b6d4cf Mon Sep 17 00:00:00 2001
From: Vladimir Diaz <vladimir.v.diaz@gmail.com>
Date: Tue, 8 Apr 2014 12:31:06 -0400
Subject: [PATCH 03/10] Continue updating test_repository_tool.py.

Add test cases for the generate_*_metadata() functions.
---
 tests/unit/test_repository_tool.py | 224 ++++++++++++++++++++++++++++-
 tuf/repository_tool.py             |  10 +-
 2 files changed, 226 insertions(+), 8 deletions(-)

diff --git a/tests/unit/test_repository_tool.py b/tests/unit/test_repository_tool.py
index 4cd58723..1297c566 100755
--- a/tests/unit/test_repository_tool.py
+++ b/tests/unit/test_repository_tool.py
@@ -31,6 +31,7 @@
 
 logger = logging.getLogger('tuf.test_repository_tool')
 
+repo_tool.disable_console_log_messages()
 
 
 class TestRepository(unittest.TestCase):
@@ -231,7 +232,44 @@ def tearDown(self):
 
 
   def test_create_new_repository(self):
-    pass
+    # Test normal case.
+    # Setup the temporary repository directories needed by
+    # create_new_repository().
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory) 
+    repository_directory = os.path.join(temporary_directory, 'repository')
+    metadata_directory = os.path.join(repository_directory,
+                                      repo_tool.METADATA_STAGED_DIRECTORY_NAME)
+    targets_directory = os.path.join(repository_directory,
+                                     repo_tool.TARGETS_DIRECTORY_NAME)
+    
+    repository = repo_tool.create_new_repository(repository_directory)
+    self.assertTrue(isinstance(repository, repo_tool.Repository))
+    
+    # Verify that the 'repository/', 'repository/metadata', and
+    # 'repository/targets' directories were created.
+    self.assertTrue(os.path.exists(repository_directory))
+    self.assertTrue(os.path.exists(metadata_directory))
+    self.assertTrue(os.path.exists(targets_directory))
+
+
+    # Test that the 'repository' directory is created (along with the other
+    # sub-directories) when it does not exist yet.  The repository tool creates
+    # the non-existent directory.
+    shutil.rmtree(repository_directory)
+
+    repository = repo_tool.create_new_repository(repository_directory)
+    repository = repo_tool.create_new_repository(repository_directory)
+    self.assertTrue(isinstance(repository, repo_tool.Repository))
+    
+    # Verify that the 'repository/', 'repository/metadata', and
+    # 'repository/targets' directories were created.
+    self.assertTrue(os.path.exists(repository_directory))
+    self.assertTrue(os.path.exists(metadata_directory))
+    self.assertTrue(os.path.exists(targets_directory))
+     
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, repo_tool.create_new_repository, 3)
 
 
 
@@ -524,22 +562,198 @@ def test_get_target_hash(self):
 
 
   def test_generate_root_metadata(self):
-    pass
+    # Test normal case.
+    # Load the root metadata provided in 'tuf/tests/repository_data/'.
+    root_filepath = os.path.join(os.pardir, 'repository_data', 'repository',
+                                 'metadata', 'root.json')
+    root_signable = tuf.util.load_json_file(root_filepath)
+
+    # generate_root_metadata() expects the top-level roles and keys to be
+    # available in 'tuf.keydb' and 'tuf.roledb'.
+    tuf.roledb.create_roledb_from_root_metadata(root_signable['signed'])
+    tuf.keydb.create_keydb_from_root_metadata(root_signable['signed'])
+
+    root_metadata = repo_tool.generate_root_metadata(1, '2088-01-01 12:00:00 UTC',
+                                                     consistent_snapshot=False)
+    self.assertTrue(tuf.formats.ROOT_SCHEMA.matches(root_metadata))
+
+    
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, repo_tool.generate_root_metadata,  
+                      '3', '2088-01-01 12:00:00 UTC', False) 
+    self.assertRaises(tuf.FormatError, repo_tool.generate_root_metadata,  
+                      1, 3, False) 
+    self.assertRaises(tuf.FormatError, repo_tool.generate_root_metadata,  
+                      1, '2088-01-01 12:00:00 UTC', 3) 
+
+    # Test for missing required roles and keys.
+    tuf.roledb.clear_roledb()
+    tuf.keydb.clear_keydb()
+    self.assertRaises(tuf.Error, repo_tool.generate_root_metadata,
+                      1, '2088-01-01 12:00:00 UTC', False)
 
 
 
   def test_generate_targets_metadata(self):
-    pass
+    # Test normal case. 
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory)
+    targets_directory = os.path.join(temporary_directory, 'targets')
+    file1_path = os.path.join(targets_directory, 'file.txt')
+    tuf.util.ensure_parent_dir(file1_path)
+
+    with open(file1_path, 'wb') as file_object:
+      file_object.write('test file.')
+   
+    # Set valid generate_targets_metadata() arguments.
+    version = 1
+    expiration_date = '2088-01-01 12:00:00 UTC'
+    target_files = ['file.txt']
+    delegations = {"keys": {
+      "a394c28384648328b16731f81440d72243c77bb44c07c040be99347f0df7d7bf": {
+       "keytype": "ed25519", 
+       "keyval": {
+        "public": "3eb81026ded5af2c61fb3d4b272ac53cd1049a810ee88f4df1fc35cdaf918157"
+       }
+      }
+     }, 
+     "roles": [
+      {
+       "keyids": [
+        "a394c28384648328b16731f81440d72243c77bb44c07c040be99347f0df7d7bf"
+       ], 
+       "name": "targets/warehouse", 
+       "paths": [
+        "/file1.txt", "/README.txt", '/warehouse/'
+       ], 
+       "threshold": 1
+      }
+     ]
+    }
+  
+    targets_metadata = \
+      repo_tool.generate_targets_metadata(targets_directory, target_files,
+                                          version, expiration_date, delegations,
+                                          False)
+    self.assertTrue(tuf.formats.TARGETS_SCHEMA.matches(targets_metadata))
+
+    # Verify that 'digest.filename' file is saved to 'targets_directory' if
+    # the 'write_consistent_targets' argument is True.
+    list_targets_directory = os.listdir(targets_directory)
+    targets_metadata = \
+      repo_tool.generate_targets_metadata(targets_directory, target_files,
+                                          version, expiration_date, delegations,
+                                          write_consistent_targets=True)
+    new_list_targets_directory = os.listdir(targets_directory)
+    
+    # Verify that 'targets_directory' contains only one extra item.
+    self.assertTrue(len(list_targets_directory) + 1,
+                    len(new_list_targets_directory))
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, repo_tool.generate_targets_metadata,
+                      3, target_files, version, expiration_date)  
+    self.assertRaises(tuf.FormatError, repo_tool.generate_targets_metadata,
+                      targets_directory, 3, version, expiration_date)  
+    self.assertRaises(tuf.FormatError, repo_tool.generate_targets_metadata,
+                      targets_directory, target_files, '3', expiration_date)  
+    self.assertRaises(tuf.FormatError, repo_tool.generate_targets_metadata,
+                      targets_directory, target_files, version, 3)  
+    
+    # Improperly formatted 'delegations' and 'write_consistent_targets' 
+    self.assertRaises(tuf.FormatError, repo_tool.generate_targets_metadata,
+                      targets_directory, target_files, version, expiration_date,
+                      3, False)  
+    self.assertRaises(tuf.FormatError, repo_tool.generate_targets_metadata,
+                      targets_directory, target_files, version, expiration_date,
+                      delegations, 3)  
+
+
+    # Test invalid 'target_files' argument.
+    self.assertRaises(tuf.Error, repo_tool.generate_targets_metadata,
+                      targets_directory, ['nonexistent_file.txt'], version,
+                      expiration_date)  
+
 
 
 
   def test_generate_snapshot_metadata(self):
-    pass
+    # Test normal case.
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory)
+    original_repository_path = os.path.join(os.pardir, 'repository_data',
+                                            'repository')
+    repository_directory = os.path.join(temporary_directory, 'repository') 
+    shutil.copytree(original_repository_path, repository_directory)
+    metadata_directory = os.path.join(repository_directory,
+                                      repo_tool.METADATA_STAGED_DIRECTORY_NAME)
+    root_filename = os.path.join(metadata_directory, repo_tool.ROOT_FILENAME)
+    targets_filename = os.path.join(metadata_directory,
+                                    repo_tool.TARGETS_FILENAME)
+    version = 1
+    expiration_date = '2088-01-01 12:00:00 UTC'
+    
+    snapshot_metadata = \
+      repo_tool.generate_snapshot_metadata(metadata_directory, version,
+                                           expiration_date, root_filename,
+                                           targets_filename,
+                                           consistent_snapshot=False)
+    self.assertTrue(tuf.formats.SNAPSHOT_SCHEMA.matches(snapshot_metadata))
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, repo_tool.generate_snapshot_metadata,
+                      3, version, expiration_date,
+                      root_filename, targets_filename, consistent_snapshot=False)
+    self.assertRaises(tuf.FormatError, repo_tool.generate_snapshot_metadata,
+                      metadata_directory, '3', expiration_date,
+                      root_filename, targets_filename, consistent_snapshot=False)
+    self.assertRaises(tuf.FormatError, repo_tool.generate_snapshot_metadata,
+                      metadata_directory, version, 3,
+                      root_filename, targets_filename, consistent_snapshot=False)
+    self.assertRaises(tuf.FormatError, repo_tool.generate_snapshot_metadata,
+                      metadata_directory, version, expiration_date,
+                      3, targets_filename, consistent_snapshot=False)
+    self.assertRaises(tuf.FormatError, repo_tool.generate_snapshot_metadata,
+                      metadata_directory, version, expiration_date,
+                      root_filename, 3, consistent_snapshot=False)
+    self.assertRaises(tuf.FormatError, repo_tool.generate_snapshot_metadata,
+                      metadata_directory, version, expiration_date,
+                      root_filename, targets_filename, 3)
 
 
 
   def test_generate_timestamp_metadata(self):
-    pass
+    # Test normal case.
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory)
+    original_repository_path = os.path.join(os.pardir, 'repository_data',
+                                            'repository')
+    repository_directory = os.path.join(temporary_directory, 'repository') 
+    shutil.copytree(original_repository_path, repository_directory)
+    metadata_directory = os.path.join(repository_directory,
+                                      repo_tool.METADATA_STAGED_DIRECTORY_NAME)
+    snapshot_filename = os.path.join(metadata_directory,
+                                     repo_tool.SNAPSHOT_FILENAME)
+   
+    # Set valid generate_timestamp_metadata() arguments.
+    version = 1
+    expiration_date = '2088-01-01 12:00:00 UTC'
+    compressions = ['gz']
+
+    snapshot_metadata = \
+      repo_tool.generate_timestamp_metadata(snapshot_filename, version,
+                                            expiration_date, compressions)
+    self.assertTrue(tuf.formats.TIMESTAMP_SCHEMA.matches(snapshot_metadata))
+    
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, repo_tool.generate_timestamp_metadata,
+                      3, version, expiration_date, compressions)
+    self.assertRaises(tuf.FormatError, repo_tool.generate_timestamp_metadata,
+                      snapshot_filename, '3', expiration_date, compressions)
+    self.assertRaises(tuf.FormatError, repo_tool.generate_timestamp_metadata,
+                      snapshot_filename, version, 3, compressions)
+    self.assertRaises(tuf.FormatError, repo_tool.generate_timestamp_metadata,
+                      snapshot_filename, version, expiration_date, 3)
 
 
 
diff --git a/tuf/repository_tool.py b/tuf/repository_tool.py
index 0db27b22..a6ca0fda 100755
--- a/tuf/repository_tool.py
+++ b/tuf/repository_tool.py
@@ -3856,13 +3856,16 @@ def generate_root_metadata(version, expiration_date, consistent_snapshot):
       'tuf.formats.TIME_SCHEMA'.
 
     consistent_snapshot:
+      Boolean.  If True, a file digest is expected to be prepended to the
+      filename of any target file located in the targets directory.  Each digest
+      is stripped from the target filename and listed in the snapshot metadata. 
 
   <Exceptions>
     tuf.FormatError, if the generated root metadata object could not
     be generated with the correct format.
 
     tuf.Error, if an error is encountered while generating the root
-    metadata object.
+    metadata object (e.g., a required top-level role not found in 'tuf.roledb'.)
   
   <Side Effects>
     The contents of 'tuf.keydb.py' and 'tuf.roledb.py' are read.
@@ -4060,7 +4063,7 @@ def generate_targets_metadata(targets_directory, target_files, version,
 
 def generate_snapshot_metadata(metadata_directory, version, expiration_date,
                                root_filename, targets_filename,
-                               consistent_snapshot):
+                               consistent_snapshot=False):
   """
   <Purpose>
     Create the snapshot metadata.  The minimum metadata must exist
@@ -4096,7 +4099,7 @@ def generate_snapshot_metadata(metadata_directory, version, expiration_date,
       is stripped from the target filename and listed in the snapshot metadata. 
 
   <Exceptions>
-    tuf.FormatError, if 'metadata_directory' is improperly formatted.
+    tuf.FormatError, if the arguments are improperly formatted.
 
     tuf.Error, if an error occurred trying to generate the snapshot metadata
     object.
@@ -4117,6 +4120,7 @@ def generate_snapshot_metadata(metadata_directory, version, expiration_date,
   tuf.formats.TIME_SCHEMA.check_match(expiration_date)
   tuf.formats.PATH_SCHEMA.check_match(root_filename)
   tuf.formats.PATH_SCHEMA.check_match(targets_filename)
+  tuf.formats.BOOLEAN_SCHEMA.check_match(consistent_snapshot)
 
   metadata_directory = _check_directory(metadata_directory)
 

From af8d2fb98e2a072cdd4be42afbe60c6d76e76b0f Mon Sep 17 00:00:00 2001
From: Vladimir Diaz <vladimir.v.diaz@gmail.com>
Date: Tue, 8 Apr 2014 14:56:39 -0400
Subject: [PATCH 04/10] Finish remaining test cases for repository_tool.py
 functions.

---
 tests/unit/test_repository_tool.py | 140 ++++++++++++++++++++++++++++-
 tuf/repository_tool.py             |  14 +--
 2 files changed, 144 insertions(+), 10 deletions(-)

diff --git a/tests/unit/test_repository_tool.py b/tests/unit/test_repository_tool.py
index 1297c566..c2813dd6 100755
--- a/tests/unit/test_repository_tool.py
+++ b/tests/unit/test_repository_tool.py
@@ -274,7 +274,47 @@ def test_create_new_repository(self):
 
 
   def test_load_repository(self):
-    pass
+    # Test normal case.
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory) 
+    original_repository_directory = os.path.join(os.pardir, 'repository_data',
+                                                 'repository')
+    repository_directory = os.path.join(temporary_directory, 'repository')
+    shutil.copytree(original_repository_directory, repository_directory)
+     
+    repository = repo_tool.load_repository(repository_directory)
+    self.assertTrue(isinstance(repository, repo_tool.Repository))
+
+    # Verify the expected roles have been loaded.  See
+    # 'tuf/tests/repository_data/repository/'.
+    expected_roles = \
+      ['root', 'targets', 'snapshot', 'timestamp', 'targets/role1']
+    for role in tuf.roledb.get_rolenames():
+      self.assertTrue(role in expected_roles)
+    
+    self.assertTrue(len(repository.root.keys))
+    self.assertTrue(len(repository.targets.keys))
+    self.assertTrue(len(repository.snapshot.keys))
+    self.assertTrue(len(repository.timestamp.keys))
+    self.assertTrue(len(repository.targets('role1').keys))
+
+    # Assumed the targets (tuf/tests/repository_data/) role contains 'file1.txt'
+    # and 'file2.txt'.
+    self.assertTrue('/file1.txt' in repository.targets.target_files)
+    self.assertTrue('/file2.txt' in repository.targets.target_files)
+    self.assertTrue('/file3.txt' in repository.targets('role1').target_files)
+    
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, repo_tool.load_repository, 3)
+
+
+    # Test for invalid 'repository_directory' (i.e., does not contain the
+    # minimum required metadata.
+    root_filepath = \
+      os.path.join(repository_directory,
+                   repo_tool.METADATA_STAGED_DIRECTORY_NAME, 'root.json') 
+    os.remove(root_filepath)
+    self.assertRaises(tuf.RepositoryError, repo_tool.load_repository,
+                      repository_directory)
 
 
 
@@ -608,6 +648,7 @@ def test_generate_targets_metadata(self):
     version = 1
     expiration_date = '2088-01-01 12:00:00 UTC'
     target_files = ['file.txt']
+    
     delegations = {"keys": {
       "a394c28384648328b16731f81440d72243c77bb44c07c040be99347f0df7d7bf": {
        "keytype": "ed25519", 
@@ -754,21 +795,112 @@ def test_generate_timestamp_metadata(self):
                       snapshot_filename, version, 3, compressions)
     self.assertRaises(tuf.FormatError, repo_tool.generate_timestamp_metadata,
                       snapshot_filename, version, expiration_date, 3)
+    self.assertRaises(tuf.FormatError, repo_tool.generate_timestamp_metadata,
+                      snapshot_filename, version, expiration_date, ['compress'])
+
 
 
 
   def test_sign_metadata(self):
-    pass
+    # Test normal case.
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory)
+    metadata_path = os.path.join(os.pardir, 'repository_data',
+                                 'repository', 'metadata')
+    keystore_path = os.path.join(os.pardir, 'repository_data',
+                                 'keystore')
+    root_filename = os.path.join(metadata_path, 'root.json')
+    root_metadata = tuf.util.load_json_file(root_filename)['signed']
+    
+    tuf.keydb.create_keydb_from_root_metadata(root_metadata)
+    tuf.roledb.create_roledb_from_root_metadata(root_metadata)
+    root_keyids = tuf.roledb.get_role_keyids('root')
+
+    root_private_keypath = os.path.join(keystore_path, 'root_key')
+    root_private_key = \
+      repo_tool.import_rsa_privatekey_from_file(root_private_keypath,
+                                                'password')
+    
+    # sign_metadata() expects the private key 'root_metadata' to be in
+    # 'tuf.keydb'.  Remove any public keys that may be loaded before
+    # adding private key, otherwise a 'tuf.KeyAlreadyExists' exception is
+    # raised.
+    tuf.keydb.remove_key(root_private_key['keyid'])
+    tuf.keydb.add_key(root_private_key)
+
+    root_signable = repo_tool.sign_metadata(root_metadata, root_keyids,
+                                            root_filename) 
+    self.assertTrue(tuf.formats.SIGNABLE_SCHEMA.matches(root_signable))
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, repo_tool.sign_metadata, 3, root_keyids,
+                      'root.json')
+    self.assertRaises(tuf.FormatError, repo_tool.sign_metadata, root_metadata,
+                      3, 'root.json')
+    self.assertRaises(tuf.FormatError, repo_tool.sign_metadata, root_metadata,
+                      root_keyids, 3)
 
 
 
   def test_write_metadata_file(self):
-    pass
+    # Test normal case.
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory)
+    metadata_directory = os.path.join(os.pardir, 'repository_data',
+                                      'repository', 'metadata')
+    root_filename = os.path.join(metadata_directory, 'root.json')
+    root_signable = tuf.util.load_json_file(root_filename)
+  
+    output_filename = os.path.join(temporary_directory, 'root.json')
+    compressions = ['gz']
+  
+    self.assertFalse(os.path.exists(output_filename))
+    repo_tool.write_metadata_file(root_signable, output_filename, compressions,
+                                  consistent_snapshot=False)
+    self.assertTrue(os.path.exists(output_filename))
+    self.assertTrue(os.path.exists(output_filename + '.gz'))
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, repo_tool.write_metadata_file,
+                      3, output_filename, compressions, False)
+    self.assertRaises(tuf.FormatError, repo_tool.write_metadata_file,
+                      root_signable, 3, compressions, False)
+    self.assertRaises(tuf.FormatError, repo_tool.write_metadata_file,
+                      root_signable, output_filename, 3, False)
+    self.assertRaises(tuf.FormatError, repo_tool.write_metadata_file,
+                      root_signable, output_filename, compressions, 3)
 
 
 
   def test_create_tuf_client_directory(self):
-    pass
+    # Test normal case.
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory)
+    repository_directory = os.path.join(os.pardir, 'repository_data',
+                                        'repository')
+    client_directory = os.path.join(temporary_directory, 'client')
+
+    repo_tool.create_tuf_client_directory(repository_directory, client_directory)
+
+    self.assertTrue(os.path.exists(client_directory))
+    metadata_directory = os.path.join(client_directory, 'metadata')
+    current_directory = os.path.join(metadata_directory, 'current')
+    previous_directory = os.path.join(metadata_directory, 'previous')
+    self.assertTrue(os.path.exists(client_directory))
+    self.assertTrue(os.path.exists(metadata_directory))
+    self.assertTrue(os.path.exists(current_directory))
+    self.assertTrue(os.path.exists(previous_directory))
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, repo_tool.create_tuf_client_directory,
+                      3, client_directory)
+    self.assertRaises(tuf.FormatError, repo_tool.create_tuf_client_directory,
+                      repository_directory, 3)
+
+
+    # Test invalid argument (i.e., client directory already exists.)
+    self.assertRaises(tuf.RepositoryError, repo_tool.create_tuf_client_directory,
+                      repository_directory, client_directory)
 
 
 # Run the test cases.
diff --git a/tuf/repository_tool.py b/tuf/repository_tool.py
index a6ca0fda..4d47fea8 100755
--- a/tuf/repository_tool.py
+++ b/tuf/repository_tool.py
@@ -878,7 +878,7 @@ def keys(self):
     <Purpose>
       A getter method that returns the role's keyids of the keys.  The role
       is expected to eventually contain a threshold of signatures generated
-      by the private keys of each of the role's keys (returned here as a keyid).
+      by the private keys of each of the role's keys (returned here as a keyid.)
 
     <Arguments>
       None.
@@ -2957,9 +2957,11 @@ def load_repository(repository_directory):
 
   <Exceptions>
     tuf.FormatError, if 'repository_directory' or any of the metadata files
-    are improperly formatted.  Also raised if, at a minimum, the Root role
-    cannot be found.
+    are improperly formatted.
 
+    tuf.RepositoryError, if the Root role cannot be found.  At a minimum,
+    a repository must contain 'root.json'
+  
   <Side Effects>
    All the metadata files found in the repository are loaded and their contents
    stored in a repository_tool.Repository object.
@@ -4249,11 +4251,11 @@ def generate_timestamp_metadata(snapshot_filename, version,
       compressed_fileinfo = get_metadata_fileinfo(compressed_filename)
     
     except:
-      logger.warn('Cannot get fileinfo about '+str(compressed_filename))
+      logger.warn('Cannot get fileinfo about '+repr(compressed_filename))
     
     else:
-      logger.info('Including fileinfo about '+str(compressed_filename))
-      fileinfo[SNAPSHOT_FILENAME+'.'+file_extension] = compressed_fileinfo
+      logger.info('Including fileinfo about '+repr(compressed_filename))
+      fileinfo[SNAPSHOT_FILENAME + '.' + file_extension] = compressed_fileinfo
 
   # Generate the timestamp metadata object.
   timestamp_metadata = tuf.formats.TimestampFile.make_metadata(version,

From 81c274885902847ff60eadf62843636c9078c1f9 Mon Sep 17 00:00:00 2001
From: Vladimir Diaz <vladimir.v.diaz@gmail.com>
Date: Tue, 8 Apr 2014 15:19:40 -0400
Subject: [PATCH 05/10] Add test cases (skeleton) for remaining methods of
 test_repository_tool.py.

---
 tests/unit/test_repository_tool.py | 142 ++++++++++++++++++++++++++++-
 1 file changed, 141 insertions(+), 1 deletion(-)

diff --git a/tests/unit/test_repository_tool.py b/tests/unit/test_repository_tool.py
index c2813dd6..9a9edaab 100755
--- a/tests/unit/test_repository_tool.py
+++ b/tests/unit/test_repository_tool.py
@@ -64,6 +64,23 @@ def test_init(self):
     self.assertRaises(tuf.FormatError, repo_tool.Repository,
                       'repository_directory', 'metadata_directory', 3)
 
+  
+
+  def test_write(self):
+    pass
+
+
+
+  def test_write_partial(self):
+    pass
+
+
+
+  def test_get_filepaths_in_directory(self):
+    pass
+
+
+
 
 
 class TestMetadata(unittest.TestCase):
@@ -75,6 +92,72 @@ def setUp(self):
   def tearDown(self):
     pass
 
+  
+
+  def test_rolename(self):
+    pass
+  
+
+
+  def test_version(self):
+    pass
+
+
+
+  def test_threshold(self):
+    pass
+
+
+
+  def test_expiration(self):
+    pass
+
+
+
+  def test_keys(self):
+    pass
+
+
+
+  def test_signing_keys(self):
+    pass
+
+
+
+  def test_compressions(self):
+    pass
+
+
+
+  def test_add_verification_keys(self):
+    pass
+
+
+
+  def test_remove_verification_keys(self):
+    pass
+
+
+
+  def test_load_signing_key(self):
+    pass
+
+
+
+  def test_unload_signing_key(self):
+    pass
+
+
+
+  def test_add_signature(self):
+    pass
+
+
+
+
+  def test_remove_signature(self):
+    pass
+
 
 
 
@@ -197,6 +280,63 @@ def test_init(self):
 
 
 
+  def test_get_delegated_rolenames(self):
+    pass
+
+
+
+  def test_target_files(self):
+    pass
+
+
+
+  def test_delegations(self):
+    pass
+
+
+
+  def test_add_target(self):
+    pass
+
+
+
+  def test_add_targets(self):
+    pass
+
+
+
+  def test_remove_target(self):
+    pass
+
+
+
+  def test_clear_targets(self):
+    pass
+
+
+
+  def test_delegate(self):
+    pass
+
+
+
+  def test_delegate_hashed_bins(self):
+    pass
+
+
+
+  def test_add_restricted_paths(self):
+    pass
+
+
+
+  def test_revoke(self):
+    pass
+
+
+
+
+
 class TestRepositoryToolFunctions(unittest.TestCase):
   @classmethod
   def setUpClass(cls):
@@ -545,7 +685,7 @@ def test_get_metadata_filenames(self):
     filenames = {'root.json': os.path.join(metadata_directory, 'root.json'),
                  'targets.json': os.path.join(metadata_directory, 'targets.json'),
                  'snapshot.json': os.path.join(metadata_directory, 'snapshot.json'),
-                 'timestamp.json': os.path.join(metadata_directory,  'timestamp.json')}
+                 'timestamp.json': os.path.join(metadata_directory, 'timestamp.json')}
     self.assertEqual(filenames, repo_tool.get_metadata_filenames())
 
 

From 666bb7ba9e5d572e06c3e9c47f536730cd31ae6a Mon Sep 17 00:00:00 2001
From: Vladimir Diaz <vladimir.v.diaz@gmail.com>
Date: Wed, 9 Apr 2014 12:43:31 -0400
Subject: [PATCH 06/10] Update repository_tool.py.

Add remaining test cases for the methods of repository_tool.Metadata().
Add test case for repository_tool.Repository.get_filepaths_in_directory().
---
 tests/unit/test_repository_tool.py | 316 +++++++++++++++++++++++++++--
 tuf/repository_tool.py             |   5 +-
 2 files changed, 300 insertions(+), 21 deletions(-)

diff --git a/tests/unit/test_repository_tool.py b/tests/unit/test_repository_tool.py
index 9a9edaab..1ddbd12b 100755
--- a/tests/unit/test_repository_tool.py
+++ b/tests/unit/test_repository_tool.py
@@ -16,6 +16,7 @@
 """
 
 import os
+import time
 import unittest
 import logging
 import tempfile
@@ -35,6 +36,30 @@
 
 
 class TestRepository(unittest.TestCase):
+  @classmethod
+  def setUpClass(cls):
+    
+    # setUpClass() is called before tests in an individual class are executed.
+    
+    # Create a temporary directory to store the repository, metadata, and target
+    # files.  'temporary_directory' must be deleted in TearDownClass() so that
+    # temporary files are always removed, even when exceptions occur. 
+    cls.temporary_directory = tempfile.mkdtemp(dir=os.getcwd())
+    
+
+
+  @classmethod 
+  def tearDownClass(cls):
+    
+    # tearDownModule() is called after all the tests have run.
+    # http://docs.python.org/2/library/unittest.html#class-and-module-fixtures
+   
+    # Remove the temporary repository directory, which should contain all the
+    # metadata, targets, and key files generated for the test cases.
+    shutil.rmtree(cls.temporary_directory)
+  
+  
+  
   def setUp(self):
     pass
 
@@ -77,7 +102,27 @@ def test_write_partial(self):
 
 
   def test_get_filepaths_in_directory(self):
-    pass
+    # Test normal case.
+    # Use the pre-generated metadata directory for testing.
+    metadata_directory = os.path.join(os.pardir, 'repository_data',
+                                        'repository', 'metadata')
+    
+    
+    # Test improperly formatted arguments.
+    repo = repo_tool.Repository
+    self.assertRaises(tuf.FormatError, repo.get_filepaths_in_directory,
+                      3, recursive_walk=False, followlinks=False)
+    self.assertRaises(tuf.FormatError, repo.get_filepaths_in_directory,
+                      metadata_directory, 3, followlinks=False)
+    self.assertRaises(tuf.FormatError, repo.get_filepaths_in_directory,
+                      metadata_directory, recursive_walk=False, followlinks=3)
+
+    # Test invalid directory argument.
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory)
+    nonexistent_directory = os.path.join(temporary_directory, 'nonexistent/')
+    self.assertRaises(tuf.Error, repo.get_filepaths_in_directory,
+                      nonexistent_directory, recursive_walk=False,
+                      followlinks=False)
 
 
 
@@ -85,80 +130,313 @@ def test_get_filepaths_in_directory(self):
 
 class TestMetadata(unittest.TestCase):
   def setUp(self):
-    pass
+    # Inherit from the repo_tool.Metadata() base class.  All of the methods
+    # to be tested in TestMetadata require at least 1 role, so create it here
+    # and set its roleinfo.
+    class MetadataRole(repo_tool.Metadata):
+      
+      def __init__(self):
+        super(MetadataRole, self).__init__() 
+        
+        self._rolename = 'metadata_role'
+        
+        # Expire in 86400 seconds (1 day).
+        expiration = tuf.formats.format_time(time.time() + 86400)
+        
+        roleinfo = {'keyids': [], 'signing_keyids': [], 'threshold': 1, 
+                    'signatures': [], 'version': 0,
+                    'consistent_snapshot': False,
+                    'compressions': [''], 'expires': expiration,
+                    'partial_loaded': False}
+        
+        tuf.roledb.add_role(self._rolename, roleinfo)
+    
+    self.metadata = MetadataRole() 
 
 
 
   def tearDown(self):
-    pass
+    tuf.roledb.clear_roledb()
+    tuf.keydb.clear_keydb()
+    self.metadata = None 
 
   
 
   def test_rolename(self):
-    pass
-  
+    base_metadata = repo_tool.Metadata()
+    
+    self.assertEqual(base_metadata.rolename, None)
+    
+    # Test the sub-classed MetadataRole().
+    self.assertEqual(self.metadata.rolename, 'metadata_role')
+
 
 
   def test_version(self):
-    pass
+    # Test version getter, and the default version number.
+    self.assertEqual(self.metadata.version, 0)
+
+    # Test version setter, and verify updated version number.
+    self.metadata.version = 8
+    self.assertEqual(self.metadata.version, 8)
 
 
 
   def test_threshold(self):
-    pass
+    # Test threshold getter, and the default threshold number.
+    self.assertEqual(self.metadata.threshold, 1)
+
+    # Test threshold setter, and verify updated threshold number.
+    self.metadata.threshold = 3
+    self.assertEqual(self.metadata.threshold, 3)
 
 
 
   def test_expiration(self):
-    pass
+    # Test expiration getter.
+    expiration = self.metadata.expiration
+    self.assertTrue(tuf.formats.TIME_SCHEMA.matches(expiration))
+
+    # Test expiration setter. 
+    self.metadata.expiration = '2088-01-01 12:00:00'
+    expiration = self.metadata.expiration
+    self.assertTrue(tuf.formats.TIME_SCHEMA.matches(expiration))
+
+
+    # Test improperly formatted datetime.
+    try: 
+      self.metadata.expiration = '3' 
+    except tuf.FormatError:
+      pass
+    else:
+      self.fail('Setter failed to detect improperly formatted datetime.')
+
+
+    # Test invalid argument (i.e., expiration has already expired.)
+    expired_datetime = tuf.formats.format_time(time.time() - 1)
+    try: 
+      self.metadata.expiration = expired_datetime 
+    except tuf.FormatError:
+      pass
+    else:
+      self.fail('Setter failted to detect an expired datetime.')
 
 
 
   def test_keys(self):
-    pass
+    # Test default case, where a verification key has not been added. 
+    self.assertEqual(self.metadata.keys, [])
+
+
+    # Test keys() getter after a verification key has been loaded.
+    key_path = os.path.join(os.pardir, 'repository_data',
+                            'keystore', 'root_key.pub')
+    key_object = repo_tool.import_rsa_publickey_from_file(key_path)
+    self.metadata.add_verification_key(key_object)
+    
+    keyid = key_object['keyid']
+    self.assertEqual([keyid], self.metadata.keys)
 
 
 
   def test_signing_keys(self):
-    pass
+    # Test default case, where a signing key has not been added. 
+    self.assertEqual(self.metadata.signing_keys, [])
+
+
+    # Test signing_keys() getter after a signing key has been loaded.
+    key_path = os.path.join(os.pardir, 'repository_data',
+                            'keystore', 'root_key')
+    key_object = repo_tool.import_rsa_privatekey_from_file(key_path, 'password')
+    self.metadata.load_signing_key(key_object)
+    
+    keyid = key_object['keyid']
+    self.assertEqual([keyid], self.metadata.signing_keys)
 
 
 
   def test_compressions(self):
-    pass
+    # Test default case, where only uncompressed metadata is supported.
+    self.assertEqual(self.metadata.compressions, [''])
+
+    # Test compressions getter after a compressions algorithm is added.
+    self.metadata.compressions = ['gz']
+
+    self.assertEqual(self.metadata.compressions, ['', 'gz'])
+
+
+    # Test improperly formatted argument.
+    try:
+      self.metadata.compressions = 3
+    except tuf.FormatError:
+      pass
+    else:
+      self.fail('Setter failed to detect improperly formatted compressions')
 
 
 
-  def test_add_verification_keys(self):
-    pass
+  def test_add_verification_key(self):
+    # Add verification key and verify with keys() that it was added. 
+    key_path = os.path.join(os.pardir, 'repository_data',
+                            'keystore', 'root_key.pub')
+    key_object = repo_tool.import_rsa_publickey_from_file(key_path)
+    self.metadata.add_verification_key(key_object)
+    
+    keyid = key_object['keyid']
+    self.assertEqual([keyid], self.metadata.keys)
+
+
+    # Test improperly formatted key argument.
+    self.assertRaises(tuf.FormatError, self.metadata.add_verification_key, 3)
 
 
 
-  def test_remove_verification_keys(self):
-    pass
+  def test_remove_verification_key(self):
+    # Add verification key so that remove_verifiation_key() can be tested.
+    key_path = os.path.join(os.pardir, 'repository_data',
+                            'keystore', 'root_key.pub')
+    key_object = repo_tool.import_rsa_publickey_from_file(key_path)
+    self.metadata.add_verification_key(key_object)
+    
+    keyid = key_object['keyid']
+    self.assertEqual([keyid], self.metadata.keys)
+
+
+    # Test successful removal of verification key added above.
+    self.metadata.remove_verification_key(key_object)
+    self.assertEqual(self.metadata.keys, [])
+    
+
+    # Test improperly formatted argument
+    self.assertRaises(tuf.FormatError, self.metadata.remove_verification_key, 3)
+
+
+    # Test non-existent public key argument.
+    key_path = os.path.join(os.pardir, 'repository_data',
+                            'keystore', 'targets_key.pub')
+    unused_key_object = repo_tool.import_rsa_publickey_from_file(key_path)
+    
+    self.assertRaises(tuf.Error, self.metadata.remove_verification_key,
+                      unused_key_object)
 
 
 
   def test_load_signing_key(self):
-    pass
+    # Test normal case. 
+    key_path = os.path.join(os.pardir, 'repository_data',
+                            'keystore', 'root_key')
+    key_object = repo_tool.import_rsa_privatekey_from_file(key_path, 'password')
+    self.metadata.load_signing_key(key_object)
+    
+    keyid = key_object['keyid']
+    self.assertEqual([keyid], self.metadata.signing_keys)
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, self.metadata.load_signing_key, 3)
+
+    
+    # Test non-private key.
+    key_path = os.path.join(os.pardir, 'repository_data',
+                            'keystore', 'root_key.pub')
+    key_object = repo_tool.import_rsa_publickey_from_file(key_path)
+    self.assertRaises(tuf.Error, self.metadata.load_signing_key, key_object)
 
 
 
   def test_unload_signing_key(self):
-    pass
+    # Load a signing key so that unload_signing_key() can have a key to unload.
+    key_path = os.path.join(os.pardir, 'repository_data',
+                            'keystore', 'root_key')
+    key_object = repo_tool.import_rsa_privatekey_from_file(key_path, 'password')
+    self.metadata.load_signing_key(key_object)
+    
+    keyid = key_object['keyid']
+    self.assertEqual([keyid], self.metadata.signing_keys)
+
+    self.metadata.unload_signing_key(key_object)
+
+    self.assertEqual(self.metadata.signing_keys, [])
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, self.metadata.unload_signing_key, 3)
+
+
+    # Test non-existent key argument.
+    key_path = os.path.join(os.pardir, 'repository_data',
+                            'keystore', 'targets_key')
+    unused_key_object = repo_tool.import_rsa_privatekey_from_file(key_path,
+                                                                  'password')
+    
+    self.assertRaises(tuf.Error, self.metadata.unload_signing_key,
+                      unused_key_object)
 
 
 
   def test_add_signature(self):
-    pass
+    # Test normal case.
+    # Load signature list from any of pre-generated metadata; needed for
+    # testing.
+    metadata_directory = os.path.join(os.pardir, 'repository_data',
+                                      'repository', 'metadata')
+    root_filepath = os.path.join(metadata_directory, 'root.json')
+    root_signable = tuf.util.load_json_file(root_filepath)
+    signatures = root_signable['signatures']
 
+    # Add the first signature from the list, as only need one is needed.
+    self.metadata.add_signature(signatures[0])
+    self.assertEqual(signatures, self.metadata.signatures)
+
+
+    # Test improperly formatted signature argument.
+    self.assertRaises(tuf.FormatError, self.metadata.add_signature, 3)
 
 
 
   def test_remove_signature(self):
-    pass
+    # Test normal case.
+    # Add a signature so remove_signature() has some signature to remove.
+    metadata_directory = os.path.join(os.pardir, 'repository_data',
+                                      'repository', 'metadata')
+    root_filepath = os.path.join(metadata_directory, 'root.json')
+    root_signable = tuf.util.load_json_file(root_filepath)
+    signatures = root_signable['signatures']
+    self.metadata.add_signature(signatures[0])
+
+    self.metadata.remove_signature(signatures[0])
+    self.assertEqual(self.metadata.signatures, [])
 
 
+    # Test improperly formatted signature argument.
+    self.assertRaises(tuf.FormatError, self.metadata.remove_signature, 3)
+
+
+    # Test invalid signature argument (i.e., signature that has not been added.)
+    # Load an unused signature to be tested.
+    targets_filepath = os.path.join(metadata_directory, 'targets.json')
+    targets_signable = tuf.util.load_json_file(targets_filepath)
+    signatures = targets_signable['signatures']
+    
+    self.assertRaises(tuf.Error, self.metadata.remove_signature, signatures[0])
+
+
+
+  def test_signatures(self):
+    # Test default case, where no signatures have been added yet.
+    self.assertEqual(self.metadata.signatures, [])
+
+
+    # Test getter after adding an example signature.
+    metadata_directory = os.path.join(os.pardir, 'repository_data',
+                                      'repository', 'metadata')
+    root_filepath = os.path.join(metadata_directory, 'root.json')
+    root_signable = tuf.util.load_json_file(root_filepath)
+    signatures = root_signable['signatures']
+
+    # Add the first signature from the list, as only need one is needed.
+    self.metadata.add_signature(signatures[0])
+    self.assertEqual(signatures, self.metadata.signatures)
 
 
 
diff --git a/tuf/repository_tool.py b/tuf/repository_tool.py
index 4d47fea8..292e6d02 100755
--- a/tuf/repository_tool.py
+++ b/tuf/repository_tool.py
@@ -1117,7 +1117,8 @@ def expiration(self, expiration_datetime_utc):
         'tuf.formats.DATETIME_SCHEMA'.
 
     <Exceptions>
-      tuf.FormatError, if 'expiration_datetime_utc' is improperly formatted.
+      tuf.FormatError, if 'expiration_datetime_utc' is improperly formatted,
+      or invalid (e.g., already expired).
     
     <Side Effects>
       Modifies the expiration attribute of the Repository object.
@@ -1135,7 +1136,7 @@ def expiration(self, expiration_datetime_utc):
     # Further validate the datetime, such as a correct date, time, expiration.
     # Convert 'expiration_datetime_utc' to a unix timestamp so that it can be
     # compared with time.time().
-    expiration_datetime_utc = expiration_datetime_utc+' UTC'
+    expiration_datetime_utc = expiration_datetime_utc + ' UTC'
     try:
       unix_timestamp = tuf.formats.parse_time(expiration_datetime_utc)
     

From 4ddd5a417c26ddfd1219144af834116244d4ea74 Mon Sep 17 00:00:00 2001
From: Vladimir Diaz <vladimir.v.diaz@gmail.com>
Date: Wed, 9 Apr 2014 12:52:20 -0400
Subject: [PATCH 07/10] Update repository tool diagram.

Add missing 'repository_tool.Metadata.signatures' to the diagram.
---
 docs/images/repository_tool-diagram.png | Bin 90045 -> 91913 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/docs/images/repository_tool-diagram.png b/docs/images/repository_tool-diagram.png
index 36d444f944625f44099f9f643a1ad1a1ed3d16c2..e8e6f2898b4788f535e3151c8d7ba18466e937e4 100644
GIT binary patch
literal 91913
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
Vkq@GbJIMb(b6OWupk@*H{{f7yXsG}I

literal 90045
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
Z;`3LcY%gyHOhMqEmfBU-Y-Ni_{|{0(yIKGM


From e018c76c1edc1579e45a840902ae85602079acca Mon Sep 17 00:00:00 2001
From: Vladimir Diaz <vladimir.v.diaz@gmail.com>
Date: Thu, 10 Apr 2014 11:34:40 -0400
Subject: [PATCH 08/10] Finish test cases for the methods of Targets().

---
 tests/unit/test_repository_tool.py | 359 ++++++++++++++++++++++++++++-
 tuf/repository_tool.py             |  12 +-
 2 files changed, 354 insertions(+), 17 deletions(-)

diff --git a/tests/unit/test_repository_tool.py b/tests/unit/test_repository_tool.py
index 1ddbd12b..a6b00761 100755
--- a/tests/unit/test_repository_tool.py
+++ b/tests/unit/test_repository_tool.py
@@ -513,14 +513,45 @@ def test_init(self):
 
 
 class TestTargets(unittest.TestCase):
+  @classmethod
+  def setUpClass(cls):
+    
+    # setUpClass() is called before tests in an individual class are executed.
+    
+    # Create a temporary directory to store the repository, metadata, and target
+    # files.  'temporary_directory' must be deleted in TearDownClass() so that
+    # temporary files are always removed, even when exceptions occur. 
+    cls.temporary_directory = tempfile.mkdtemp(dir=os.getcwd())
+    
+
+
+  @classmethod 
+  def tearDownClass(cls):
+    
+    # tearDownModule() is called after all the tests have run.
+    # http://docs.python.org/2/library/unittest.html#class-and-module-fixtures
+   
+    # Remove the temporary repository directory, which should contain all the
+    # metadata, targets, and key files generated for the test cases.
+    shutil.rmtree(cls.temporary_directory)
+ 
+
+
   def setUp(self):
-    pass
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory)
+    self.targets_directory = os.path.join(temporary_directory, 'repository',
+                                          'targets')
+    original_targets_directory = os.path.join(os.pardir, 'repository_data',
+                                              'repository', 'targets')
+    shutil.copytree(original_targets_directory, self.targets_directory)
+    self.targets_object = repo_tool.Targets(self.targets_directory)
 
 
 
   def tearDown(self):
     tuf.roledb.clear_roledb() 
     tuf.keydb.clear_keydb()
+    self.targets_object = None
   
   
   
@@ -559,57 +590,361 @@ def test_init(self):
 
 
   def test_get_delegated_rolenames(self):
-    pass
+    # Test normal case.
+    # Perform two delegations so that get_delegated_rolenames() has roles to 
+    # return.
+    keystore_directory = os.path.join(os.pardir, 'repository_data', 'keystore')
+    public_keypath = os.path.join(keystore_directory, 'root_key.pub')
+    public_key = repo_tool.import_rsa_publickey_from_file(public_keypath)
+    target1_filepath = os.path.join(self.targets_directory, 'file1.txt')
+    target2_filepath = os.path.join(self.targets_directory, 'file2.txt')
+
+    # Set needed arguments by delegate().
+    public_keys = [public_key]
+    threshold = 1
+
+    self.targets_object.delegate('tuf', public_keys, [target1_filepath],
+                                 threshold, restricted_paths=None,
+                                 path_hash_prefixes=None)
+    self.targets_object.delegate('warehouse', public_keys, [target2_filepath],
+                                 threshold, restricted_paths=None,
+                                 path_hash_prefixes=None)
+
+    # Test that get_delegated_rolenames returns the expected delegations.
+    expected_delegated_rolenames = ['targets/tuf/', 'targets/warehouse']
+    for delegated_rolename in self.targets_object.get_delegated_rolenames():
+      delegated_rolename in expected_delegated_rolenames  
 
 
 
   def test_target_files(self):
-    pass
+    # Test normal case.
+    # Verify the targets object initially contains zero target files.
+    self.assertEqual(self.targets_object.target_files, [])
+
+    target_filepath = os.path.join(self.targets_directory, 'file1.txt')
+    self.targets_object.add_target(target_filepath)
+
+    self.assertEqual(len(self.targets_object.target_files), 1)
+    self.assertTrue('/file1.txt' in self.targets_object.target_files)
 
 
 
   def test_delegations(self):
-    pass
+    # Test normal case.
+    # Perform a delegation so that delegations() has a Targets() object to
+    # return.
+    keystore_directory = os.path.join(os.pardir, 'repository_data', 'keystore')
+    public_keypath = os.path.join(keystore_directory, 'root_key.pub')
+    public_key = repo_tool.import_rsa_publickey_from_file(public_keypath)
+    target1_filepath = os.path.join(self.targets_directory, 'file1.txt')
+
+    # Set needed arguments by delegate().
+    public_keys = [public_key]
+    rolename = 'tuf'
+    list_of_targets = [target1_filepath] 
+    threshold = 1
+
+    self.targets_object.delegate(rolename, public_keys, list_of_targets,
+                                 threshold, restricted_paths=None,
+                                 path_hash_prefixes=None)
+
+    # Test that a valid Targets() object is returned by delegations().
+    for delegated_object in self.targets_object.delegations:
+      self.assertTrue(isinstance(delegated_object, repo_tool.Targets))
 
 
 
   def test_add_target(self):
-    pass
+    # Test normal case.
+    # Verify the targets object initially contains zero target files.
+    self.assertEqual(self.targets_object.target_files, [])
+
+    target_filepath = os.path.join(self.targets_directory, 'file1.txt')
+    self.targets_object.add_target(target_filepath)
+
+    self.assertEqual(len(self.targets_object.target_files), 1)
+    self.assertTrue('/file1.txt' in self.targets_object.target_files)
+    
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, self.targets_object.add_target,
+                      3)
+
+
+    # Test invalid filepath argument (i.e., non-existent or invalid file.)
+    self.assertRaises(tuf.Error, self.targets_object.add_target,
+                      'non-existent.txt')
+    self.assertRaises(tuf.Error, self.targets_object.add_target,
+                      self.temporary_directory)
 
 
 
   def test_add_targets(self):
-    pass
+    # Test normal case.
+    # Verify the targets object initially contains zero target files.
+    self.assertEqual(self.targets_object.target_files, [])
+
+    target1_filepath = os.path.join(self.targets_directory, 'file1.txt')
+    target2_filepath = os.path.join(self.targets_directory, 'file2.txt')
+    target3_filepath = os.path.join(self.targets_directory, 'file3.txt')
+    
+    target_files = [target1_filepath, target2_filepath, target3_filepath]
+    self.targets_object.add_targets(target_files)
+    
+    self.assertEqual(len(self.targets_object.target_files), 3)
+    self.assertEqual(self.targets_object.target_files, 
+                     ['/file1.txt', '/file2.txt', '/file3.txt'])
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, self.targets_object.add_targets,
+                      3)
+
+
+    # Test invalid filepath argument (i.e., non-existent or invalid file.)
+    self.assertRaises(tuf.Error, self.targets_object.add_target,
+                      ['non-existent.txt'])
+    self.assertRaises(tuf.Error, self.targets_object.add_target,
+                      [target1_filepath, target2_filepath, 'non-existent.txt'])
+    self.assertRaises(tuf.Error, self.targets_object.add_target,
+                      self.temporary_directory)
 
 
 
   def test_remove_target(self):
-    pass
+    # Test normal case.
+    # Verify the targets object initially contains zero target files.
+    self.assertEqual(self.targets_object.target_files, [])
+
+    # Add a target so that remove_target() has something to remove.
+    target_filepath = os.path.join(self.targets_directory, 'file1.txt')
+    self.targets_object.add_target(target_filepath)
+
+    # Test remove_target()'s behavior.
+    self.targets_object.remove_target(target_filepath)
+    self.assertEqual(self.targets_object.target_files, [])
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, self.targets_object.remove_target,
+                      3)
+
+
+    # Test invalid filepath argument (i.e., non-existent or invalid file.)
+    self.assertRaises(tuf.Error, self.targets_object.remove_target,
+                      '/non-existent.txt')
 
 
 
   def test_clear_targets(self):
-    pass
+    # Test normal case.
+    # Verify the targets object initially contains zero target files.
+    self.assertEqual(self.targets_object.target_files, [])
+
+    # Add targets, to be tested by clear_targets().
+    target1_filepath = os.path.join(self.targets_directory, 'file1.txt')
+    target2_filepath = os.path.join(self.targets_directory, 'file2.txt')
+    self.targets_object.add_targets([target1_filepath, target2_filepath])
+
+    self.targets_object.clear_targets()
+    self.assertEqual(self.targets_object.target_files, [])
 
 
 
   def test_delegate(self):
-    pass
+    # Test normal case.
+    # Need at least one public key and valid target paths required by
+    # delegate().
+    keystore_directory = os.path.join(os.pardir, 'repository_data', 'keystore')
+    public_keypath = os.path.join(keystore_directory, 'root_key.pub')
+    public_key = repo_tool.import_rsa_publickey_from_file(public_keypath)
+    target1_filepath = os.path.join(self.targets_directory, 'file1.txt')
+    target2_filepath = os.path.join(self.targets_directory, 'file2.txt')
+  
+
+    # Set needed arguments by delegate().
+    public_keys = [public_key]
+    rolename = 'tuf'
+    list_of_targets = [target1_filepath, target2_filepath] 
+    threshold = 1
+    restricted_paths = [self.targets_directory]
+    path_hash_prefixes = ['e3a3', '8fae', 'd543']
+
+    self.targets_object.delegate(rolename, public_keys, list_of_targets,
+                                 threshold, restricted_paths,
+                                 path_hash_prefixes)
+
+    self.assertEqual(self.targets_object.get_delegated_rolenames(),
+                     ['targets/tuf'])
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, self.targets_object.delegate,
+                      3, public_keys, list_of_targets, threshold,
+                      restricted_paths, path_hash_prefixes)
+    self.assertRaises(tuf.FormatError, self.targets_object.delegate,
+                      rolename, 3, list_of_targets, threshold,
+                      restricted_paths, path_hash_prefixes)
+    self.assertRaises(tuf.FormatError, self.targets_object.delegate,
+                      rolename, public_keys, 3, threshold,
+                      restricted_paths, path_hash_prefixes)
+    self.assertRaises(tuf.FormatError, self.targets_object.delegate,
+                      rolename, public_keys, list_of_targets, '3',
+                      restricted_paths, path_hash_prefixes)
+    self.assertRaises(tuf.FormatError, self.targets_object.delegate,
+                      rolename, public_keys, list_of_targets, threshold,
+                      3, path_hash_prefixes)
+    self.assertRaises(tuf.FormatError, self.targets_object.delegate,
+                      rolename, public_keys, list_of_targets, threshold,
+                      restricted_paths, 3)
+
+
+    # Test invalid arguments (e.g., already delegated 'rolename', non-existent
+    # files, etc.).
+    # Test duplicate 'rolename' delegation, which should have been delegated
+    # in the normal case above.
+    self.assertRaises(tuf.Error, self.targets_object.delegate,
+                      rolename, public_keys, list_of_targets, threshold,
+                      restricted_paths, path_hash_prefixes)
+    
+    # Test non-existent target paths.
+    self.assertRaises(tuf.Error, self.targets_object.delegate,
+                      rolename, public_keys, ['/non-existent'], threshold,
+                      restricted_paths, path_hash_prefixes)
 
 
 
   def test_delegate_hashed_bins(self):
-    pass
+    # Test normal case.
+    keystore_directory = os.path.join(os.pardir, 'repository_data', 'keystore')
+    public_keypath = os.path.join(keystore_directory, 'root_key.pub')
+    public_key = repo_tool.import_rsa_publickey_from_file(public_keypath)
+    target1_filepath = os.path.join(self.targets_directory, 'file1.txt')
+
+    # Set needed arguments by delegate_hashed_bins().
+    public_keys = [public_key]
+    list_of_targets = [target1_filepath] 
+
+    # Test delegate_hashed_bins() and verify that 16 hashed bins have
+    # been delegated in the parent's roleinfo.
+    self.targets_object.delegate_hashed_bins(list_of_targets, public_keys,
+                                             number_of_bins=16)
+
+    # The expected child rolenames, since 'number_of_bins' = 16 
+    delegated_rolenames = ['0', '1', '2', '3', '4', '5', '6', '7',
+                           '8', '9', 'a', 'b', 'c', 'd', 'e', 'f']
+
+    # Prepend the parent's rolename.
+    expected_delegated_rolenames = []
+    for rolename in delegated_rolenames:
+      rolename = self.targets_object.rolename + '/' + rolename
+      expected_delegated_rolenames.append(rolename)
+
+    self.assertEqual(sorted(self.targets_object.get_delegated_rolenames()),
+                     sorted(expected_delegated_rolenames))
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError,
+                      self.targets_object.delegate_hashed_bins, 3, public_keys,
+                      number_of_bins=1)
+    self.assertRaises(tuf.FormatError,
+                      self.targets_object.delegate_hashed_bins,
+                      list_of_targets, 3, number_of_bins=1)
+    self.assertRaises(tuf.FormatError,
+                      self.targets_object.delegate_hashed_bins,
+                      list_of_targets, public_keys, '1')
+
+
+    # Test invalid arguments.
+    # Invalid number of bins, which must be a power of 2.
+    self.assertRaises(tuf.Error,
+                      self.targets_object.delegate_hashed_bins,
+                      list_of_targets, public_keys, number_of_bins=3)
+    
+    # Invalid 'list_of_targets'.
+    self.assertRaises(tuf.Error,
+                      self.targets_object.delegate_hashed_bins,
+                      ['/non-existent'], public_keys, number_of_bins=3)
 
 
 
   def test_add_restricted_paths(self):
-    pass
+    # Test normal case.
+    # Perform a delegation so that add_restricted_paths() has a child role
+    # to restrict.
+    keystore_directory = os.path.join(os.pardir, 'repository_data', 'keystore')
+    public_keypath = os.path.join(keystore_directory, 'root_key.pub')
+    public_key = repo_tool.import_rsa_publickey_from_file(public_keypath)
+
+    # Set needed arguments by delegate().
+    public_keys = [public_key]
+    rolename = 'tuf'
+    threshold = 1
+
+    self.targets_object.delegate(rolename, public_keys, [],
+                                 threshold, restricted_paths=None,
+                                 path_hash_prefixes=None)
+
+    restricted_path = os.path.join(self.targets_directory, 'tuf_files')
+    os.mkdir(restricted_path)
+    restricted_paths = [restricted_path]
+    self.targets_object.add_restricted_paths(restricted_paths, 'tuf')
+    
+    # Retrieve 'targets_object' roleinfo, and verify the roleinfo contains
+    # the expected restricted paths of the delegated role.  Only
+    # Repository.write() verifies that child target paths are allowed by the
+    # parent.
+    targets_object_roleinfo = tuf.roledb.get_roleinfo(self.targets_object.rolename)
+
+    delegated_role = targets_object_roleinfo['delegations']['roles'][0]
+    self.assertEqual(['/tuf_files/'], delegated_role['paths'])
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, self.targets_object.add_restricted_paths,
+                      3, 'tuf')
+    self.assertRaises(tuf.FormatError, self.targets_object.add_restricted_paths,
+                      restricted_paths, 3)
+
+
+    # Test invalid arguments.
+    # A non-delegated child role.
+    self.assertRaises(tuf.Error, self.targets_object.add_restricted_paths,
+                      restricted_paths, 'non_delegated_rolename')
+    
+    # Non-existent 'restricted_paths'.
+    self.assertRaises(tuf.Error, self.targets_object.add_restricted_paths,
+                      ['/non-existent'], 'tuf')
 
 
 
   def test_revoke(self):
-    pass
+    # Test normal case.
+    # Perform a delegation so that revoke() has a delegation to revoke.
+    keystore_directory = os.path.join(os.pardir, 'repository_data', 'keystore')
+    public_keypath = os.path.join(keystore_directory, 'root_key.pub')
+    public_key = repo_tool.import_rsa_publickey_from_file(public_keypath)
+    target1_filepath = os.path.join(self.targets_directory, 'file1.txt')
+
+    # Set needed arguments by delegate().
+    public_keys = [public_key]
+    rolename = 'tuf'
+    list_of_targets = [target1_filepath] 
+    threshold = 1
+
+    self.targets_object.delegate(rolename, public_keys, list_of_targets,
+                                 threshold, restricted_paths=None,
+                                 path_hash_prefixes=None)
+
+    # Test revoke()
+    self.targets_object.revoke('tuf')
+    self.assertEqual(self.targets_object.get_delegated_rolenames(), [])
+
+
+    # Test improperly formatted rolename argument.
+    self.assertRaises(tuf.FormatError, self.targets_object.revoke, 3)
 
 
 
diff --git a/tuf/repository_tool.py b/tuf/repository_tool.py
index 292e6d02..737141b9 100755
--- a/tuf/repository_tool.py
+++ b/tuf/repository_tool.py
@@ -1611,7 +1611,8 @@ def add_restricted_paths(self, list_of_directory_paths, child_rolename):
 
       child_rolename:
         The child delegation that requires an update to its restricted paths,
-        as listed in the parent role's delegations.
+        as listed in the parent role's delegations (e.g., 'Django' in
+        'targets/unclaimed/Django').
 
     <Exceptions>
       tuf.Error, if a directory path in 'list_of_directory_paths' is not a
@@ -2192,8 +2193,9 @@ def delegate_hashed_bins(self, list_of_targets, keys_of_hashed_bins,
         considered the hash prefix).
 
     <Exceptions>
-      tuf.FormatError, if the arguments are improperly formatted,
-        'number_of_bins' is not a power of 2, or one of the targets
+      tuf.FormatError, if the arguments are improperly formatted.
+      
+      tuf.Error, if 'number_of_bins' is not a power of 2, or one of the targets
         in 'list_of_targets' is not located under the repository's targets
         directory.
 
@@ -2229,7 +2231,7 @@ def delegate_hashed_bins(self, list_of_targets, keys_of_hashed_bins,
     # (total_hash_prefixes / number_of_bins) hash prefixes.
     if total_hash_prefixes % number_of_bins != 0:
       message = 'The "number_of_bins" argument must be a power of 2.'
-      raise tuf.FormatError(message)
+      raise tuf.Error(message)
 
     logger.info('Creating hashed bin delegations.')
     logger.info(repr(len(list_of_targets)) + ' total targets.')
@@ -2250,7 +2252,7 @@ def delegate_hashed_bins(self, list_of_targets, keys_of_hashed_bins,
       if not target_path.startswith(self._targets_directory+os.sep):
         message = 'A path in the list of targets argument is not '+\
           'under the repository\'s targets directory: '+repr(target_path) 
-        raise tuf.FormatError(message)
+        raise tuf.Error(message)
       
       # Determine the hash prefix of 'target_path' by computing the digest of
       # its path relative to the targets directory.  Example:

From 19bc1f326ee8941ee7f60aecd975c1afa8119301 Mon Sep 17 00:00:00 2001
From: Vladimir Diaz <vladimir.v.diaz@gmail.com>
Date: Thu, 10 Apr 2014 12:59:42 -0400
Subject: [PATCH 09/10] [WIP] Add test case for repository.write().

---
 tests/unit/test_repository_tool.py | 106 +++++++++++++++++++++++++++--
 1 file changed, 102 insertions(+), 4 deletions(-)

diff --git a/tests/unit/test_repository_tool.py b/tests/unit/test_repository_tool.py
index a6b00761..6b2de58b 100755
--- a/tests/unit/test_repository_tool.py
+++ b/tests/unit/test_repository_tool.py
@@ -91,13 +91,109 @@ def test_init(self):
 
   
 
-  def test_write(self):
-    pass
+  def test_write_and_write_partial(self):
+    # Test full example of creating a TUF repository, including delegations.
+    # 1. Load public and private keys.
+    # 2. Add verification keys.
+    # 3. Load signing keys.
+    # 4. Add target files.
+    # 5. Perform delegation.
+    # 5. write()
+    # 
+    # Copy the target files from 'tuf/tests/repository_data' so that write()
+    # has target files to include in metadata.
+    temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory)
+    targets_directory = os.path.join(temporary_directory, 'repository',
+                                     repo_tool.TARGETS_DIRECTORY_NAME)
+    original_targets_directory = os.path.join(os.pardir, 'repository_data',
+                                              'repository', 'targets')
+    shutil.copytree(original_targets_directory, targets_directory)
+
+    # create_new_repository() creates the 'repository/' sub-directory in
+    # 'temporary_directory' if it does not exist.
+    repository_directory = os.path.join(temporary_directory, 'repository')
+    repository = repo_tool.create_new_repository(repository_directory)
+
+    
+    # (1) Load the public and private keys of the top-level roles, and one
+    # delegated.
+    keystore_directory = os.path.join(os.pardir, 'repository_data', 'keystore')
+   
+    # Load the public keys.
+    root_pubkey_path = os.path.join(keystore_directory, 'root_key.pub')
+    targets_pubkey_path = os.path.join(keystore_directory, 'targets_key.pub')
+    snapshot_pubkey_path = os.path.join(keystore_directory, 'snapshot_key.pub')
+    timestamp_pubkey_path = os.path.join(keystore_directory, 'timestamp_key.pub')
+    role1_pubkey_path = os.path.join(keystore_directory, 'delegation_key.pub')
+    
+    root_pubkey = repo_tool.import_rsa_publickey_from_file(root_pubkey_path)
+    targets_pubkey = repo_tool.import_rsa_publickey_from_file(targets_pubkey_path)
+    snapshot_pubkey = repo_tool.import_rsa_publickey_from_file(snapshot_pubkey_path)
+    timestamp_pubkey = repo_tool.import_rsa_publickey_from_file(timestamp_pubkey_path)
+    role1_pubkey = repo_tool.import_rsa_publickey_from_file(role1_pubkey_path)
+    
+    # Load the private keys.
+    root_privkey_path = os.path.join(keystore_directory, 'root_key')
+    targets_privkey_path = os.path.join(keystore_directory, 'targets_key')
+    snapshot_privkey_path = os.path.join(keystore_directory, 'snapshot_key')
+    timestamp_privkey_path = os.path.join(keystore_directory, 'timestamp_key')
+    role1_privkey_path = os.path.join(keystore_directory, 'delegation_key')
+    
+    root_privkey = \
+      repo_tool.import_rsa_privatekey_from_file(root_privkey_path, 'password')
+    targets_privkey = \
+      repo_tool.import_rsa_privatekey_from_file(targets_privkey_path,
+                                                'password')
+    snapshot_privkey = \
+      repo_tool.import_rsa_privatekey_from_file(snapshot_privkey_path,
+                                                'password')
+    timestamp_privkey = \
+      repo_tool.import_rsa_privatekey_from_file(timestamp_privkey_path,
+                                                'password')
+    role1_privkey = \
+      repo_tool.import_rsa_privatekey_from_file(role1_privkey_path,
+                                                'password')
 
 
+    # (2) Add verification keys.
+    repository.root.add_verification_key(root_pubkey)
+    repository.targets.add_verification_key(targets_pubkey)
+    repository.snapshot.add_verification_key(snapshot_pubkey)
+    repository.timestamp.add_verification_key(timestamp_pubkey)
+    
+    
+    # (3) Load signing keys.
+    repository.root.load_signing_key(root_privkey)
+    repository.targets.load_signing_key(targets_privkey)
+    repository.snapshot.load_signing_key(snapshot_privkey)
+    repository.timestamp.load_signing_key(timestamp_privkey)
+   
+    
+    # (4) Add target files.
+    target1 = os.path.join(targets_directory, 'file1.txt')
+    target2 = os.path.join(targets_directory, 'file2.txt')
+    target3 = os.path.join(targets_directory, 'file3.txt')
+    repository.targets.add_target(target1)
+    repository.targets.add_target(target2)
 
-  def test_write_partial(self):
-    pass
+    # (5) Perform delegation.
+    repository.targets.delegate('role1', [role1_pubkey], [target3]) 
+    repository.targets('role1').load_signing_key(role1_privkey)
+    
+    # (6) Write repository.
+    repository.targets.compressions = ['gz']
+    repository.write()
+
+
+    # TODO: Test expected exceptions for incomplete write().
+    # TODO: Test consistent snapshots.
+    # TODO: Test write_partial()
+    # TODO: Test multiple writes, loading repository, and compressed metadata.
+
+
+    # Test improperly formatted arguments.
+    self.assertRaises(tuf.FormatError, repository.write, 3, False)
+    self.assertRaises(tuf.FormatError, repository.write, False, 3)
 
 
 
@@ -109,7 +205,9 @@ def test_get_filepaths_in_directory(self):
     
     
     # Test improperly formatted arguments.
+    # Set 'repo' to improve readability.
     repo = repo_tool.Repository
+
     self.assertRaises(tuf.FormatError, repo.get_filepaths_in_directory,
                       3, recursive_walk=False, followlinks=False)
     self.assertRaises(tuf.FormatError, repo.get_filepaths_in_directory,

From 6a4c82cc8172e8f88865b0751d7d2859d97631f6 Mon Sep 17 00:00:00 2001
From: vladdd <vladimir.v.diaz@gmail.com>
Date: Fri, 11 Apr 2014 07:35:02 -0400
Subject: [PATCH 10/10] Finish test case for write().

---
 tests/unit/test_repository_tool.py | 91 +++++++++++++++++++++++++-----
 tuf/repository_tool.py             | 27 +++++----
 2 files changed, 91 insertions(+), 27 deletions(-)

diff --git a/tests/unit/test_repository_tool.py b/tests/unit/test_repository_tool.py
index 6b2de58b..62dc92f4 100755
--- a/tests/unit/test_repository_tool.py
+++ b/tests/unit/test_repository_tool.py
@@ -92,7 +92,8 @@ def test_init(self):
   
 
   def test_write_and_write_partial(self):
-    # Test full example of creating a TUF repository, including delegations.
+    # Test creation of a TUF repository.
+    # 
     # 1. Load public and private keys.
     # 2. Add verification keys.
     # 3. Load signing keys.
@@ -101,7 +102,7 @@ def test_write_and_write_partial(self):
     # 5. write()
     # 
     # Copy the target files from 'tuf/tests/repository_data' so that write()
-    # has target files to include in metadata.
+    # has target fileinfo to include in metadata.
     temporary_directory = tempfile.mkdtemp(dir=self.temporary_directory)
     targets_directory = os.path.join(temporary_directory, 'repository',
                                      repo_tool.TARGETS_DIRECTORY_NAME)
@@ -109,14 +110,16 @@ def test_write_and_write_partial(self):
                                               'repository', 'targets')
     shutil.copytree(original_targets_directory, targets_directory)
 
-    # create_new_repository() creates the 'repository/' sub-directory in
-    # 'temporary_directory' if it does not exist.
+    # In this case, create_new_repository() creates the 'repository/'
+    # sub-directory in 'temporary_directory' if it does not exist.
     repository_directory = os.path.join(temporary_directory, 'repository')
+    metadata_directory = os.path.join(repository_directory,
+                                      repo_tool.METADATA_STAGED_DIRECTORY_NAME)
     repository = repo_tool.create_new_repository(repository_directory)
 
     
     # (1) Load the public and private keys of the top-level roles, and one
-    # delegated.
+    # delegated role.
     keystore_directory = os.path.join(os.pardir, 'repository_data', 'keystore')
    
     # Load the public keys.
@@ -127,9 +130,12 @@ def test_write_and_write_partial(self):
     role1_pubkey_path = os.path.join(keystore_directory, 'delegation_key.pub')
     
     root_pubkey = repo_tool.import_rsa_publickey_from_file(root_pubkey_path)
-    targets_pubkey = repo_tool.import_rsa_publickey_from_file(targets_pubkey_path)
-    snapshot_pubkey = repo_tool.import_rsa_publickey_from_file(snapshot_pubkey_path)
-    timestamp_pubkey = repo_tool.import_rsa_publickey_from_file(timestamp_pubkey_path)
+    targets_pubkey = \
+      repo_tool.import_rsa_publickey_from_file(targets_pubkey_path)
+    snapshot_pubkey = \
+      repo_tool.import_rsa_publickey_from_file(snapshot_pubkey_path)
+    timestamp_pubkey = \
+      repo_tool.import_rsa_publickey_from_file(timestamp_pubkey_path)
     role1_pubkey = repo_tool.import_rsa_publickey_from_file(role1_pubkey_path)
     
     # Load the private keys.
@@ -155,17 +161,27 @@ def test_write_and_write_partial(self):
                                                 'password')
 
 
-    # (2) Add verification keys.
+    # (2) Add top-level verification keys.
     repository.root.add_verification_key(root_pubkey)
     repository.targets.add_verification_key(targets_pubkey)
     repository.snapshot.add_verification_key(snapshot_pubkey)
+
+    # Verify that repository.write() fails for insufficient threshold
+    # of signatures (default threshold = 1).
+    self.assertRaises(tuf.UnsignedMetadataError, repository.write) 
+    
     repository.timestamp.add_verification_key(timestamp_pubkey)
     
     
-    # (3) Load signing keys.
+    # (3) Load top-level signing keys.
     repository.root.load_signing_key(root_privkey)
     repository.targets.load_signing_key(targets_privkey)
     repository.snapshot.load_signing_key(snapshot_privkey)
+   
+    # Verify that repository.write() fails for insufficient threshold
+    # of signatures (default threshold = 1).
+    self.assertRaises(tuf.UnsignedMetadataError, repository.write) 
+    
     repository.timestamp.load_signing_key(timestamp_privkey)
    
     
@@ -184,11 +200,56 @@ def test_write_and_write_partial(self):
     repository.targets.compressions = ['gz']
     repository.write()
 
+    
+    # Verify that the expected metadata is written.
+    for role in ['root.json', 'targets.json', 'snapshot.json', 'timestamp.json']:
+      role_filepath = os.path.join(metadata_directory, role)
+      role_signable = tuf.util.load_json_file(role_filepath)
+      
+      # Raise 'tuf.FormatError' if 'role_signable' is an invalid signable.
+      tuf.formats.check_signable_object_format(role_signable)
 
-    # TODO: Test expected exceptions for incomplete write().
-    # TODO: Test consistent snapshots.
-    # TODO: Test write_partial()
-    # TODO: Test multiple writes, loading repository, and compressed metadata.
+      if role == 'targets.json':
+        compressed_filepath = role_filepath + '.gz'
+        self.assertTrue(os.path.exists(compressed_filepath))
+       
+    # Verify the 'role1.json' delegation is also written.
+    role1_filepath = os.path.join(metadata_directory, 'targets', 'role1.json')
+    role1_signable = tuf.util.load_json_file(role1_filepath)
+    tuf.formats.check_signable_object_format(role1_signable)
+
+    # Verify that an exception is *not* raised for multiple repository.write().
+    repository.write()
+
+    # Verify that a write() fails if a repository is loaded and a change
+    # is made to a role.
+    repo_tool.load_repository(repository_directory)
+    
+    repository.timestamp.expiration = '2084-01-01 12:00:00'
+    self.assertRaises(tuf.UnsignedMetadataError, repository.write)
+
+    # Verify that a write_partial() is allowed. 
+    repository.write_partial()
+
+    # Next, perform a non-partial write() with consistent snapshots enabled.
+    # Since the timestamp was modified, load its private key.
+    repository.timestamp.load_signing_key(timestamp_privkey)
+
+    # Test creation of a consistent snapshot repository.  Writing a consistent
+    # snapshot modifies the Root metadata, which specifies whether a repository
+    # supports consistent snapshots.  Verify that an exception is raised due to
+    # the missing signatures of Root and Snapshot.
+    self.assertRaises(tuf.UnsignedMetadataError, repository.write,
+                      False, True)
+    
+    # Load the private keys of Root and Snapshot (new version required since
+    # Root has changed.)
+    repository.root.load_signing_key(root_privkey)
+    repository.snapshot.load_signing_key(snapshot_privkey)
+   
+    # Verify that consistent snapshot can be written and loaded. 
+    repository.write(consistent_snapshot=True) 
+    repo_tool.load_repository(repository_directory)
 
 
     # Test improperly formatted arguments.
@@ -205,7 +266,7 @@ def test_get_filepaths_in_directory(self):
     
     
     # Test improperly formatted arguments.
-    # Set 'repo' to improve readability.
+    # Set 'repo' reference to improve readability.
     repo = repo_tool.Repository
 
     self.assertRaises(tuf.FormatError, repo.get_filepaths_in_directory,
diff --git a/tuf/repository_tool.py b/tuf/repository_tool.py
index 737141b9..5e1a3866 100755
--- a/tuf/repository_tool.py
+++ b/tuf/repository_tool.py
@@ -2771,29 +2771,32 @@ def _delete_obsolete_metadata(metadata_directory, snapshot_metadata,
       
         # Strip the digest if 'consistent_snapshot' is True.
         # Example:  'targets/unclaimed/13df98ab0.django.json'  -->
-        # 'targets/unclaimed/django.json'
-        metadata_name, embeded_digest = \
-          _strip_consistent_snapshot_digest(metadata_name, consistent_snapshot)
-
+        # 'targets/unclaimed/django.json'.  Consistent and non-consistent
+        # metadata might co-exist if write() and write(consistent_snapshot=True)
+        # are mixed, so ensure only 'digest.filename' metadata is stripped.
+        embeded_digest = None
+        if metadata_name not in snapshot_metadata['meta']: 
+          metadata_name, embeded_digest = \
+            _strip_consistent_snapshot_digest(metadata_name, consistent_snapshot)
+        
         # Strip filename extensions.  The role database does not include the
         # metadata extension.
+        metadata_name_extension = metadata_name
         for metadata_extension in METADATA_EXTENSIONS: 
           if metadata_name.endswith(metadata_extension):
-            metadata_name_without_extension = \
-              metadata_name[:-len(metadata_extension)]
+            metadata_name = metadata_name[:-len(metadata_extension)]
         
         # Delete the metadata file if it does not exist in 'tuf.roledb'.
-        # repository_tool.py might have marked 'metadata_name' as removed, but its
-        # metadata file is not actually deleted yet.  Do it now.
-        if not tuf.roledb.role_exists(metadata_name_without_extension):
+        # 'repository_tool.py' might have marked 'metadata_name' as removed, but
+        # its metadata file is not actually deleted yet.  Do it now.
+        if not tuf.roledb.role_exists(metadata_name):
           logger.info('Removing outdated metadata: ' + repr(metadata_path))
           os.remove(metadata_path)
 
         # Delete outdated consistent snapshots.  snapshot metadata includes
         # the file extension of roles.
-        if consistent_snapshot:
-          #metadata_name_extension = metadata_name + METADATA_EXTENSION 
-          file_hashes = snapshot_metadata['meta'][metadata_name] \
+        if consistent_snapshot and embeded_digest is not None:
+          file_hashes = snapshot_metadata['meta'][metadata_name_extension] \
                                         ['hashes'].values()
           if embeded_digest not in file_hashes:
             logger.info('Removing outdated metadata: ' + repr(metadata_path))