Don't use mocks to unit-test the ImageMetadata class.

1 files changed, 100 insertions, 282 deletions

diff --git a/test/metadata.py b/test/metadata.py
index 237a510..f7ce119 100644
--- a/test/metadata.py
+++ b/test/metadata.py
@@ -24,8 +24,6 @@
 #
 # ******************************************************************************
 
-import unittest
-
 from pyexiv2.metadata import ImageMetadata
 from pyexiv2.exif import ExifTag
 from pyexiv2.iptc import IptcTag
@@ -33,169 +31,38 @@ from pyexiv2.xmp import XmpTag
 from pyexiv2.utils import FixedOffset, Rational
 
 import datetime
+import os
+import tempfile
+import unittest
 
 
-class _TagMock(object):
-
-    def __init__(self, key, type, value):
-        self.key = key
-        self.type = type
-        self.value = value
-
-    def _getKey(self):
-        return self.key
-
-    def _getType(self):
-        return self.type
-
-    def _getRawValue(self):
-        return self.value
-
-
-class _ExifTagMock(_TagMock):
-
-    def __init__(self, key, type, value, human_value=None):
-        super(_ExifTagMock, self).__init__(key, type, value)
-        self.human_value = human_value
-
-    def _getHumanValue(self):
-        return self.human_value
-
-    def _setRawValue(self, value):
-        pass
-
-
-class _IptcTagMock(_TagMock):
-
-    def _getRawValues(self):
-        return self.value
-
-    def _setRawValues(self, values):
-        pass
-
-
-class _XmpTagMock(_TagMock):
-
-    def __init__(self, key, type, exiv2_type, value):
-        super(_XmpTagMock, self).__init__(key, type, value)
-        self.exiv2_type = exiv2_type
-
-    def _getExiv2Type(self):
-        return self.exiv2_type
-
-    def _getTextValue(self):
-        return self.value
-
-    def _getArrayValue(self):
-        return self.value
-
-    def _setTextValue(self, value):
-        pass
-
-    def _setArrayValue(self, values):
-        pass
-
-
-class ImageMock(object):
-
-    def __init__(self, filename):
-        self.filename = filename
-        self.read = False
-        self.written = False
-        self.tags = {'exif': {}, 'iptc': {}, 'xmp': {}}
-
-    def _readMetadata(self):
-        self.read = True
-
-    def _writeMetadata(self):
-        self.written = True
-
-    def _exifKeys(self):
-        return self.tags['exif'].keys()
-
-    def _getExifTag(self, key):
-        return self.tags['exif'][key]
-
-    def _setExifTagValue(self, key, value):
-        self.tags['exif'][key] = value
-
-    def _deleteExifTag(self, key):
-        try:
-            del self.tags['exif'][key]
-        except KeyError:
-            pass
-
-    def _iptcKeys(self):
-        return self.tags['iptc'].keys()
-
-    def _getIptcTag(self, key):
-        return self.tags['iptc'][key]
-
-    def _setIptcTagValues(self, key, values):
-        self.tags['iptc'][key] = values
-
-    def _deleteIptcTag(self, key):
-        try:
-            del self.tags['iptc'][key]
-        except KeyError:
-            pass
-
-    def _xmpKeys(self):
-        return self.tags['xmp'].keys()
-
-    def _getXmpTag(self, key):
-        return self.tags['xmp'][key]
-
-    def _setXmpTagTextValue(self, key, value):
-        self.tags['xmp'][key] = value
-
-    def _setXmpTagArrayValue(self, key, value):
-        self.tags['xmp'][key] = value
-
-    def _setXmpTagLangAltValue(self, key, value):
-        self.tags['xmp'][key] = value
-
-    def _deleteXmpTag(self, key):
-        try:
-            del self.tags['xmp'][key]
-        except KeyError:
-            pass
-
-    def _copyMetadata(self, other, exif=True, iptc=True, xmp=True):
-        if exif:
-            other.tags['exif'] = self.tags['exif']
-        if iptc:
-            other.tags['iptc'] = self.tags['iptc']
-        if xmp:
-            other.tags['xmp'] = self.tags['xmp']
+EMPTY_PNG_DATA = \
+    '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08' \
+    '\x02\x00\x00\x00\x90wS\xde\x00\x00\x00\x0cIDATx\x9cc```\x00\x00\x00\x04' \
+    '\x00\x01\xf6\x178U\x00\x00\x00\x00IEND\xaeB`\x82'
 
 
 class TestImageMetadata(unittest.TestCase):
 
     def setUp(self):
