manifest: Include tag in from_list() calls

2 files changed, 102 insertions, 93 deletions

diff --git a/gemato/manifest.py b/gemato/manifest.py
index e5b6a81..195a4aa 100644
--- a/gemato/manifest.py
+++ b/gemato/manifest.py
@@ -23,14 +23,14 @@ class ManifestEntryTIMESTAMP(object):
 
     @classmethod
     def from_list(cls, l):
-        if len(l) != 1:
+        if len(l) != 2:
             raise ManifestSyntaxError(
-                    'TIMESTAMP line: expects 1 value, got: {}'.format(l))
+                    '{} line: expects 1 value, got: {}'.format(l[0], l[1:]))
         try:
-            ts = datetime.datetime.strptime(l[0], '%Y-%m-%dT%H:%M:%SZ')
+            ts = datetime.datetime.strptime(l[1], '%Y-%m-%dT%H:%M:%SZ')
         except ValueError:
             raise ManifestSyntaxError(
-                    'TIMESTAMP line: expected ISO8601 timestamp, got: {}'.format(l[0]))
+                    '{} line: expected ISO8601 timestamp, got: {}'.format(l[0], l[1:]))
         return cls(ts)
 
 
@@ -44,14 +44,14 @@ class ManifestPathEntry(object):
         self.path = path
 
     @staticmethod
-    def process_path(tag, l):
-        if len(l) != 1:
+    def process_path(l):
+        if len(l) != 2:
             raise ManifestSyntaxError(
-                    '{} line: expects 1 value, got: {}'.format(tag, l))
-        if not l[0] or l[0][0] == '/':
+                    '{} line: expects 1 value, got: {}'.format(l[0], l[1:]))
+        if not l[1] or l[1][0] == '/':
             raise ManifestSyntaxError(
-                    '{} line: expected relative path, got: {}'.format(tag, l[0]))
-        return l[0]
+                    '{} line: expected relative path, got: {}'.format(l[0], l[1:]))
+        return l[1]
 
 
 class ManifestEntryIGNORE(ManifestPathEntry):
@@ -61,7 +61,7 @@ class ManifestEntryIGNORE(ManifestPathEntry):
 
     @classmethod
     def from_list(cls, l):
-        return cls(cls.process_path('IGNORE', l))
+        return cls(cls.process_path(l))
 
 
 class ManifestEntryOPTIONAL(ManifestPathEntry):
@@ -76,7 +76,7 @@ class ManifestEntryOPTIONAL(ManifestPathEntry):
 
     @classmethod
     def from_list(cls, l):
-        return cls(cls.process_path('OPTIONAL', l))
+        return cls(cls.process_path(l))
 
 
 class ManifestFileEntry(ManifestPathEntry):
@@ -90,21 +90,21 @@ class ManifestFileEntry(ManifestPathEntry):
         self.checksums = checksums
 
     @staticmethod
-    def process_checksums(tag, l):
-        if len(l) < 2:
+    def process_checksums(l):
+        if len(l) < 3:
             raise ManifestSyntaxError(
-                    '{} line: expects at least 2 values, got: {}'.format(tag, l))
+                    '{} line: expects at least 2 values, got: {}'.format(l[0], l[1:]))
 
         try:
-            size = int(l[1])
+            size = int(l[2])
             if size < 0:
                 raise ValueError()
         except ValueError:
             raise ManifestSyntaxError(
-                    '{} line: size must be a non-negative integer, got: {}'.format(tag, l[1]))
+                    '{} line: size must be a non-negative integer, got: {}'.format(l[0], l[2]))
 
         checksums = {}
-        it = iter(l[2:])
+        it = iter(l[3:])
         while True:
             try:
                 ckname = next(it)
@@ -114,7 +114,7 @@ class ManifestFileEntry(ManifestPathEntry):
                 ckval = next(it)
             except StopIteration:
                 raise ManifestSyntaxError(
-                        '{} line: checksum {} has no value'.format(tag, ckname))
+                        '{} line: checksum {} has no value'.format(l[0], ckname))
             checksums[ckname] = ckval
 
         return size, checksums
@@ -127,8 +127,8 @@ class ManifestEntryMANIFEST(ManifestFileEntry):
 
     @classmethod
     def from_list(cls, l):
-        path = cls.process_path('MANIFEST', l[:1])
-        size, checksums = cls.process_checksums('MANIFEST', l)
+        path = cls.process_path(l[:2])
+        size, checksums = cls.process_checksums(l)
         return cls(path, size, checksums)
 
 
@@ -139,8 +139,8 @@ class ManifestEntryDATA(ManifestFileEntry):
 
     @classmethod
     def from_list(cls, l):
