Move exceptions to a separate module

4 files changed, 107 insertions, 103 deletions

diff --git a/tests/test_hash.py b/tests/test_hash.py
index d4dc3c1..900ccd7 100644
--- a/tests/test_hash.py
+++ b/tests/test_hash.py
@@ -7,6 +7,7 @@ import io
 import tempfile
 import unittest
 
+import gemato.exceptions
 import gemato.hash
 
 
@@ -23,15 +24,15 @@ class HashAPITest(unittest.TestCase):
         gemato.hash.get_hash_by_name('sha1')
 
     def test_get_invalid(self):
-        self.assertRaises(gemato.hash.UnsupportedHash,
+        self.assertRaises(gemato.exceptions.UnsupportedHash,
                 gemato.hash.get_hash_by_name, '_invalid_name_')
 
     def test_get_invalid_pyblake2(self):
-        self.assertRaises(gemato.hash.UnsupportedHash,
+        self.assertRaises(gemato.exceptions.UnsupportedHash,
                 gemato.hash.get_hash_by_name, 'blake2zzz')
 
     def test_get_invalid_pysha3(self):
-        self.assertRaises(gemato.hash.UnsupportedHash,
+        self.assertRaises(gemato.exceptions.UnsupportedHash,
                 gemato.hash.get_hash_by_name, 'sha3_987')
 
     def test_hash_file(self):
@@ -142,126 +143,126 @@ class OptionalHashTest(unittest.TestCase):
         try:
             self.assertEqual(gemato.hash.hash_bytes(TEST_STRING, 'md4'),
                     '1bee69a46ba811185c194762abaeae90')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_md4_empty(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(b'', 'md4'),
                     '31d6cfe0d16ae931b73c59d7e0c089c0')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_ripemd160(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(TEST_STRING, 'ripemd160'),
                     '37f332f68db77bd9d7edd4969571ad671cf9dd3b')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_ripemd160_empty(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(b'', 'ripemd160'),
                     '9c1185a5c5e9fc54612808977ee8f548b2258d31')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_blake2b(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(TEST_STRING, 'blake2b'),
                     'a8add4bdddfd93e4877d2746e62817b116364a1fa7bc148d95090bc7333b3673f82401cf7aa2e4cb1ecd90296e3f14cb5413f8ed77be73045b13914cdcd6a918')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_blake2b_empty(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(b'', 'blake2b'),
                     '786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_blake2s(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(TEST_STRING, 'blake2s'),
                     '606beeec743ccbeff6cbcdf5d5302aa855c256c29b88c8ed331ea1a6bf3c8812')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_blake2s_empty(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(b'', 'blake2s'),
                     '69217a3079908094e11121d042354a7c1f55b6482ca1a51e1b250dfd1ed0eef9')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_sha3_224(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(TEST_STRING, 'sha3_224'),
                     'd15dadceaa4d5d7bb3b48f446421d542e08ad8887305e28d58335795')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_sha3_224_empty(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(b'', 'sha3_224'),
                     '6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_sha3_256(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(TEST_STRING, 'sha3_256'),
                     '69070dda01975c8c120c3aada1b282394e7f032fa9cf32f4cb2259a0897dfc04')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_sha3_256_empty(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(b'', 'sha3_256'),
                     'a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_sha3_384(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(TEST_STRING, 'sha3_384'),
                     '7063465e08a93bce31cd89d2e3ca8f602498696e253592ed26f07bf7e703cf328581e1471a7ba7ab119b1a9ebdf8be41')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_sha3_384_empty(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(b'', 'sha3_384'),
                     '0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_sha3_512(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(TEST_STRING, 'sha3_512'),
                     '01dedd5de4ef14642445ba5f5b97c15e47b9ad931326e4b0727cd94cefc44fff23f07bf543139939b49128caf436dc1bdee54fcb24023a08d9403f9b4bf0d450')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_sha3_512_empty(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(b'', 'sha3_512'),
                     'a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_whirlpool(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(TEST_STRING, 'whirlpool'),
                     'b97de512e91e3828b40d2b0fdce9ceb3c4a71f9bea8d88e75c4fa854df36725fd2b52eb6544edcacd6f8beddfea403cb55ae31f03ad62a5ef54e42ee82c3fb35')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
     def test_whirlpool_empty(self):
         try:
             self.assertEqual(gemato.hash.hash_bytes(b'', 'whirlpool'),
                     '19fa61d75522a4669b44e39c1d2e1726c530232130d407f89afee0964997f7a73e83be698b288febcf88e3e03c4f0757ea8964e59b63d93708b138cc42a66eb3')
-        except gemato.hash.UnsupportedHash:
+        except gemato.exceptions.UnsupportedHash:
             raise unittest.SkipTest('hash not supported')
 
 
diff --git a/tests/test_manifest.py b/tests/test_manifest.py
index 8729eb9..fbf74e5 100644
--- a/tests/test_manifest.py
+++ b/tests/test_manifest.py
@@ -7,6 +7,7 @@ import datetime
 import io
 import unittest
 
+import gemato.exceptions
 import gemato.manifest
 
 
@@ -189,157 +190,157 @@ class ManifestEntryTest(unittest.TestCase):
                 ['AUX'] + list(self.file_vals))
 
     def test_timestamp_invalid(self):
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('TIMESTAMP',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('TIMESTAMP', ''))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('TIMESTAMP', '2017-10-22T18:06:41+02:00'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('TIMESTAMP', '2017-10-22T18:06:41'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('TIMESTAMP', '2017-10-22', '18:06:41Z'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('TIMESTAMP', '20171022T180641Z'))
 
     def test_path_invalid(self):
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMANIFEST.from_list, ('MANIFEST', '', '0'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMANIFEST.from_list, ('MANIFEST', '/foo', '0'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryIGNORE.from_list, ('IGNORE', '',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryIGNORE.from_list, ('IGNORE', '/foo',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryOPTIONAL.from_list, ('OPTIONAL', '',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryOPTIONAL.from_list, ('OPTIONAL', '/foo',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDATA.from_list, ('DATA', '',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDATA.from_list, ('DATA', '/foo',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMISC.from_list, ('MISC', '',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMISC.from_list, ('MISC', '/foo',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDIST.from_list, ('DIST', '',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDIST.from_list, ('DIST', '/foo',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDIST.from_list, ('DIST', 'foo/bar.gz',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryEBUILD.from_list, ('EBUILD', '',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryEBUILD.from_list, ('EBUILD', '/foo',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryAUX.from_list, ('AUX', '',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryAUX.from_list, ('AUX', '/foo',))
 
     def test_size_invalid(self):
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMANIFEST.from_list, ('MANIFEST', 'foo', 'asdf'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMANIFEST.from_list, ('MANIFEST', 'foo', '5ds'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMANIFEST.from_list, ('MANIFEST', 'foo', '-5'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDATA.from_list, ('DATA', 'foo', 'asdf'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDATA.from_list, ('DATA', 'foo', '5ds'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDATA.from_list, ('DATA', 'foo', '-5'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMISC.from_list, ('MISC', 'foo', 'asdf'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMISC.from_list, ('MISC', 'foo', '5ds'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMISC.from_list, ('MISC', 'foo', '-5'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDIST.from_list, ('DIST', 'foo', 'asdf'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDIST.from_list, ('DIST', 'foo', '5ds'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDIST.from_list, ('DIST', 'foo', '-5'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryEBUILD.from_list, ('EBUILD', 'foo', 'asdf'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryEBUILD.from_list, ('EBUILD', 'foo', '5ds'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryEBUILD.from_list, ('EBUILD', 'foo', '-5'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryAUX.from_list, ('AUX', 'foo', 'asdf'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryAUX.from_list, ('AUX', 'foo', '5ds'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryAUX.from_list, ('AUX', 'foo', '-5'))
 
     def test_checksum_short(self):
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMANIFEST.from_list, ('MANIFEST', 'foo', '0', 'md5'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMANIFEST.from_list,
                 ('MANIFEST', 'foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDATA.from_list, ('DATA', 'foo', '0', 'md5'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDATA.from_list,
                 ('DATA', 'foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMISC.from_list, ('MISC', 'foo', '0', 'md5'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMISC.from_list,
                 ('MISC', 'foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDIST.from_list, ('DIST', 'foo', '0', 'md5'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDIST.from_list,
                 ('DIST', 'foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryEBUILD.from_list, ('EBUILD', 'foo', '0', 'md5'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryEBUILD.from_list,
                 ('EBUILD', 'foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryAUX.from_list, ('AUX', 'foo', '0', 'md5'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryAUX.from_list,
                 ('AUX', 'foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
 
     def test_invalid_value_count(self):
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMANIFEST.from_list, ('MANIFEST',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMANIFEST.from_list, ('MANIFEST', 'foo'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryIGNORE.from_list, ('IGNORE',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryIGNORE.from_list, ('IGNORE', 'foo', 'bar'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDATA.from_list, ('DATA',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDATA.from_list, ('DATA', 'foo'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMISC.from_list, ('MISC',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMISC.from_list, ('MISC', 'foo'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryOPTIONAL.from_list, ('OPTIONAL',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryOPTIONAL.from_list, ('OPTIONAL', 'foo', 'bar'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDIST.from_list, ('DIST',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDIST.from_list, ('DIST', 'foo'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryEBUILD.from_list, ('EBUILD',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryEBUILD.from_list, ('EBUILD', 'foo'))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryAUX.from_list, ('AUX',))
-        self.assertRaises(gemato.manifest.ManifestSyntaxError,
+        self.assertRaises(gemato.exceptions.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryAUX.from_list, ('AUX', 'foo'))
 
 
diff --git a/tests/test_recursiveloader.py b/tests/test_recursiveloader.py
index 8257691..c16e7ff 100644
--- a/tests/test_recursiveloader.py
+++ b/tests/test_recursiveloader.py
@@ -9,6 +9,7 @@ import os
 import tempfile
 import unittest
 
+import gemato.exceptions
 import gemato.recursiveloader
 
 
@@ -177,7 +178,7 @@ DATA test 0 MD5 d41d8cd98f00b204e9800998ecf8427e
     def test_assert_path_verifies_stray_path(self):
         m = gemato.recursiveloader.ManifestRecursiveLoader(
             os.path.join(self.dir, 'Manifest'))
-        self.assertRaises(gemato.verify.ManifestMismatch,
+        self.assertRaises(gemato.exceptions.ManifestMismatch,
                 m.assert_path_verifies, 'sub/stray')
 
     def test_get_file_entry_dict(self):
@@ -227,7 +228,7 @@ DATA test 0 MD5 d41d8cd98f00b204e9800998ecf8427e
     def test_assert_directory_verifies_stray_file(self):
         m = gemato.recursiveloader.ManifestRecursiveLoader(
             os.path.join(self.dir, 'Manifest'))
-        self.assertRaises(gemato.verify.ManifestMismatch,
+        self.assertRaises(gemato.exceptions.ManifestMismatch,
                 m.assert_directory_verifies, 'sub')
 
 
@@ -499,7 +500,7 @@ DATA test 0 SHA1 2fd4e1c67a2d28fced849ee1bb76e7391b93eb12
     def test_assert_directory_verifies(self):
         m = gemato.recursiveloader.ManifestRecursiveLoader(
             os.path.join(self.dir, 'Manifest'))
-        with self.assertRaises(gemato.verify.ManifestMismatch) as cm:
+        with self.assertRaises(gemato.exceptions.ManifestMismatch) as cm:
             m.assert_directory_verifies('')
         self.assertListEqual(cm.exception.diff,
             [
@@ -529,7 +530,7 @@ MISC test.ebuild 0 MD5 d41d8cd98f00b204e9800998ecf8427e
     def test_get_file_entry_dict(self):
         m = gemato.recursiveloader.ManifestRecursiveLoader(
             os.path.join(self.dir, 'Manifest'))
-        self.assertRaises(gemato.recursiveloader.ManifestIncompatibleEntry,
+        self.assertRaises(gemato.exceptions.ManifestIncompatibleEntry,
                 m.get_file_entry_dict, '')
 
 
@@ -554,7 +555,7 @@ OPTIONAL test.ebuild
     def test_get_file_entry_dict(self):
         m = gemato.recursiveloader.ManifestRecursiveLoader(
             os.path.join(self.dir, 'Manifest'))
-        self.assertRaises(gemato.recursiveloader.ManifestIncompatibleEntry,
+        self.assertRaises(gemato.exceptions.ManifestIncompatibleEntry,
                 m.get_file_entry_dict, '')
 
 
@@ -579,7 +580,7 @@ OPTIONAL test.ebuild
     def test_get_file_entry_dict(self):
         m = gemato.recursiveloader.ManifestRecursiveLoader(
             os.path.join(self.dir, 'Manifest'))
-        self.assertRaises(gemato.recursiveloader.ManifestIncompatibleEntry,
+        self.assertRaises(gemato.exceptions.ManifestIncompatibleEntry,
                 m.get_file_entry_dict, '')
 
 
@@ -604,7 +605,7 @@ DATA test.ebuild 32 MD5 d41d8cd98f00b204e9800998ecf8427e
     def test_get_file_entry_dict(self):
         m = gemato.recursiveloader.ManifestRecursiveLoader(
             os.path.join(self.dir, 'Manifest'))
-        self.assertRaises(gemato.recursiveloader.ManifestIncompatibleEntry,
+        self.assertRaises(gemato.exceptions.ManifestIncompatibleEntry,
                 m.get_file_entry_dict, '')
 
 
@@ -629,13 +630,13 @@ DATA test.ebuild 0 MD5 9e107d9d372bb6826bd81d3542a419d6
     def test_get_file_entry_dict(self):
         m = gemato.recursiveloader.ManifestRecursiveLoader(
             os.path.join(self.dir, 'Manifest'))
-        self.assertRaises(gemato.recursiveloader.ManifestIncompatibleEntry,
+        self.assertRaises(gemato.exceptions.ManifestIncompatibleEntry,
                 m.get_file_entry_dict, '')
 
     def test_assert_directory_verifies(self):
         m = gemato.recursiveloader.ManifestRecursiveLoader(
             os.path.join(self.dir, 'Manifest'))
-        self.assertRaises(gemato.recursiveloader.ManifestIncompatibleEntry,
+        self.assertRaises(gemato.exceptions.ManifestIncompatibleEntry,
             m.assert_directory_verifies, '')
 
 
@@ -674,7 +675,7 @@ MISC foo 0 MD5 d41d8cd98f00b204e9800998ecf8427e
     def test_assert_directory_verifies(self):
         m = gemato.recursiveloader.ManifestRecursiveLoader(
             os.path.join(self.dir, 'Manifest'))
-        self.assertRaises(gemato.verify.ManifestMismatch,
+        self.assertRaises(gemato.exceptions.ManifestMismatch,
                 m.assert_directory_verifies, '')
 
     def test_assert_directory_verifies_nonstrict(self):
@@ -698,7 +699,7 @@ OPTIONAL foo
     def test_assert_directory_verifies(self):
         m = gemato.recursiveloader.ManifestRecursiveLoader(
             os.path.join(self.dir, 'Manifest'))
-        self.assertRaises(gemato.verify.ManifestMismatch,
+        self.assertRaises(gemato.exceptions.ManifestMismatch,
                 m.assert_directory_verifies, '')
 
     def test_assert_directory_verifies_nonstrict(self):
diff --git a/tests/test_verify.py b/tests/test_verify.py
index ccb3330..4902ec8 100644
--- a/tests/test_verify.py
+++ b/tests/test_verify.py
@@ -9,6 +9,7 @@ import socket
 import tempfile
 import unittest
 
+import gemato.exceptions
 import gemato.manifest
 import gemato.verify
 
@@ -496,11 +497,11 @@ class ExceptionVerificationTest(object):
     def testWrongSizeDATA(self):
         e = gemato.manifest.ManifestEntryDATA.from_list(
                 ('DATA', os.path.basename(self.path), '0'))
-        self.assertRaises(gemato.verify.ManifestMismatch,
+        self.assertRaises(gemato.exceptions.ManifestMismatch,
                 gemato.verify.assert_path_verifies, self.path, e)
 
     def testNone(self):
-        self.assertRaises(gemato.verify.ManifestMismatch,
+        self.assertRaises(gemato.exceptions.ManifestMismatch,
                 gemato.verify.gemato.verify.assert_path_verifies, self.path, None)