-        self.metadata = ImageMetadata('nofile')
-        self.metadata._instantiate_image = lambda filename: ImageMock(filename)
-
-    def _set_exif_tags(self):
-        tags = {}
-        tags['Exif.Image.Make'] = _ExifTagMock('Exif.Image.Make', 'Ascii', 'EASTMAN KODAK COMPANY')
-        tags['Exif.Image.DateTime'] = _ExifTagMock('Exif.Image.DateTime', 'Ascii', '2009:02:09 13:33:20')
-        tags['Exif.Photo.ExifVersion'] = _ExifTagMock('Exif.Photo.ExifVersion', 'Undefined', '48 50 50 49 ')
-        self.metadata._image.tags['exif'] = tags
-
-    def _set_iptc_tags(self):
-        tags = {}
-        tags['Iptc.Application2.Caption'] = _IptcTagMock('Iptc.Application2.Caption', 'String', ['blabla'])
-        tags['Iptc.Application2.DateCreated'] = _IptcTagMock('Iptc.Application2.DateCreated', 'Date', ['2004-07-13'])
-        self.metadata._image.tags['iptc'] = tags
-
-    def _set_xmp_tags(self):
-        tags = {}
-        tags['Xmp.dc.format'] = _XmpTagMock('Xmp.dc.format', 'MIMEType', 'XmpText', 'image/jpeg')
-        tags['Xmp.dc.subject'] = _XmpTagMock('Xmp.dc.subject', 'bag Text', 'XmpBag', 'image, test, pyexiv2')
-        tags['Xmp.xmp.CreateDate'] = _XmpTagMock('Xmp.xmp.CreateDate', 'Date', 'XmpText', '2005-09-07T15:07:40-07:00')
-        tags['Xmp.xmpMM.DocumentID'] = _XmpTagMock('Xmp.xmpMM.DocumentID', 'URI', 'XmpText', 'uuid:9A3B7F52214211DAB6308A7391270C13')
-        self.metadata._image.tags['xmp'] = tags
+        # Create an empty image file
+        fd, self.pathname = tempfile.mkstemp(suffix='.png')
+        os.write(fd, EMPTY_PNG_DATA)
+        os.close(fd)
+        # Write some metadata
+        m = ImageMetadata(self.pathname)
+        m.read()
+        m['Exif.Image.Make'] = 'EASTMAN KODAK COMPANY'
+        m['Exif.Image.DateTime'] = datetime.datetime(2009, 2, 9, 13, 33, 20)
+        m['Iptc.Application2.Caption'] = ['blabla']
+        m['Iptc.Application2.DateCreated'] = [datetime.date(2004, 7, 13)]
+        m['Xmp.dc.format'] = ('image', 'jpeg')
+        m['Xmp.dc.subject'] = ['image', 'test', 'pyexiv2']
+        m.write()
+        self.metadata = ImageMetadata(self.pathname)
+
+    def tearDown(self):
+        os.remove(self.pathname)
 
     ######################
     # Test general methods
@@ -205,33 +72,24 @@ class TestImageMetadata(unittest.TestCase):
         self.assertEqual(self.metadata._image, None)
         self.metadata.read()
         self.failIfEqual(self.metadata._image, None)
-        self.failUnless(self.metadata._image.read)
 
     def test_read_nonexistent_file(self):
         metadata = ImageMetadata('idontexist')
         self.failUnlessRaises(IOError, metadata.read)
 
-    def test_write(self):
-        self.metadata.read()
-        self.failIf(self.metadata._image.written)
-        self.metadata.write()
-        self.failUnless(self.metadata._image.written)
-
     ###########################
     # Test EXIF-related methods
     ###########################
 
     def test_exif_keys(self):
         self.metadata.read()
-        self._set_exif_tags()
         self.assertEqual(self.metadata._keys['exif'], None)
         keys = self.metadata.exif_keys
-        self.assertEqual(len(keys), 3)
+        self.assertEqual(len(keys), 2)
         self.assertEqual(self.metadata._keys['exif'], keys)
 
     def test_get_exif_tag(self):
         self.metadata.read()
-        self._set_exif_tags()
         self.assertEqual(self.metadata._tags['exif'], {})
         # Get an existing tag
         key = 'Exif.Image.Make'
@@ -245,7 +103,6 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_set_exif_tag_wrong(self):
         self.metadata.read()
-        self._set_exif_tags()
         self.assertEqual(self.metadata._tags['exif'], {})
         # Try to set a tag with wrong type
         tag = 'Not an exif tag'