-        path = cls.process_path('DATA', l[:1])
-        size, checksums = cls.process_checksums('DATA', l)
+        path = cls.process_path(l[:2])
+        size, checksums = cls.process_checksums(l)
         return cls(path, size, checksums)
 
 
@@ -151,8 +151,8 @@ class ManifestEntryMISC(ManifestFileEntry):
 
     @classmethod
     def from_list(cls, l):
-        path = cls.process_path('MISC', l[:1])
-        size, checksums = cls.process_checksums('MISC', l)
+        path = cls.process_path(l[:2])
+        size, checksums = cls.process_checksums(l)
         return cls(path, size, checksums)
 
 
@@ -163,11 +163,11 @@ class ManifestEntryDIST(ManifestFileEntry):
 
     @classmethod
     def from_list(cls, l):
-        path = cls.process_path('DIST', l[:1])
+        path = cls.process_path(l[:2])
         if '/' in path:
             raise ManifestSyntaxError(
                     'DIST line: file name expected, got directory path: {}'.format(path))
-        size, checksums = cls.process_checksums('DIST', l)
+        size, checksums = cls.process_checksums(l)
         return cls(path, size, checksums)
 
 
@@ -178,8 +178,8 @@ class ManifestEntryEBUILD(ManifestFileEntry):
 
     @classmethod
     def from_list(cls, l):
-        path = cls.process_path('EBUILD', l[:1])
-        size, checksums = cls.process_checksums('EBUILD', l)
+        path = cls.process_path(l[:2])
+        size, checksums = cls.process_checksums(l)
         return cls(path, size, checksums)
 
 
@@ -195,8 +195,8 @@ class ManifestEntryAUX(ManifestFileEntry):
 
     @classmethod
     def from_list(cls, l):
-        path = cls.process_path('AUX', l[:1])
-        size, checksums = cls.process_checksums('AUX', l)
+        path = cls.process_path(l[:2])
+        size, checksums = cls.process_checksums(l)
         return cls(path, size, checksums)
 
 
@@ -238,7 +238,7 @@ class ManifestFile(object):
             # skip empty lines
             if not sl:
                 continue
-            tag = sl.pop(0)
+            tag = sl[0]
             MANIFEST_TAG_MAPPING[tag].from_list(sl)
 
 
diff --git a/tests/test_manifest.py b/tests/test_manifest.py
index ef95e22..aee5eba 100644
--- a/tests/test_manifest.py
+++ b/tests/test_manifest.py
@@ -55,49 +55,58 @@ class ManifestEntryTest(unittest.TestCase):
     }
 
     def test_TIMESTAMP(self):
