# -*- coding: utf-8 -*- # # Copyright (c) 2008-2009, European Space Agency & European Southern # Observatory (ESA/ESO) # Copyright (c) 2008-2009, CRS4 - Centre for Advanced Studies, Research and # Development in Sardinia # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # * Neither the name of the European Space Agency, European Southern # Observatory, CRS4 nor the names of its contributors may be used to # endorse or promote products derived from this software without specific # prior written permission. # # THIS SOFTWARE IS PROVIDED BY ESA/ESO AND CRS4 ``AS IS'' AND ANY EXPRESS OR # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO # EVENT SHALL ESA/ESO BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, # WHETHER # IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE import datetime import sys if sys.hexversion < 0x02070000: import unittest2 as unittest else: import unittest import os import os.path import pkg_resources import shutil import tempfile import pytz import libxmp from libxmp import XMPFiles, XMPMeta, XMPError from libxmp.utils import file_to_dict, object_to_dict from .common_fixtures import setup_sample_files from . import xmpcoverage from libxmp.consts import XMP_ITERATOR_OPTIONS, XMP_SKIP_OPTIONS from libxmp.consts import XMP_NS_XMP as NS_XAP from libxmp.consts import XMP_NS_CC as NS_CC from libxmp.consts import XMP_NS_DC as NS_DC from libxmp.consts import XMP_NS_EXIF as NS_EXIF from libxmp.consts import XMP_NS_TIFF as NS_TIFF from libxmp.consts import XMP_NS_CameraRaw as NS_CAMERA_RAW_SETTINGS from libxmp.consts import XMP_NS_Photoshop as NS_PHOTOSHOP class TestClass(object): def __unicode__(self): return xmpcoverage.RDFCoverage class XMPMetaTestCase(unittest.TestCase): def setUp(self): self.tempdir = tempfile.mkdtemp() self.samplefiles, self.formats = setup_sample_files(self.tempdir) def tearDown(self): shutil.rmtree(self.tempdir) def test_init_del(self): xmp = XMPMeta() self.assertTrue( xmp.xmpptr ) del xmp def test_test_files(self): for f in self.samplefiles: self.assertTrue( os.path.exists(f), "Test file does not exists." ) def test_get_xmp(self): for f in self.samplefiles: xmpfile = XMPFiles( file_path=f ) xmp = xmpfile.get_xmp() self.assertTrue( isinstance(xmp, XMPMeta), "Not an XMPMeta object" ) xmpfile.close_file() def test_get_localized_text(self): xmp = XMPMeta() xmp.parse_from_str(xmpcoverage.RDFCoverage, xmpmeta_wrap=True ) prop = xmp.get_property(xmpcoverage.NS1, "SimpleProp2" ) self.assertEqual(prop, "Simple2 value" ) ltext = xmp.get_localized_text(xmpcoverage.NS1, "ArrayProp2", 'x-one', 'x-one' ) self.assertEqual(ltext, "Item2.1 value" ) del xmp def test_parse_str(self): xmp = XMPMeta() xmp.parse_from_str( xmpcoverage.RDFCoverage, xmpmeta_wrap=True ) prop = xmp.get_property( xmpcoverage.NS1, "SimpleProp1" ) self.assertEqual(prop, "Simple1 value" ) self.assertEqual(prop, u"Simple1 value" ) del xmp def test_shorthand_rdf(self): """ Tests pass so long as no error is issued. """ xmp = XMPMeta() xmp.parse_from_str( xmpcoverage.ShorthandRDF, xmpmeta_wrap=True ) prop = xmp.get_property( "http://ns.adobe.com/tiff/1.0", "Model" ) self.assertEqual(prop, "Canon PowerShot S300" ) del xmp def test_serialize_str(self): xmp = XMPMeta() xmp.parse_from_str( xmpcoverage.RDFCoverage, xmpmeta_wrap=True ) obj = xmp.serialize_to_str(use_compact_format=True, omit_packet_wrapper=True) if sys.hexversion >= 0x03000000: the_unicode_type = str else: the_unicode_type = unicode self.assertTrue(isinstance(obj, the_unicode_type)) with self.assertRaises(XMPError): xmp.serialize_to_str(read_only_packet=True, omit_packet_wrapper=True) with self.assertRaises(XMPError): xmp.serialize_to_str(include_thumbnail_pad=True, omit_packet_wrapper=True) with self.assertRaises(XMPError): xmp.serialize_to_str(exact_packet_length=True, omit_packet_wrapper=True) del xmp def test_serialize_unicode(self): """ Return type is unicode in 2.7, but str in 3.x """ xmp = XMPMeta() xmp.parse_from_str(xmpcoverage.RDFCoverage, xmpmeta_wrap=True) if sys.hexversion >= 0x03000000: the_unicode_type = str else: the_unicode_type = unicode obj = xmp.serialize_to_unicode(use_compact_format=True, omit_packet_wrapper=False) self.assertTrue(isinstance(obj, the_unicode_type ), "Incorrect string result type." ) with self.assertRaises(XMPError): xmp.serialize_to_unicode(read_only_packet=True, omit_packet_wrapper=True) with self.assertRaises(XMPError): xmp.serialize_to_unicode(include_thumbnail_pad=True, omit_packet_wrapper=True ) with self.assertRaises(XMPError): xmp.serialize_to_unicode(exact_packet_length=True, omit_packet_wrapper=True ) del xmp def test_serialize_and_format(self): xmp = XMPMeta() xmp.parse_from_str(xmpcoverage.RDFCoverage, xmpmeta_wrap=True) obj = xmp.serialize_and_format(padding=0, newlinechr='NEWLINE', tabchr = 'TAB', indent=6 ) if sys.hexversion >= 0x03000000: the_unicode_type = str else: the_unicode_type = unicode self.assertTrue(isinstance(obj, the_unicode_type), "Result is not the correct string" ) with self.assertRaises(XMPError): xmp.serialize_and_format(read_only_packet=True, omit_packet_wrapper=True) with self.assertRaises(XMPError): xmp.serialize_and_format(include_thumbnail_pad=True, omit_packet_wrapper=True) with self.assertRaises(XMPError): xmp.serialize_and_format(exact_packet_length=True, omit_packet_wrapper=True ) del xmp def test_clone(self): xmp1 = XMPMeta() self.assertTrue( xmp1 == xmp1, "XMP1 not equal it self" ) self.assertFalse( xmp1 != xmp1, "XMP1 is equal it self" ) xmp2 = xmp1.clone() self.assertFalse( xmp1 == xmp2, "XMP1 is not equal XMP2" ) self.assertTrue( xmp1 != xmp2, "XMP1 is not equal XMP2" ) del xmp1 del xmp2 def test_text_property_450_file(self): files = ["fixtures/BlueSquare450.xmp", "fixtures/BlueSquare450.tif"] options = ['open_nooption', 'open_read', 'open_forupdate', 'open_onlyxmp', 'open_cachetnail', 'open_strictly', 'open_usesmarthandler', 'open_usepacketscanning', 'open_limitscanning',] for f in files: for o in options: try: xmpfile = XMPFiles( file_path=f, ** { o : True } ) xmp_data = xmpfile.get_xmp() headline = xmp_data.get_property(NS_PHOTOSHOP, 'Headline') self.assertEqual(headline[-5:], "=END=") self.assertTrue(len(headline) > 450, "Not all text was extracted." ) except ((IOError, XMPError)): pass def test_text_property_450(self): xmp = XMPMeta() xmp.parse_from_str( xmpcoverage.LongTextProperty, xmpmeta_wrap=True ) headline = xmp.get_property("http://ns.adobe.com/photoshop/1.0/", 'Headline' ) self.assertEqual( headline[-5:], "=END=" ) self.assertTrue(len(headline) > 450, "Not all text was extracted from headline property.") def test_does_property_exist(self): filename = pkg_resources.resource_filename(__name__, "fixtures/BlueSquare450.tif") xmp = XMPFiles(file_path=filename) xmp_data = xmp.get_xmp() self.assertTrue( xmp_data.does_property_exist( "http://ns.adobe.com/photoshop/1.0/", 'Headline' ) ) def test_write_new_property(self): """Corresponds to test-write-new-property.cpp""" filename = pkg_resources.resource_filename(__name__, "samples/test1.xmp") with open(filename, 'r') as fptr: strbuffer = fptr.read() xmp = XMPMeta() xmp.parse_from_str(strbuffer, xmpmeta_wrap=False) XMPMeta.register_namespace(NS_CC, "cc") reg_prefix = XMPMeta.get_namespace_for_prefix("cc") self.assertEqual(reg_prefix, NS_CC) reg_prefix = XMPMeta.get_prefix_for_namespace(NS_CC) self.assertEqual(reg_prefix, "cc:") xmp.set_property(NS_CC, "License", "Foo") self.assertEqual(xmp.get_property(NS_CC, "License"), "Foo") the_dt = datetime.datetime(2005, 12, 25, 12, 42, 42, tzinfo=pytz.utc) xmp.set_property_datetime(NS_EXIF, "DateTimeOriginal", the_dt) self.assertEqual(xmp.get_property(NS_EXIF, "DateTimeOriginal"), "2005-12-25T12:42:42") prop = xmp.get_property_datetime(NS_EXIF, "DateTimeOriginal") self.assertEqual(prop.year, 2005) self.assertEqual(prop.minute, 42) self.assertEqual(prop.tzinfo, pytz.utc) def test_write_new_struct_in_array(self): filename = pkg_resources.resource_filename(__name__, "samples/test1.xmp") with open(filename, 'r') as fptr: strbuffer = fptr.read() xmp = XMPMeta() xmp.parse_from_str(strbuffer) prefix = xmp.get_prefix_for_namespace(NS_DC) xmp.append_array_item(NS_DC, prefix + 'creator', None, prop_value_is_struct=True) xmp.set_property(NS_DC, prefix + 'creator[2]/' + prefix + 'TestProp', '100') self.assertTrue(xmp.does_property_exist(NS_DC, prefix + 'creator[2]')) prop = xmp.get_property(NS_DC, prefix + 'creator[2]/%sTestProp' % prefix) self.assertEqual(prop, '100') xpath = prefix + 'creator' xmp.set_array_item(NS_DC, xpath, 3, None, prop_value_is_struct=True) xpath += '[3]/%sTestProp' % prefix xmp.set_property(NS_DC, xpath, '200') self.assertTrue(xmp.does_property_exist(NS_DC, xpath)) prop = xmp.get_property(NS_DC, xpath) self.assertEqual(prop, '200') xpath = prefix + 'TestStruct/' + prefix + 'TestValue' xmp.set_property(NS_DC, xpath, '300') self.assertTrue(xmp.does_property_exist(NS_DC, xpath)) prop = xmp.get_property(NS_DC, xpath) self.assertEqual(prop, '300') def test_exempi_core(self): """Corresponds to test_exempi.TestExempi.test_exempi_core""" filename = pkg_resources.resource_filename(__name__, "samples/test1.xmp") with open(filename, 'r') as fptr: strbuffer = fptr.read() xmp = XMPMeta() xmp.parse_from_str(strbuffer) self.assertTrue(xmp.does_property_exist(NS_TIFF, 'Make')) self.assertFalse(xmp.does_property_exist(NS_TIFF, 'Foo')) prop = xmp.get_property(NS_TIFF, 'Make') self.assertEqual(prop, 'Canon') xmp.set_property(NS_TIFF, 'Make', 'Leica') prop = xmp.get_property(NS_TIFF, 'Make') self.assertEqual(prop, 'Leica') # Some tests correspond to option masks not currently returned via # this interface. item = xmp.get_localized_text(NS_DC, 'rights', None, 'x-default') self.assertEqual(item, "2006, Hubert Figuiere") xmp.set_localized_text(NS_DC, 'rights', 'en', 'en-CA', 'Foo bar') item = xmp.get_localized_text(NS_DC, 'rights', 'en', 'en-US') # Can't look at the actual lang, unlike the original test. self.assertEqual(item, 'Foo bar') xmp.delete_localized_text(NS_DC, 'rights', 'en', 'en-CA') self.assertFalse(xmp.does_property_exist(NS_DC, "rights[1]")) xmp.set_array_item(NS_DC, "creator", 2, "foo") xmp.append_array_item(NS_DC, "creator", "bar") prop = xmp.get_array_item(NS_DC, "creator", 3) self.assertEqual(prop, "bar") xmp.delete_property(NS_DC, "creator[3]") self.assertFalse(xmp.does_property_exist(NS_DC, "creator[3]")) prop = xmp.get_property(NS_EXIF, "DateTimeOriginal") self.assertEqual(prop, "2006-12-07T23:20:43-05:00") the_prop = xmp.get_property_datetime(NS_EXIF, "DateTimeOriginal") self.assertEqual(the_prop.year, 2006) self.assertEqual(the_prop.minute, 20) self.assertEqual(the_prop.tzinfo, pytz.utc) prop = xmp.get_property(NS_XAP, "Rating") self.assertEqual(prop, "3") prop = xmp.get_property_float(NS_CAMERA_RAW_SETTINGS, "SharpenRadius") self.assertEqual(prop, 1.0) xmp.set_property_float(NS_CAMERA_RAW_SETTINGS, "SharpenRadius", 2.5) prop = xmp.get_property_float(NS_CAMERA_RAW_SETTINGS, "SharpenRadius") self.assertEqual(prop, 2.5) prop = xmp.get_property_bool(NS_CAMERA_RAW_SETTINGS, "AlreadyApplied") self.assertFalse(prop) xmp.set_property_bool(NS_CAMERA_RAW_SETTINGS, "AlreadyApplied", True) prop = xmp.get_property_bool(NS_CAMERA_RAW_SETTINGS, "AlreadyApplied") self.assertTrue(prop) prop = xmp.get_property_int(NS_EXIF, "MeteringMode") self.assertEqual(prop, 5) xmp.set_property_int(NS_EXIF, "MeteringMode", 10) prop = xmp.get_property_long(NS_EXIF, "MeteringMode") self.assertEqual(prop, 10) xmp.set_property_long(NS_EXIF, "MeteringMode", 32) prop = xmp.get_property_int(NS_EXIF, "MeteringMode") self.assertEqual(prop, 32) def test_does_array_item_exist(self): """Tests XMPMeta method does_array_item_exist. Issue #03""" filename = pkg_resources.resource_filename(__name__, "samples/test1.xmp") with open(filename, 'r') as fptr: strbuffer = fptr.read() xmp = XMPMeta() xmp.parse_from_str(strbuffer) xmp.set_array_item(NS_DC, "creator", 2, "foo") xmp.append_array_item(NS_DC, "creator", "bar") self.assertTrue(xmp.does_array_item_exist(NS_DC, "creator", "foo")) self.assertFalse(xmp.does_array_item_exist(NS_DC, "creator", "blah")) def test_count_array_items(self): """Tests XMPMeta method count_array_items.""" filename = pkg_resources.resource_filename(__name__, "samples/test1.xmp") with open(filename, 'r') as fptr: strbuffer = fptr.read() xmp = XMPMeta() xmp.parse_from_str(strbuffer) xmp.set_array_item(NS_DC, "creator", 2, "foo") xmp.append_array_item(NS_DC, "creator", "bar") xmp.append_array_item(NS_DC, "creator", "donuts") self.assertEqual(xmp.count_array_items(NS_DC, "creator"), 4) def test_skip(self): """Verify usage of XMPMeta skip method. """ filename = pkg_resources.resource_filename(__name__, "samples/test1.xmp") with open(filename, 'r') as fptr: strbuffer = fptr.read() xmp = XMPMeta() xmp.parse_from_str(strbuffer) iterator = iterator = iter(xmp) schemas = [] paths = [] props = [] for schema, path, prop, options in iterator: if schema == NS_TIFF: iterator.skip(iter_skipsubtree=True) else: schemas.append(schema) paths.append(path) props.append(prop) # If the iteration modification worked, there should be no TIFF # properties in the list of schemas. self.assertTrue(NS_TIFF not in schemas) self.assertTrue(NS_EXIF in schemas) class UtilsTestCase(unittest.TestCase): def setUp(self): self.tempdir = tempfile.mkdtemp() self.samplefiles, self.formats = setup_sample_files(self.tempdir) def tearDown(self): shutil.rmtree(self.tempdir) def test_object_to_dict(self): for filename in self.samplefiles: xmpfile = XMPFiles( file_path=filename ) xmp = xmpfile.get_xmp() self.assertTrue( object_to_dict( xmp ), "Not an XMPMeta object" ) xmpfile.close_file() def test_file_to_dict(self): for filename in self.samplefiles: self.assertTrue( file_to_dict(filename), "Expected dictionary" ) def test_file_to_dict_nofile(self): self.assertRaises( IOError, file_to_dict, "nonexistingfile.ext" ) def test_file_to_dict_noxmp(self): filename = pkg_resources.resource_filename(__name__, "fixtures/empty.txt") self.assertEqual( file_to_dict(filename), {} ) def test_object_to_dict_noxmp(self): self.assertEqual( object_to_dict( [] ), {} ) class NegativeTestCases(unittest.TestCase): def test_delete_property(self): """ Verify the deleting a phony property does not raise an exception. """ xmp = XMPMeta() xmp.parse_from_str(xmpcoverage.RDFCoverage, xmpmeta_wrap=True ) xmp.delete_property(xmpcoverage.NS1, "NotReallyThere" ) def test_delete_property_bad_schema(self): """ Specifying a bad schema trigger an exception. """ xmp = XMPMeta() xmp.parse_from_str(xmpcoverage.RDFCoverage, xmpmeta_wrap=True ) with self.assertRaises(XMPError): xmp.delete_property("not really a schema", "NotReallyThere" ) class UnicodeTestCase(unittest.TestCase): # TODO: need a latin-1 case, both positive and negative. def test_get_localized_text(self): """ Verify that unicode string literals are properly interpreted. """ xmp = XMPMeta() xmp.parse_from_str(xmpcoverage.RDFCoverage, xmpmeta_wrap=True ) prop = xmp.get_property(xmpcoverage.NS1, "SimpleProp2" ) self.assertEqual(prop, u'Simple2 value' ) ltext = xmp.get_localized_text(xmpcoverage.NS1, "ArrayProp2", 'x-one', 'x-one' ) self.assertEqual(ltext, u'Item2.1 value' ) del xmp def test_2bytes_codepoint(self): """ Verify that we can create and read back utf-8 where some characters takes 2 bytes to encode. """ xmp = XMPMeta() rdf = xmpcoverage.RDFCoverage # Replace 'Simple2 value' with 'stürm' # ü has code point 252, so takes 5+1=6 bytes to encode. expectedValue = u'stürm' if sys.hexversion < 0x03000000: rdf = unicode(rdf[0:272]) + expectedValue + unicode(rdf[285:]) else: rdf = rdf[0:272] + expectedValue + rdf[285:] xmp.parse_from_str(rdf, xmpmeta_wrap=True ) prop = xmp.get_property(xmpcoverage.NS1, "SimpleProp2" ) self.assertEqual(prop, expectedValue) del xmp def test_parse_from_str_3_bytes_per_codepoint(self): """ Verify that we can create and read back utf-8 where each character takes 3 bytes to encode. """ xmp = XMPMeta() rdf = xmpcoverage.RDFCoverage # Replace 'Simple2 value' with 'शिव' # This is 'Shiva' in Devanagari # शिव has code points [2358, 2367, 2357] expectedValue = u'शिव' if sys.hexversion < 0x03000000: rdf = unicode(rdf[0:272]) + expectedValue + unicode(rdf[285:]) #rdf = rdf[0:272] + expectedValue.encode('utf-8') + rdf[285:] #rdf = unicode(rdf) else: rdf = rdf[0:272] + expectedValue + rdf[285:] xmp.parse_from_str(rdf, xmpmeta_wrap=True ) prop = xmp.get_property(xmpcoverage.NS1, "SimpleProp2" ) self.assertEqual(prop, expectedValue) del xmp def test_libxmp_version(self): """Verify that the version attribute is accessible.""" self.assertTrue(hasattr(libxmp, '__version__')) def test_xmpmeta_str(self): """In 2.7, str must return a byte string. In 3.x, it is a str.""" xmp = XMPMeta() xmp.set_property(NS_DC, "Title", 'Huckleberry Finn') self.assertTrue(isinstance(str(xmp), str)) xmp = XMPMeta() xmp.set_property(NS_DC, "Title", u'Stürm und Drang') self.assertTrue(isinstance(str(xmp), str)) # Something in Devanagari xmp = XMPMeta() xmp.set_property(NS_DC, "Title", u'शिव') self.assertTrue(isinstance(str(xmp), str)) def test_xmpmeta_repr(self): """Should be a str in both 2.x and 3.x""" xmp = XMPMeta() self.assertTrue(isinstance(repr(xmp), str)) def test_xmpmeta_unicode_27(self): """In 2.7, unicode(xmp) should return a unicode object.""" xmp = XMPMeta() rdf = xmpcoverage.RDFCoverage xmp.parse_from_str(rdf) if sys.hexversion < 0x03000000: self.assertTrue(isinstance(unicode(xmp), unicode)) else: # It's a no-op in 3.x. self.assertTrue(True) def suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(XMPMetaTestCase)) suite.addTest(unittest.makeSuite(UtilsTestCase)) return suite def test( verbose=2 ): all_tests = suite() runner = unittest.TextTestRunner(verbosity=verbose) result = runner.run(all_tests) return result, runner if __name__ == "__main__": #test() unittest.main()