@@ -254,7 +111,6 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_set_exif_tag_create(self):
         self.metadata.read()
-        self._set_exif_tags()
         self.assertEqual(self.metadata._tags['exif'], {})
         # Create a new tag
         tag = ExifTag('Exif.Thumbnail.Orientation', 1)
@@ -264,13 +120,12 @@ class TestImageMetadata(unittest.TestCase):
         self.assertEqual(tag.metadata, self.metadata)
         self.assert_(tag.key in self.metadata.exif_keys)
         self.assertEqual(self.metadata._tags['exif'], {tag.key: tag})
-        self.assert_(self.metadata._image.tags['exif'].has_key(tag.key))
-        self.assertEqual(self.metadata._image.tags['exif'][tag.key],
+        self.assert_(tag.key in self.metadata._image._exifKeys())
+        self.assertEqual(self.metadata._image._getExifTag(tag.key)._getRawValue(),
                          tag.raw_value)
 
     def test_set_exif_tag_overwrite(self):
         self.metadata.read()
-        self._set_exif_tags()
         self.assertEqual(self.metadata._tags['exif'], {})
         # Overwrite an existing tag
         tag = ExifTag('Exif.Image.DateTime', datetime.datetime(2009, 3, 20, 20, 32, 0))
@@ -278,47 +133,44 @@ class TestImageMetadata(unittest.TestCase):
         self.metadata._set_exif_tag(tag.key, tag)
         self.assertEqual(tag.metadata, self.metadata)
         self.assertEqual(self.metadata._tags['exif'], {tag.key: tag})
-        self.assert_(self.metadata._image.tags['exif'].has_key(tag.key))
-        self.assertEqual(self.metadata._image.tags['exif'][tag.key],
+        self.assert_(tag.key in self.metadata._image._exifKeys())
+        self.assertEqual(self.metadata._image._getExifTag(tag.key)._getRawValue(),
                          tag.raw_value)
 
     def test_set_exif_tag_overwrite_already_cached(self):
         self.metadata.read()
-        self._set_exif_tags()
         self.assertEqual(self.metadata._tags['exif'], {})
         # Overwrite an existing tag already cached
-        key = 'Exif.Photo.ExifVersion'
+        key = 'Exif.Image.Make'
         tag = self.metadata._get_exif_tag(key)
         self.assertEqual(self.metadata._tags['exif'][key], tag)
-        new_tag = ExifTag(key, '48 50 50 48 ', _tag=_ExifTagMock(key, 'Undefined', '48 50 50 48 ', '2.20'))
+        new_tag = ExifTag(key, 'World Company')
         self.assertEqual(new_tag.metadata, None)
         self.metadata._set_exif_tag(key, new_tag)
         self.assertEqual(new_tag.metadata, self.metadata)
         self.assertEqual(self.metadata._tags['exif'], {key: new_tag})
-        self.assert_(self.metadata._image.tags['exif'].has_key(key))
-        # Special case where the formatted value is used instead of the raw
-        # value.
-        self.assertEqual(self.metadata._image.tags['exif'][key], new_tag.raw_value)
+        self.assert_(key in self.metadata._image._exifKeys())
+        self.assertEqual(self.metadata._image._getExifTag(key)._getRawValue(),
+                         new_tag.raw_value)
 
     def test_set_exif_tag_direct_value_assignment(self):
         self.metadata.read()
-        self._set_exif_tags()
         self.assertEqual(self.metadata._tags['exif'], {})
         # Direct value assignment: pass a value instead of a fully-formed tag
         key = 'Exif.Thumbnail.Orientation'
         value = 1
         self.metadata._set_exif_tag(key, value)
         self.assert_(key in self.metadata.exif_keys)
-        self.assert_(self.metadata._image.tags['exif'].has_key(key))
+        self.assert_(key in self.metadata._image._exifKeys())
         tag = self.metadata._get_exif_tag(key)
         self.assertEqual(tag.value, value)
         self.assertEqual(tag.metadata, self.metadata)
         self.assertEqual(self.metadata._tags['exif'], {key: tag})
-        self.assertEqual(self.metadata._image.tags['exif'][key], tag.raw_value)
+        self.assertEqual(self.metadata._image._getExifTag(key)._getRawValue(),
+                         tag.raw_value)
 
     def test_set_exif_tag_value_inexistent(self):
         self.metadata.read()
-        self._set_exif_tags()
         key = 'Exif.Photo.ExposureTime'
         value = '1/500'
         self.failUnlessRaises(KeyError, self.metadata._set_exif_tag_value,
@@ -326,7 +178,6 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_set_exif_tag_value_wrong_type(self):
         self.metadata.read()
-        self._set_exif_tags()
         key = 'Exif.Image.DateTime'
         value = datetime.datetime(2009, 3, 24, 9, 37, 36)
         self.failUnlessRaises(TypeError, self.metadata._set_exif_tag_value,
@@ -334,40 +185,36 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_set_exif_tag_value(self):
         self.metadata.read()
-        self._set_exif_tags()
         key = 'Exif.Image.DateTime'
         tag = self.metadata._get_exif_tag(key)
         value = '2009:03:24 09:37:36'
-        self.failIfEqual(self.metadata._image.tags['exif'][key], value)
+        self.failIfEqual(self.metadata._image._getExifTag(key)._getRawValue(), value)
         self.metadata._set_exif_tag_value(key, value)
-        self.assertEqual(self.metadata._image.tags['exif'][key], value)
+        self.assertEqual(self.metadata._image._getExifTag(key)._getRawValue(), value)
 
     def test_delete_exif_tag_inexistent(self):
         self.metadata.read()
-        self._set_exif_tags()
         key = 'Exif.Image.Artist'
         self.failUnlessRaises(KeyError, self.metadata._delete_exif_tag, key)
 
     def test_delete_exif_tag_not_cached(self):
         self.metadata.read()
-        self._set_exif_tags()
         key = 'Exif.Image.DateTime'
         self.assertEqual(self.metadata._tags['exif'], {})
-        self.assert_(self.metadata._image.tags['exif'].has_key(key))
+        self.assert_(key in self.metadata._image._exifKeys())
         self.metadata._delete_exif_tag(key)
         self.assertEqual(self.metadata._tags['exif'], {})
-        self.failIf(self.metadata._image.tags['exif'].has_key(key))
+        self.failIf(key in self.metadata._image._exifKeys())
 
     def test_delete_exif_tag_cached(self):
         self.metadata.read()
-        self._set_exif_tags()
         key = 'Exif.Image.DateTime'
-        self.assert_(self.metadata._image.tags['exif'].has_key(key))
+        self.assert_(key in self.metadata._image._exifKeys())
         tag = self.metadata._get_exif_tag(key)
         self.assertEqual(self.metadata._tags['exif'][key], tag)
         self.metadata._delete_exif_tag(key)
         self.assertEqual(self.metadata._tags['exif'], {})
-        self.failIf(self.metadata._image.tags['exif'].has_key(key))
+        self.failIf(key in self.metadata._image._exifKeys())
 
     ###########################
     # Test IPTC-related methods
@@ -375,7 +222,6 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_iptc_keys(self):
         self.metadata.read()
-        self._set_iptc_tags()
         self.assertEqual(self.metadata._keys['iptc'], None)
         keys = self.metadata.iptc_keys
         self.assertEqual(len(keys), 2)
@@ -383,7 +229,6 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_get_iptc_tag(self):
         self.metadata.read()
-        self._set_iptc_tags()
         self.assertEqual(self.metadata._tags['iptc'], {})
         # Get an existing tag
         key = 'Iptc.Application2.DateCreated'
@@ -397,7 +242,6 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_set_iptc_tag_wrong(self):
         self.metadata.read()
-        self._set_iptc_tags()
         self.assertEqual(self.metadata._tags['iptc'], {})
         # Try to set a tag with wrong type
         tag = 'Not an iptc tag'
@@ -406,7 +250,6 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_set_iptc_tag_create(self):
         self.metadata.read()
-        self._set_iptc_tags()
         self.assertEqual(self.metadata._tags['iptc'], {})
         # Create a new tag
         tag = IptcTag('Iptc.Application2.Writer', ['Nobody'])
@@ -416,13 +259,12 @@ class TestImageMetadata(unittest.TestCase):
         self.assertEqual(tag.metadata, self.metadata)
         self.assert_(tag.key in self.metadata.iptc_keys)
         self.assertEqual(self.metadata._tags['iptc'], {tag.key: tag})
-        self.assert_(self.metadata._image.tags['iptc'].has_key(tag.key))
-        self.assertEqual(self.metadata._image.tags['iptc'][tag.key],
+        self.assert_(tag.key in self.metadata._image._iptcKeys())
+        self.assertEqual(self.metadata._image._getIptcTag(tag.key)._getRawValues(),
                          tag.raw_values)
 
     def test_set_iptc_tag_overwrite(self):
         self.metadata.read()
-        self._set_iptc_tags()
         self.assertEqual(self.metadata._tags['iptc'], {})
         # Overwrite an existing tag
         tag = IptcTag('Iptc.Application2.Caption', ['A picture.'])
@@ -430,13 +272,12 @@ class TestImageMetadata(unittest.TestCase):
         self.metadata._set_iptc_tag(tag.key, tag)
         self.assertEqual(tag.metadata, self.metadata)
         self.assertEqual(self.metadata._tags['iptc'], {tag.key: tag})
-        self.assert_(self.metadata._image.tags['iptc'].has_key(tag.key))
-        self.assertEqual(self.metadata._image.tags['iptc'][tag.key],
+        self.assert_(tag.key in self.metadata._image._iptcKeys())
+        self.assertEqual(self.metadata._image._getIptcTag(tag.key)._getRawValues(),
                          tag.raw_values)
 
     def test_set_iptc_tag_overwrite_already_cached(self):
         self.metadata.read()
-        self._set_iptc_tags()
         self.assertEqual(self.metadata._tags['iptc'], {})
         # Overwrite an existing tag already cached
         key = 'Iptc.Application2.Caption'
@@ -447,29 +288,28 @@ class TestImageMetadata(unittest.TestCase):
         self.metadata._set_iptc_tag(key, new_tag)
         self.assertEqual(new_tag.metadata, self.metadata)
         self.assertEqual(self.metadata._tags['iptc'], {key: new_tag})
-        self.assert_(self.metadata._image.tags['iptc'].has_key(key))
-        self.assertEqual(self.metadata._image.tags['iptc'][key],
+        self.assert_(key in self.metadata._image._iptcKeys())
+        self.assertEqual(self.metadata._image._getIptcTag(key)._getRawValues(),
                          new_tag.raw_values)
 
     def test_set_iptc_tag_direct_value_assignment(self):
         self.metadata.read()
-        self._set_iptc_tags()
         self.assertEqual(self.metadata._tags['iptc'], {})
         # Direct value assignment: pass a value instead of a fully-formed tag
         key = 'Iptc.Application2.Writer'
         values = ['Nobody']
         self.metadata._set_iptc_tag(key, values)
         self.assert_(key in self.metadata.iptc_keys)
-        self.assert_(self.metadata._image.tags['iptc'].has_key(key))
+        self.assert_(key in self.metadata._image._iptcKeys())
         tag = self.metadata._get_iptc_tag(key)
         self.assertEqual(tag.values, values)
         self.assertEqual(tag.metadata, self.metadata)
         self.assertEqual(self.metadata._tags['iptc'], {key: tag})
-        self.assertEqual(self.metadata._image.tags['iptc'][key], tag.raw_values)
+        self.assertEqual(self.metadata._image._getIptcTag(key)._getRawValues(),
+                         tag.raw_values)
 
     def test_set_iptc_tag_values_inexistent(self):
         self.metadata.read()
-        self._set_iptc_tags()
         key = 'Iptc.Application2.Urgency'
         values = ['1']
         self.failUnlessRaises(KeyError, self.metadata._set_iptc_tag_values,
@@ -477,7 +317,6 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_set_iptc_tag_values_wrong_type(self):
         self.metadata.read()
-        self._set_iptc_tags()
         key = 'Iptc.Application2.DateCreated'
         value = '20090324'
         self.failUnlessRaises(TypeError, self.metadata._set_iptc_tag_values,
@@ -488,40 +327,36 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_set_iptc_tag_values(self):
         self.metadata.read()
-        self._set_iptc_tags()
         key = 'Iptc.Application2.DateCreated'
         tag = self.metadata._get_iptc_tag(key)
         values = ['2009-04-07']
-        self.failIfEqual(self.metadata._image.tags['iptc'][key], values)
+        self.failIfEqual(self.metadata._image._getIptcTag(key)._getRawValues(), values)
         self.metadata._set_iptc_tag_values(key, values)
-        self.assertEqual(self.metadata._image.tags['iptc'][key], values)
+        self.assertEqual(self.metadata._image._getIptcTag(key)._getRawValues(), values)
 
     def test_delete_iptc_tag_inexistent(self):
         self.metadata.read()
-        self._set_iptc_tags()
         key = 'Iptc.Application2.LocationCode'
         self.failUnlessRaises(KeyError, self.metadata._delete_iptc_tag, key)
 
     def test_delete_iptc_tag_not_cached(self):
         self.metadata.read()
-        self._set_iptc_tags()
         key = 'Iptc.Application2.Caption'
         self.assertEqual(self.metadata._tags['iptc'], {})
-        self.assert_(self.metadata._image.tags['iptc'].has_key(key))
+        self.assert_(key in self.metadata._image._iptcKeys())
         self.metadata._delete_iptc_tag(key)
         self.assertEqual(self.metadata._tags['iptc'], {})
-        self.failIf(self.metadata._image.tags['iptc'].has_key(key))
+        self.failIf(key in self.metadata._image._iptcKeys())
 
     def test_delete_iptc_tag_cached(self):
         self.metadata.read()
-        self._set_iptc_tags()
         key = 'Iptc.Application2.Caption'
-        self.assert_(self.metadata._image.tags['iptc'].has_key(key))
+        self.assert_(key in self.metadata._image._iptcKeys())
         tag = self.metadata._get_iptc_tag(key)
         self.assertEqual(self.metadata._tags['iptc'][key], tag)
         self.metadata._delete_iptc_tag(key)
         self.assertEqual(self.metadata._tags['iptc'], {})
-        self.failIf(self.metadata._image.tags['iptc'].has_key(key))
+        self.failIf(key in self.metadata._image._iptcKeys())
 
     ##########################
     # Test XMP-related methods
@@ -529,15 +364,13 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_xmp_keys(self):
         self.metadata.read()
-        self._set_xmp_tags()
         self.assertEqual(self.metadata._keys['xmp'], None)
         keys = self.metadata.xmp_keys
-        self.assertEqual(len(keys), 4)
+        self.assertEqual(len(keys), 2)
         self.assertEqual(self.metadata._keys['xmp'], keys)
 
     def test_get_xmp_tag(self):
         self.metadata.read()
-        self._set_xmp_tags()
         self.assertEqual(self.metadata._tags['xmp'], {})
         # Get an existing tag
         key = 'Xmp.dc.subject'
@@ -551,7 +384,6 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_set_xmp_tag_wrong(self):
         self.metadata.read()
-        self._set_xmp_tags()
         self.assertEqual(self.metadata._tags['xmp'], {})
         # Try to set a tag with wrong type
         tag = 'Not an xmp tag'
@@ -560,7 +392,6 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_set_xmp_tag_create(self):
         self.metadata.read()
-        self._set_xmp_tags()
         self.assertEqual(self.metadata._tags['xmp'], {})
         # Create a new tag
         tag = XmpTag('Xmp.dc.title', {'x-default': 'This is not a title',
@@ -571,13 +402,12 @@ class TestImageMetadata(unittest.TestCase):
         self.assertEqual(tag.metadata, self.metadata)
         self.assert_(tag.key in self.metadata.xmp_keys)
         self.assertEqual(self.metadata._tags['xmp'], {tag.key: tag})
-        self.assert_(self.metadata._image.tags['xmp'].has_key(tag.key))
-        self.assertEqual(self.metadata._image.tags['xmp'][tag.key],
+        self.assert_(tag.key in self.metadata._image._xmpKeys())
+        self.assertEqual(self.metadata._image._getXmpTag(tag.key)._getLangAltValue(),
                          tag.raw_value)
 
     def test_set_xmp_tag_overwrite(self):
         self.metadata.read()
-        self._set_xmp_tags()
         self.assertEqual(self.metadata._tags['xmp'], {})
         # Overwrite an existing tag
         tag = XmpTag('Xmp.dc.format', ('image', 'png'))
@@ -585,30 +415,28 @@ class TestImageMetadata(unittest.TestCase):
         self.metadata._set_xmp_tag(tag.key, tag)
         self.assertEqual(tag.metadata, self.metadata)
         self.assertEqual(self.metadata._tags['xmp'], {tag.key: tag})
-        self.assert_(self.metadata._image.tags['xmp'].has_key(tag.key))
-        self.assertEqual(self.metadata._image.tags['xmp'][tag.key],
+        self.assert_(tag.key in self.metadata._image._xmpKeys())
+        self.assertEqual(self.metadata._image._getXmpTag(tag.key)._getTextValue(),
                          tag.raw_value)
 
     def test_set_xmp_tag_overwrite_already_cached(self):
         self.metadata.read()
-        self._set_xmp_tags()
         self.assertEqual(self.metadata._tags['xmp'], {})
         # Overwrite an existing tag already cached
-        key = 'Xmp.xmp.CreateDate'
+        key = 'Xmp.dc.subject'
         tag = self.metadata._get_xmp_tag(key)
         self.assertEqual(self.metadata._tags['xmp'][key], tag)
-        new_tag = XmpTag(key, datetime.datetime(2009, 4, 21, 20, 7, 0, tzinfo=FixedOffset('+', 1, 0)))
+        new_tag = XmpTag(key, ['hello', 'world'])
         self.assertEqual(new_tag.metadata, None)
         self.metadata._set_xmp_tag(key, new_tag)
         self.assertEqual(new_tag.metadata, self.metadata)
         self.assertEqual(self.metadata._tags['xmp'], {key: new_tag})
-        self.assert_(self.metadata._image.tags['xmp'].has_key(key))
-        self.assertEqual(self.metadata._image.tags['xmp'][key],
+        self.assert_(key in self.metadata._image._xmpKeys())
+        self.assertEqual(self.metadata._image._getXmpTag(key)._getArrayValue(),
                          new_tag.raw_value)
 
     def test_set_xmp_tag_direct_value_assignment(self):
         self.metadata.read()
-        self._set_xmp_tags()
         self.assertEqual(self.metadata._tags['xmp'], {})
         # Direct value assignment: pass a value instead of a fully-formed tag
         key = 'Xmp.dc.title'
@@ -616,16 +444,15 @@ class TestImageMetadata(unittest.TestCase):
                  'fr-FR': "Ceci n'est pas un titre"}
         self.metadata._set_xmp_tag(key, value)
         self.assert_(key in self.metadata.xmp_keys)
-        self.assert_(self.metadata._image.tags['xmp'].has_key(key))
+        self.assert_(key in self.metadata._image._xmpKeys())
         tag = self.metadata._get_xmp_tag(key)
         self.assertEqual(tag.value, value)
         self.assertEqual(tag.metadata, self.metadata)
         self.assertEqual(self.metadata._tags['xmp'], {key: tag})
-        self.assertEqual(self.metadata._image.tags['xmp'][key], tag.raw_value)
+        self.assertEqual(self.metadata._image._getXmpTag(key)._getLangAltValue(), tag.raw_value)
 
     def test_set_xmp_tag_value_inexistent(self):
         self.metadata.read()
-        self._set_xmp_tags()
         key = 'Xmp.xmp.Nickname'
         value = 'oSoMoN'
         self.failUnlessRaises(KeyError, self.metadata._set_xmp_tag_value,
@@ -633,8 +460,7 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_set_xmp_tag_value_wrong_type(self):
         self.metadata.read()
-        self._set_xmp_tags()
-        key = 'Xmp.xmp.CreateDate'
+        key = 'Xmp.dc.subject'
         tag = self.metadata[key]
         value = datetime.datetime(2009, 4, 21, 20, 11, 0)
         self.failUnlessRaises(TypeError, self.metadata._set_xmp_tag_value,
@@ -642,40 +468,36 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_set_xmp_tag_value(self):
         self.metadata.read()
-        self._set_xmp_tags()
-        key = 'Xmp.xmp.CreateDate'
+        key = 'Xmp.dc.subject'
         tag = self.metadata._get_xmp_tag(key)
-        value = '2009-04-21T20:12:47+01:00'
-        self.failIfEqual(self.metadata._image.tags['xmp'][key], value)
+        value = ['Hello', 'World']
+        self.failIfEqual(self.metadata._image._getXmpTag(key)._getArrayValue(), value)
         self.metadata._set_xmp_tag_value(key, value)
-        self.assertEqual(self.metadata._image.tags['xmp'][key], value)
+        self.assertEqual(self.metadata._image._getXmpTag(key)._getArrayValue(), value)
 
     def test_delete_xmp_tag_inexistent(self):
         self.metadata.read()
-        self._set_xmp_tags()
         key = 'Xmp.xmp.CreatorTool'
         self.failUnlessRaises(KeyError, self.metadata._delete_xmp_tag, key)
 
     def test_delete_xmp_tag_not_cached(self):
         self.metadata.read()
-        self._set_xmp_tags()
         key = 'Xmp.dc.subject'
         self.assertEqual(self.metadata._tags['xmp'], {})
-        self.assert_(self.metadata._image.tags['xmp'].has_key(key))
+        self.assert_(key in self.metadata._image._xmpKeys())
         self.metadata._delete_xmp_tag(key)
         self.assertEqual(self.metadata._tags['xmp'], {})
-        self.failIf(self.metadata._image.tags['xmp'].has_key(key))
+        self.failIf(key in self.metadata._image._xmpKeys())
 
     def test_delete_xmp_tag_cached(self):
         self.metadata.read()
-        self._set_xmp_tags()
         key = 'Xmp.dc.subject'
-        self.assert_(self.metadata._image.tags['xmp'].has_key(key))
+        self.assert_(key in self.metadata._image._xmpKeys())
         tag = self.metadata._get_xmp_tag(key)
         self.assertEqual(self.metadata._tags['xmp'][key], tag)
         self.metadata._delete_xmp_tag(key)
         self.assertEqual(self.metadata._tags['xmp'], {})
-        self.failIf(self.metadata._image.tags['xmp'].has_key(key))
+        self.failIf(key in self.metadata._image._xmpKeys())
 
     ###########################
     # Test dictionary interface
@@ -683,17 +505,14 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_getitem(self):
         self.metadata.read()
-        self._set_exif_tags()
-        self._set_iptc_tags()
-        self._set_xmp_tags()
         # Get existing tags
-        key = 'Exif.Photo.ExifVersion'
+        key = 'Exif.Image.DateTime'
         tag = self.metadata[key]
         self.assertEqual(type(tag), ExifTag)
         key = 'Iptc.Application2.Caption'
         tag = self.metadata[key]
         self.assertEqual(type(tag), IptcTag)
-        key = 'Xmp.xmp.CreateDate'
+        key = 'Xmp.dc.format'
         tag = self.metadata[key]
         self.assertEqual(type(tag), XmpTag)
         # Try to get nonexistent tags
@@ -704,9 +523,6 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_setitem(self):
         self.metadata.read()
-        self._set_exif_tags()
-        self._set_iptc_tags()
-        self._set_xmp_tags()
         # Set new tags
         key = 'Exif.Photo.ExposureBiasValue'
         tag = ExifTag(key, Rational(0, 3))
@@ -742,17 +558,14 @@ class TestImageMetadata(unittest.TestCase):
 
     def test_delitem(self):
         self.metadata.read()
-        self._set_exif_tags()
-        self._set_iptc_tags()
-        self._set_xmp_tags()
         # Delete existing tags
-        key = 'Exif.Photo.ExifVersion'
+        key = 'Exif.Image.Make'
         del self.metadata[key]
         self.failIf(key in self.metadata._tags['exif'])
         key = 'Iptc.Application2.Caption'
         del self.metadata[key]
         self.failIf(key in self.metadata._tags['iptc'])
-        key = 'Xmp.xmp.CreateDate'
+        key = 'Xmp.dc.subject'
         del self.metadata[key]
         self.failIf(key in self.metadata._tags['xmp'])
         # Try to delete nonexistent tags
@@ -766,27 +579,32 @@ class TestImageMetadata(unittest.TestCase):
     ####################
 
     def _set_up_other(self):
-        self.other = ImageMetadata('nofile')
-        self.other._instantiate_image = lambda filename: ImageMock(filename)
+        self.other = ImageMetadata.from_buffer(EMPTY_PNG_DATA)
 
     def test_copy_metadata(self):
         self.metadata.read()
-        self._set_exif_tags()
-        self._set_iptc_tags()
-        self._set_xmp_tags()
         self._set_up_other()
         self.other.read()
-        self.failUnlessEqual(self.other.exif_keys, [])
-        self.failUnlessEqual(self.other.iptc_keys, [])
-        self.failUnlessEqual(self.other.xmp_keys, [])
+        families = ('exif', 'iptc', 'xmp')
+
+        for family in families:
+            self.failUnlessEqual(getattr(self.other, '%s_keys' % family), [])
+
         self.metadata.copy(self.other)
 
-        # The actual test is here, the rest of the functionality being mocked...
         for family in ('exif', 'iptc', 'xmp'):
             self.failUnlessEqual(self.other._keys[family], None)
             self.failUnlessEqual(self.other._tags[family], {})
+            keys = getattr(self.metadata, '%s_keys' % family)
+            self.failUnlessEqual(getattr(self.other._image, '_%sKeys' % family)(), keys)
+            self.failUnlessEqual(getattr(self.other, '%s_keys' % family), keys)
+
+        for key in self.metadata.exif_keys:
+            self.failUnlessEqual(self.metadata[key].value, self.other[key].value)
+
+        for key in self.metadata.iptc_keys:
+            self.failUnlessEqual(self.metadata[key].values, self.other[key].values)
 
-        self.failUnlessEqual(self.other.exif_keys, self.metadata.exif_keys)
-        self.failUnlessEqual(self.other.iptc_keys, self.metadata.iptc_keys)
-        self.failUnlessEqual(self.other.xmp_keys, self.metadata.xmp_keys)
+        for key in self.metadata.xmp_keys:
+            self.failUnlessEqual(self.metadata[key].value, self.other[key].value)