-        self.assertEqual(gemato.manifest.ManifestEntryTIMESTAMP.from_list(('2010-01-01T11:12:13Z',)).ts,
+        self.assertEqual(gemato.manifest.ManifestEntryTIMESTAMP.from_list(
+                    ('TIMESTAMP', '2010-01-01T11:12:13Z')).ts,
                 datetime.datetime(2010, 1, 1, 11, 12, 13))
 
     def test_MANIFEST(self):
-        m = gemato.manifest.ManifestEntryMANIFEST.from_list(self.file_vals)
+        m = gemato.manifest.ManifestEntryMANIFEST.from_list(
+                ('MANIFEST',) + self.file_vals)
         self.assertEqual(m.path, 'test')
         self.assertEqual(m.size, 0)
         self.assertDictEqual(m.checksums, self.exp_cksums)
 
     def test_IGNORE(self):
-        self.assertEqual(gemato.manifest.ManifestEntryIGNORE.from_list(('test',)).path,
+        self.assertEqual(gemato.manifest.ManifestEntryIGNORE.from_list(
+                    ('IGNORE', 'test')).path,
                 'test')
 
     def test_DATA(self):
-        m = gemato.manifest.ManifestEntryDATA.from_list(self.file_vals)
+        m = gemato.manifest.ManifestEntryDATA.from_list(
+                ('DATA',) + self.file_vals)
         self.assertEqual(m.path, 'test')
         self.assertEqual(m.size, 0)
         self.assertDictEqual(m.checksums, self.exp_cksums)
 
     def test_MISC(self):
-        m = gemato.manifest.ManifestEntryMISC.from_list(self.file_vals)
+        m = gemato.manifest.ManifestEntryMISC.from_list(
+                ('MISC',) + self.file_vals)
         self.assertEqual(m.path, 'test')
         self.assertEqual(m.size, 0)
         self.assertDictEqual(m.checksums, self.exp_cksums)
 
     def test_OPTIONAL(self):
-        self.assertEqual(gemato.manifest.ManifestEntryOPTIONAL.from_list(('test',)).path,
+        self.assertEqual(gemato.manifest.ManifestEntryOPTIONAL.from_list(
+                    ('OPTIONAL', 'test')).path,
                 'test')
 
     def test_DIST(self):
-        m = gemato.manifest.ManifestEntryDIST.from_list(self.file_vals)
+        m = gemato.manifest.ManifestEntryDIST.from_list(
+                ('DIST',) + self.file_vals)
         self.assertEqual(m.path, 'test')
         self.assertEqual(m.size, 0)
         self.assertDictEqual(m.checksums, self.exp_cksums)
 
     def test_EBUILD(self):
-        m = gemato.manifest.ManifestEntryEBUILD.from_list(self.file_vals)
+        m = gemato.manifest.ManifestEntryEBUILD.from_list(
+                ('EBUILD',) + self.file_vals)
         self.assertEqual(m.path, 'test')
         self.assertEqual(m.size, 0)
         self.assertDictEqual(m.checksums, self.exp_cksums)
 
     def test_AUX(self):
-        m = gemato.manifest.ManifestEntryAUX.from_list(self.file_vals)
+        m = gemato.manifest.ManifestEntryAUX.from_list(
+                ('AUX',) + self.file_vals)
         self.assertEqual(m.aux_path, 'test')
         self.assertEqual(m.path, 'files/test')
         self.assertEqual(m.size, 0)
@@ -105,118 +114,118 @@ class ManifestEntryTest(unittest.TestCase):
 
     def test_timestamp_invalid(self):
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('',))
+                gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('TIMESTAMP', '',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('2017-10-22T18:06:41+02:00',))
+                gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('TIMESTAMP', '2017-10-22T18:06:41+02:00',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('2017-10-22T18:06:41',))
+                gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('TIMESTAMP', '2017-10-22T18:06:41',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('2017-10-22 18:06:41Z',))
+                gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('TIMESTAMP', '2017-10-22 18:06:41Z',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('20171022T180641Z',))
+                gemato.manifest.ManifestEntryTIMESTAMP.from_list, ('TIMESTAMP', '20171022T180641Z',))
 
     def test_path_invalid(self):
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryMANIFEST.from_list, ('', '0'))
+                gemato.manifest.ManifestEntryMANIFEST.from_list, ('MANIFEST', '', '0'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryMANIFEST.from_list, ('/foo', '0'))
+                gemato.manifest.ManifestEntryMANIFEST.from_list, ('MANIFEST', '/foo', '0'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryIGNORE.from_list, ('',))
+                gemato.manifest.ManifestEntryIGNORE.from_list, ('IGNORE', '',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryIGNORE.from_list, ('/foo',))
+                gemato.manifest.ManifestEntryIGNORE.from_list, ('IGNORE', '/foo',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryOPTIONAL.from_list, ('',))
+                gemato.manifest.ManifestEntryOPTIONAL.from_list, ('OPTIONAL', '',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryOPTIONAL.from_list, ('/foo',))
+                gemato.manifest.ManifestEntryOPTIONAL.from_list, ('OPTIONAL', '/foo',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryDATA.from_list, ('',))
+                gemato.manifest.ManifestEntryDATA.from_list, ('DATA', '',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryDATA.from_list, ('/foo',))
+                gemato.manifest.ManifestEntryDATA.from_list, ('DATA', '/foo',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryMISC.from_list, ('',))
+                gemato.manifest.ManifestEntryMISC.from_list, ('MISC', '',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryMISC.from_list, ('/foo',))
+                gemato.manifest.ManifestEntryMISC.from_list, ('MISC', '/foo',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryDIST.from_list, ('',))
+                gemato.manifest.ManifestEntryDIST.from_list, ('DIST', '',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryDIST.from_list, ('/foo',))
+                gemato.manifest.ManifestEntryDIST.from_list, ('DIST', '/foo',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryDIST.from_list, ('foo/bar.gz',))
+                gemato.manifest.ManifestEntryDIST.from_list, ('DIST', 'foo/bar.gz',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryEBUILD.from_list, ('',))
+                gemato.manifest.ManifestEntryEBUILD.from_list, ('EBUILD', '',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryEBUILD.from_list, ('/foo',))
+                gemato.manifest.ManifestEntryEBUILD.from_list, ('EBUILD', '/foo',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryAUX.from_list, ('',))
+                gemato.manifest.ManifestEntryAUX.from_list, ('AUX', '',))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryAUX.from_list, ('/foo',))
+                gemato.manifest.ManifestEntryAUX.from_list, ('AUX', '/foo',))
 
     def test_size_invalid(self):
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryMANIFEST.from_list, ('foo', 'asdf'))
+                gemato.manifest.ManifestEntryMANIFEST.from_list, ('MANIFEST', 'foo', 'asdf'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryMANIFEST.from_list, ('foo', '5ds'))
+                gemato.manifest.ManifestEntryMANIFEST.from_list, ('MANIFEST', 'foo', '5ds'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryMANIFEST.from_list, ('foo', '-5'))
+                gemato.manifest.ManifestEntryMANIFEST.from_list, ('MANIFEST', 'foo', '-5'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryDATA.from_list, ('foo', 'asdf'))
+                gemato.manifest.ManifestEntryDATA.from_list, ('DATA', 'foo', 'asdf'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryDATA.from_list, ('foo', '5ds'))
+                gemato.manifest.ManifestEntryDATA.from_list, ('DATA', 'foo', '5ds'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryDATA.from_list, ('foo', '-5'))
+                gemato.manifest.ManifestEntryDATA.from_list, ('DATA', 'foo', '-5'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryMISC.from_list, ('foo', 'asdf'))
+                gemato.manifest.ManifestEntryMISC.from_list, ('MISC', 'foo', 'asdf'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryMISC.from_list, ('foo', '5ds'))
+                gemato.manifest.ManifestEntryMISC.from_list, ('MISC', 'foo', '5ds'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryMISC.from_list, ('foo', '-5'))
+                gemato.manifest.ManifestEntryMISC.from_list, ('MISC', 'foo', '-5'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryDIST.from_list, ('foo', 'asdf'))
+                gemato.manifest.ManifestEntryDIST.from_list, ('DIST', 'foo', 'asdf'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryDIST.from_list, ('foo', '5ds'))
+                gemato.manifest.ManifestEntryDIST.from_list, ('DIST', 'foo', '5ds'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryDIST.from_list, ('foo', '-5'))
+                gemato.manifest.ManifestEntryDIST.from_list, ('DIST', 'foo', '-5'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryEBUILD.from_list, ('foo', 'asdf'))
+                gemato.manifest.ManifestEntryEBUILD.from_list, ('EBUILD', 'foo', 'asdf'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryEBUILD.from_list, ('foo', '5ds'))
+                gemato.manifest.ManifestEntryEBUILD.from_list, ('EBUILD', 'foo', '5ds'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryEBUILD.from_list, ('foo', '-5'))
+                gemato.manifest.ManifestEntryEBUILD.from_list, ('EBUILD', 'foo', '-5'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryAUX.from_list, ('foo', 'asdf'))
+                gemato.manifest.ManifestEntryAUX.from_list, ('AUX', 'foo', 'asdf'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryAUX.from_list, ('foo', '5ds'))
+                gemato.manifest.ManifestEntryAUX.from_list, ('AUX', 'foo', '5ds'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryAUX.from_list, ('foo', '-5'))
+                gemato.manifest.ManifestEntryAUX.from_list, ('AUX', 'foo', '-5'))
 
     def test_checksum_short(self):
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryMANIFEST.from_list, ('foo', '0', 'md5'))
+                gemato.manifest.ManifestEntryMANIFEST.from_list, ('MANIFEST', 'foo', '0', 'md5'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMANIFEST.from_list,
-                ('foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
+                ('MANIFEST', 'foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryDATA.from_list, ('foo', '0', 'md5'))
+                gemato.manifest.ManifestEntryDATA.from_list, ('DATA', 'foo', '0', 'md5'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDATA.from_list,
-                ('foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
+                ('DATA', 'foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryMISC.from_list, ('foo', '0', 'md5'))
+                gemato.manifest.ManifestEntryMISC.from_list, ('MISC', 'foo', '0', 'md5'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryMISC.from_list,
-                ('foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
+                ('MISC', 'foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryDIST.from_list, ('foo', '0', 'md5'))
+                gemato.manifest.ManifestEntryDIST.from_list, ('DIST', 'foo', '0', 'md5'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryDIST.from_list,
-                ('foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
+                ('DIST', 'foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryEBUILD.from_list, ('foo', '0', 'md5'))
+                gemato.manifest.ManifestEntryEBUILD.from_list, ('EBUILD', 'foo', '0', 'md5'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryEBUILD.from_list,
-                ('foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
+                ('EBUILD', 'foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
-                gemato.manifest.ManifestEntryAUX.from_list, ('foo', '0', 'md5'))
+                gemato.manifest.ManifestEntryAUX.from_list, ('AUX', 'foo', '0', 'md5'))
         self.assertRaises(gemato.manifest.ManifestSyntaxError,
                 gemato.manifest.ManifestEntryAUX.from_list,
-                ('foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))
+                ('AUX', 'foo', '0', 'md5', 'd41d8cd98f00b204e9800998ecf8427e', 'sha1'))