def afterSetUp(self): data = getFile('image.gif').read() item = DummyContent() item.image = NamedImage(data, 'image/gif', u'image.gif') self.app._setOb('item', item) self.item = self.app.item self.scaling = ImageScaling(self.app.item, None)
def setUp(self): data = getFile('image.png').read() item = DummyContent() item.image = NamedImage(data, 'image/png', u'image.png') self.layer['app']._setOb('item', item) self.item = self.layer['app'].item self.scaling = ImageScaling(self.item, None)
def testCreateHighPixelDensityScaleWithoutData(self): item = DummyContent() scaling = ImageScaling(item, None) scaling.getHighPixelDensityScales = lambda: [{ 'scale': 2, 'quality': 66 }] foo = scaling.scale('image', width=100, height=80) self.assertFalse(hasattr(foo, 'srcset'))
def setUp(self): data = getFile('image.gif').read() item = DummyContent() item.image = NamedImage(data, 'image/gif', u'image.gif') self.layer['app']._setOb('item', item) self.item = self.layer['app'].item self.scaling = ImageScaling(self.item, None)
def testScaledJpegImageQuality(self): """Test image quality setting for jpeg images. Image quality not available for PNG images. """ data = getFile('image.jpg').read() item = DummyContent() item.image = NamedImage(data, 'image/jpeg', u'image.jpg') scaling = ImageScaling(item, None) # scale an image, record its size foo = scaling.scale('image', width=100, height=80) size_foo = foo.data.getSize() # let's pretend p.a.imaging set the scaling quality to "really sloppy" gsm = getGlobalSiteManager() qualitySupplier = DummyQualitySupplier() gsm.registerUtility(qualitySupplier.getQuality, IScaledImageQuality) wait_to_ensure_modified() # now scale again bar = scaling.scale('image', width=100, height=80) size_bar = bar.data.getSize() # first one should be bigger self.assertTrue(size_foo > size_bar)
def testScaledJpegImageQuality(self): """Test image quality setting for jpeg images. Image quality not available for PNG images. """ data = getFile('image.jpg').read() item = DummyContent() item.image = NamedImage(data, 'image/png', u'image.jpg') scaling = ImageScaling(item, None) # scale an image, record its size foo = scaling.scale('image', width=100, height=80) size_foo = foo.data.getSize() # let's pretend p.a.imaging set the scaling quality to "really sloppy" gsm = getGlobalSiteManager() qualitySupplier = DummyQualitySupplier() gsm.registerUtility(qualitySupplier.getQuality, IScaledImageQuality) wait_to_ensure_modified() # now scale again bar = scaling.scale('image', width=100, height=80) size_bar = bar.data.getSize() # first one should be bigger self.assertTrue(size_foo > size_bar)
def logo(self): logo = self.getItems() if not logo: return None if getattr(logo, 'image_sizes', None): sizes = logo.image_sizes['base'] return { 'id': logo.getId, 'content': '<img width="%s" height="%s" title="%s" alt="%s" src="%s"/>' % (str(sizes[0]), str( sizes[1]), logo.Description, logo.Title, logo.getPath()) } else: logo = logo.getObject() if has_dx and IImage.providedBy(logo): return { 'id': logo.id, 'content': ImageScaling(logo, self.request).tag(title=logo.Description()) } elif hasattr(logo, 'tag'): return { 'id': logo.id, 'content': logo.tag(title=logo.Description()) } elif has_dx and IDocument.providedBy(logo): return { 'id': logo.id, 'content': logo.text and logo.text.raw or '' } elif hasattr(logo, 'getText'): return {'id': logo.id, 'content': logo.getText()} elif logo.portal_type == 'FlashMovie': return { 'id': logo.id, 'content': ObjectView(logo, self.request, 'flashmovie_macro_flashobject.pt') } return None
class ImageScalingTests(unittest.TestCase): layer = PLONE_NAMEDFILE_INTEGRATION_TESTING def setUp(self): data = getFile('image.gif').read() item = DummyContent() item.image = NamedImage(data, 'image/gif', u'image.gif') self.layer['app']._setOb('item', item) self.item = self.layer['app'].item self.scaling = ImageScaling(self.item, None) def testCreateScale(self): foo = self.scaling.scale('image', width=100, height=80) self.assertTrue(foo.uid) self.assertEqual(foo.mimetype, 'image/jpeg') self.assertEqual(foo.width, 80) self.assertEqual(foo.height, 80) assertImage(self, foo.data.data, 'JPEG', (80, 80)) def testCreateScaleWithoutData(self): item = DummyContent() scaling = ImageScaling(item, None) foo = scaling.scale('image', width=100, height=80) self.assertEqual(foo, None) def testGetScaleByName(self): self.scaling.available_sizes = {'foo': (60, 60)} foo = self.scaling.scale('image', scale='foo') self.assertTrue(foo.uid) self.assertEqual(foo.mimetype, 'image/jpeg') self.assertEqual(foo.width, 60) self.assertEqual(foo.height, 60) assertImage(self, foo.data.data, 'JPEG', (60, 60)) expected_url = re.compile( r'http://nohost/item/@@images/[-a-z0-9]{36}\.jpeg') self.assertTrue(expected_url.match(foo.absolute_url())) self.assertEqual(foo.url, foo.absolute_url()) tag = foo.tag() base = IAbsoluteURL(self.item, '') expected = ( r'<img src="{0:s}/@@images/([-0-9a-f]{{36}}).(jpeg|gif|png)" ' r'alt="foo" title="foo" height="(\d+)" width="(\d+)" />'.format( base)) groups = re.match(expected, tag).groups() self.assertTrue(groups, tag) def testGetUnknownScale(self): foo = self.scaling.scale('image', scale='foo?') self.assertEqual(foo, None) def testScaleInvalidation(self): # first get the scale of the original image self.scaling.available_sizes = {'foo': (23, 23)} foo1 = self.scaling.scale('image', scale='foo') wait_to_ensure_modified() # now upload a new one and make sure the scale has changed data = getFile('image.jpg').read() self.item.image = NamedImage(data, 'image/jpeg', u'image.jpg') foo2 = self.scaling.scale('image', scale='foo') self.assertFalse(foo1.data == foo2.data, 'scale not updated?') def testCustomSizeChange(self): # set custom image sizes & view a scale self.scaling.available_sizes = {'foo': (23, 23)} foo = self.scaling.scale('image', scale='foo') self.assertEqual(foo.width, 23) self.assertEqual(foo.height, 23) # now let's update the scale dimensions, after which the scale # shouldn't be the same... self.scaling.available_sizes = {'foo': (42, 42)} foo = self.scaling.scale('image', scale='foo') self.assertEqual(foo.width, 42) self.assertEqual(foo.height, 42) def testAvailableSizes(self): # by default, no named scales are configured self.assertEqual(self.scaling.available_sizes, {}) # a callable can be used to look up the available sizes def custom_available_sizes(): return {'bar': (10, 10)} sm = getSiteManager() sm.registerUtility(component=custom_available_sizes, provided=IAvailableSizes) self.assertEqual(self.scaling.available_sizes, {'bar': (10, 10)}) sm.unregisterUtility(provided=IAvailableSizes) # for testing purposes, the sizes may also be set directly on # the scaling adapter self.scaling.available_sizes = {'qux': (12, 12)} self.assertEqual(self.scaling.available_sizes, {'qux': (12, 12)}) def testGetAvailableSizes(self): self.scaling.available_sizes = {'foo': (60, 60)} assert self.scaling.getAvailableSizes('image') == {'foo': (60, 60)} def testGetImageSize(self): assert self.scaling.getImageSize('image') == (200, 200) def testGetOriginalScaleTag(self): tag = self.scaling.tag('image') base = IAbsoluteURL(self.item, '') expected = ( r'<img src="{0:s}/@@images/([-0-9a-f]{{36}}).(jpeg|gif|png)" ' r'alt="foo" title="foo" height="(\d+)" width="(\d+)" />'.format( base)) self.assertTrue(re.match(expected, tag).groups()) def testScaleOnItemWithNonASCIITitle(self): self.item.title = '\xc3\xbc' tag = self.scaling.tag('image') base = IAbsoluteURL(self.item, '') expected = ( r'<img src="{0:s}/@@images/([-0-9a-f]{{36}}).(jpeg|gif|png)" ' r'alt="\xfc" title="\xfc" height="(\d+)" width="(\d+)" />'.format( base)) self.assertTrue(re.match(expected, tag).groups()) def testScaleOnItemWithUnicodeTitle(self): self.item.Title = lambda: b'\xc3\xbc'.decode('utf8') tag = self.scaling.tag('image') base = IAbsoluteURL(self.item, '') expected = ( r'<img src="{0:s}/@@images/([-0-9a-f]{{36}}).(jpeg|gif|png)" ' r'alt="\xfc" title="\xfc" height="(\d+)" width="(\d+)" />'.format( base)) self.assertTrue(re.match(expected, tag).groups()) def testScaledImageQuality(self): # scale an image, record its size foo = self.scaling.scale('image', width=100, height=80) size_foo = foo.data.getSize() # let's pretend p.a.imaging set the scaling quality to "really sloppy" gsm = getGlobalSiteManager() qualitySupplier = DummyQualitySupplier() gsm.registerUtility(qualitySupplier.getQuality, IScaledImageQuality) wait_to_ensure_modified() # now scale again bar = self.scaling.scale('image', width=100, height=80) size_bar = bar.data.getSize() # first one should be bigger self.assertTrue(size_foo > size_bar)
class ImageScalingTests(NamedFileTestCase): def afterSetUp(self): data = getFile('image.gif').read() item = DummyContent() item.image = NamedImage(data, 'image/gif', u'image.gif') self.app._setOb('item', item) self.item = self.app.item self.scaling = ImageScaling(self.app.item, None) def testCreateScale(self): foo = self.scaling.scale('image', width=100, height=80) self.failUnless(foo.uid) self.assertEqual(foo.mimetype, 'image/jpeg') self.assertEqual(foo.width, 80) self.assertEqual(foo.height, 80) self.assertImage(foo.data.data, 'JPEG', (80, 80)) def testCreateScaleWithoutData(self): item = DummyContent() scaling = ImageScaling(item, None) foo = scaling.scale('image', width=100, height=80) self.assertEqual(foo, None) def testGetScaleByName(self): self.scaling.available_sizes = {'foo': (60,60)} foo = self.scaling.scale('image', scale='foo') self.failUnless(foo.uid) self.assertEqual(foo.mimetype, 'image/jpeg') self.assertEqual(foo.width, 60) self.assertEqual(foo.height, 60) self.assertImage(foo.data.data, 'JPEG', (60, 60)) expected_url = re.compile(r'http://nohost/item/@@images/[-a-z0-9]{36}\.jpeg') self.failUnless(expected_url.match(foo.absolute_url())) self.assertEqual(foo.url, foo.absolute_url()) tag = foo.tag() base = self.item.absolute_url() expected = r'<img src="%s/@@images/([-0-9a-f]{36}).(jpeg|gif|png)" ' \ r'alt="foo" title="foo" height="(\d+)" width="(\d+)" />' % base groups = re.match(expected, tag).groups() self.failUnless(groups, tag) def testGetUnknownScale(self): foo = self.scaling.scale('image', scale='foo?') self.assertEqual(foo, None) def testScaleInvalidation(self): # first get the scale of the original image self.scaling.available_sizes = {'foo': (23,23)} foo1 = self.scaling.scale('image', scale='foo') # now upload a new one and make sure the scale has changed data = getFile('image.jpg').read() self.item.image = NamedImage(data, 'image/jpeg', u'image.jpg') foo2 = self.scaling.scale('image', scale='foo') self.failIf(foo1.data == foo2.data, 'scale not updated?') def testCustomSizeChange(self): # set custom image sizes & view a scale self.scaling.available_sizes = {'foo': (23,23)} foo = self.scaling.scale('image', scale='foo') self.assertEqual(foo.width, 23) self.assertEqual(foo.height, 23) # now let's update the scale dimensions, after which the scale # shouldn't be the same... self.scaling.available_sizes = {'foo': (42,42)} foo = self.scaling.scale('image', scale='foo') self.assertEqual(foo.width, 42) self.assertEqual(foo.height, 42) def testAvailableSizes(self): # by default, no named scales are configured self.assertEqual(self.scaling.available_sizes, {}) # a callable can be used to look up the available sizes def custom_available_sizes(): return {'bar': (10,10)} sm = getSiteManager() sm.registerUtility(component=custom_available_sizes, provided=IAvailableSizes) self.assertEqual(self.scaling.available_sizes, {'bar': (10,10)}) sm.unregisterUtility(provided=IAvailableSizes) # for testing purposes, the sizes may also be set directly on # the scaling adapter self.scaling.available_sizes = {'qux': (12, 12)} self.assertEqual(self.scaling.available_sizes, {'qux': (12, 12)}) def testGuardedAccess(self): # make sure it's not possible to access scales of forbidden images self.item.__allow_access_to_unprotected_subobjects__ = 0 self.assertRaises(Unauthorized, self.scaling.guarded_orig_image, 'image') self.item.__allow_access_to_unprotected_subobjects__ = 1 def testGetAvailableSizes(self): self.scaling.available_sizes = {'foo': (60,60)} assert self.scaling.getAvailableSizes('image') == {'foo': (60, 60)} def testGetImageSize(self): assert self.scaling.getImageSize('image') == (200, 200) def testGetOriginalScaleTag(self): tag = self.scaling.tag('image') base = self.item.absolute_url() expected = r'<img src="%s/@@images/([-0-9a-f]{36}).(jpeg|gif|png)" ' \ r'alt="foo" title="foo" height="(\d+)" width="(\d+)" />' % base self.assertTrue(re.match(expected, tag).groups()) def testScaleOnItemWithNonASCIITitle(self): self.item.title = '\xc3\xbc' tag = self.scaling.tag('image') base = self.item.absolute_url() expected = r'<img src="%s/@@images/([-0-9a-f]{36}).(jpeg|gif|png)" ' \ r'alt="\xfc" title="\xfc" height="(\d+)" width="(\d+)" />' % base self.assertTrue(re.match(expected, tag).groups()) def testScaleOnItemWithUnicodeTitle(self): self.item.title = u'Unicode here' tag = self.scaling.tag('image') base = self.item.absolute_url() expected = r'<img src="%s/@@images/([-0-9a-f]{36}).(jpeg|gif|png)" ' \ r'alt="Unicode here" title="Unicode here" height="(\d+)" width="(\d+)" />' % base self.assertTrue(re.match(expected, tag).groups())
def testCreateScaleWithoutData(self): item = DummyContent() scaling = ImageScaling(item, None) foo = scaling.scale('image', width=100, height=80) self.assertEqual(foo, None)
class ImageScalingTests(unittest.TestCase): layer = PLONE_NAMEDFILE_INTEGRATION_TESTING def setUp(self): data = getFile('image.png').read() item = DummyContent() item.image = NamedImage(data, 'image/png', u'image.png') self.layer['app']._setOb('item', item) self.item = self.layer['app'].item self.scaling = ImageScaling(self.item, None) def testCreateScale(self): foo = self.scaling.scale('image', width=100, height=80) self.assertTrue(foo.uid) self.assertEqual(foo.mimetype, 'image/png') self.assertIsInstance(foo.mimetype, str) self.assertEqual(foo.data.contentType, 'image/png') self.assertIsInstance(foo.data.contentType, str) self.assertEqual(foo.width, 80) self.assertEqual(foo.height, 80) assertImage(self, foo.data.data, 'PNG', (80, 80)) def testCreateHighPixelDensityScale(self): self.scaling.getHighPixelDensityScales = lambda: [{ 'scale': 2, 'quality': 66 }] foo = self.scaling.scale('image', width=100, height=80) self.assertTrue(foo.srcset) self.assertEqual(foo.srcset[0]['mimetype'], 'image/png') self.assertEqual(foo.srcset[0]['height'], 160) self.assertEqual(foo.srcset[0]['width'], 160) assertImage(self, foo.srcset[0]['data'].data, 'PNG', (160, 160)) def testCreateScaleWithoutData(self): item = DummyContent() scaling = ImageScaling(item, None) foo = scaling.scale('image', width=100, height=80) self.assertEqual(foo, None) def testCreateHighPixelDensityScaleWithoutData(self): item = DummyContent() scaling = ImageScaling(item, None) scaling.getHighPixelDensityScales = lambda: [{ 'scale': 2, 'quality': 66 }] foo = scaling.scale('image', width=100, height=80) self.assertFalse(hasattr(foo, 'srcset')) def testGetScaleByName(self): self.scaling.available_sizes = {'foo': (60, 60)} foo = self.scaling.scale('image', scale='foo') self.assertTrue(foo.uid) self.assertEqual(foo.mimetype, 'image/png') self.assertIsInstance(foo.mimetype, str) self.assertEqual(foo.data.contentType, 'image/png') self.assertIsInstance(foo.data.contentType, str) self.assertEqual(foo.width, 60) self.assertEqual(foo.height, 60) assertImage(self, foo.data.data, 'PNG', (60, 60)) expected_url = re.compile( r'http://nohost/item/@@images/[-a-z0-9]{36}\.png') self.assertTrue(expected_url.match(foo.absolute_url())) self.assertEqual(foo.url, foo.absolute_url()) tag = foo.tag() base = self.item.absolute_url() expected = \ r'<img src="{0}/@@images/([-0-9a-f]{{36}}).(jpeg|gif|png)" ' \ r'alt="foo" title="foo" height="(\d+)" width="(\d+)" />'.format( base, ) groups = re.match(expected, tag).groups() self.assertTrue(groups, tag) def testGetHighPixelDensityScaleByName(self): self.scaling.getHighPixelDensityScales = lambda: [{ 'scale': 2, 'quality': 66 }] self.scaling.available_sizes = {'foo': (60, 60)} foo = self.scaling.scale('image', scale='foo') self.assertTrue(foo.srcset) self.assertEqual(foo.srcset[0]['mimetype'], 'image/png') self.assertEqual(foo.srcset[0]['width'], 120) self.assertEqual(foo.srcset[0]['height'], 120) assertImage(self, foo.srcset[0]['data'].data, 'PNG', (120, 120)) tag = foo.tag() base = self.item.absolute_url() expected = (r'<img src="{0}'.format(base) + r'/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)" ' r'alt="foo" title="foo" height="(\d+)" width="(\d+)" ' r'srcset="http://nohost/item/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)' r' 2x" />') groups = re.match(expected, tag).groups() self.assertTrue(groups, tag) def testGetHPDScaleByWidthAndHeight(self): self.scaling.getHighPixelDensityScales = lambda: [{ 'scale': 2, 'quality': 66 }] foo = self.scaling.scale('image', width=60, height=60) self.assertTrue(foo.srcset) self.assertEqual(foo.srcset[0]['mimetype'], 'image/png') self.assertEqual(foo.srcset[0]['width'], 120) self.assertEqual(foo.srcset[0]['height'], 120) assertImage(self, foo.srcset[0]['data'].data, 'PNG', (120, 120)) tag = foo.tag() base = self.item.absolute_url() expected = (r'<img src="{0}'.format(base) + r'/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)" ' r'alt="foo" title="foo" height="(\d+)" width="(\d+)" ' r'srcset="http://nohost/item/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)' r' 2x" />') groups = re.match(expected, tag).groups() self.assertTrue(groups, tag) def testGetHPDScaleByWidthOnly(self): self.scaling.getHighPixelDensityScales = lambda: [{ 'scale': 2, 'quality': 66 }] foo = self.scaling.scale('image', width=60) self.assertTrue(foo.srcset) self.assertEqual(foo.srcset[0]['mimetype'], 'image/png') self.assertEqual(foo.srcset[0]['width'], 120) self.assertEqual(foo.srcset[0]['height'], 120) assertImage(self, foo.srcset[0]['data'].data, 'PNG', (120, 120)) tag = foo.tag() base = self.item.absolute_url() expected = (r'<img src="{0}'.format(base) + r'/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)" ' r'alt="foo" title="foo" height="(\d+)" width="(\d+)" ' r'srcset="http://nohost/item/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)' r' 2x" />') groups = re.match(expected, tag).groups() self.assertTrue(groups, tag) def testGetHPDScaleByHeightOnly(self): self.scaling.getHighPixelDensityScales = lambda: [{ 'scale': 2, 'quality': 66 }] foo = self.scaling.scale('image', height=60) self.assertTrue(foo.srcset) self.assertEqual(foo.srcset[0]['mimetype'], 'image/png') self.assertEqual(foo.srcset[0]['width'], 120) self.assertEqual(foo.srcset[0]['height'], 120) assertImage(self, foo.srcset[0]['data'].data, 'PNG', (120, 120)) tag = foo.tag() base = self.item.absolute_url() expected = (r'<img src="{0}'.format(base) + r'/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)" ' r'alt="foo" title="foo" height="(\d+)" width="(\d+)" ' r'srcset="http://nohost/item/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)' r' 2x" />') groups = re.match(expected, tag).groups() self.assertTrue(groups, tag) def testGetUnknownScale(self): foo = self.scaling.scale('image', scale='foo?') self.assertEqual(foo, None) def testScaleInvalidation(self): # first get the scale of the original image self.scaling.available_sizes = {'foo': (23, 23)} foo1 = self.scaling.scale('image', scale='foo') wait_to_ensure_modified() # now upload a new one and make sure the scale has changed data = getFile('image.jpg').read() self.item.image = NamedImage(data, 'image/jpeg', u'image.jpg') foo2 = self.scaling.scale('image', scale='foo') self.assertFalse(foo1.data == foo2.data, 'scale not updated?') def testCustomSizeChange(self): # set custom image sizes & view a scale self.scaling.available_sizes = {'foo': (23, 23)} foo = self.scaling.scale('image', scale='foo') self.assertEqual(foo.width, 23) self.assertEqual(foo.height, 23) # now let's update the scale dimensions, after which the scale # shouldn't be the same... self.scaling.available_sizes = {'foo': (42, 42)} foo = self.scaling.scale('image', scale='foo') self.assertEqual(foo.width, 42) self.assertEqual(foo.height, 42) def testAvailableSizes(self): # by default, no named scales are configured self.assertEqual(self.scaling.available_sizes, {}) # a callable can be used to look up the available sizes def custom_available_sizes(): return {'bar': (10, 10)} sm = getSiteManager() sm.registerUtility(component=custom_available_sizes, provided=IAvailableSizes) self.assertEqual(self.scaling.available_sizes, {'bar': (10, 10)}) sm.unregisterUtility(provided=IAvailableSizes) # for testing purposes, the sizes may also be set directly on # the scaling adapter self.scaling.available_sizes = {'qux': (12, 12)} self.assertEqual(self.scaling.available_sizes, {'qux': (12, 12)}) def testGuardedAccess(self): # make sure it's not possible to access scales of forbidden images self.item.__allow_access_to_unprotected_subobjects__ = 0 self.assertRaises(Unauthorized, self.scaling.guarded_orig_image, 'image') self.item.__allow_access_to_unprotected_subobjects__ = 1 def testGetAvailableSizes(self): self.scaling.available_sizes = {'foo': (60, 60)} assert self.scaling.getAvailableSizes('image') == {'foo': (60, 60)} def testGetImageSize(self): assert self.scaling.getImageSize('image') == (200, 200) def testGetOriginalScaleTag(self): tag = self.scaling.tag('image') base = self.item.absolute_url() expected = \ r'<img src="{0}/@@images/([-0-9a-f]{{36}}).(jpeg|gif|png)" ' \ r'alt="foo" title="foo" height="(\d+)" width="(\d+)" />'.format( base, ) self.assertTrue(re.match(expected, tag).groups()) def testScaleOnItemWithNonASCIITitle(self): self.item.title = '\xc3\xbc' tag = self.scaling.tag('image') base = self.item.absolute_url() expected = \ r'<img src="{0}/@@images/([-0-9a-f]{{36}}).(jpeg|gif|png)" ' \ r'alt="\xfc" title="\xfc" height="(\d+)" width="(\d+)" />'.format( base, ) self.assertTrue(re.match(expected, tag).groups()) def testScaleOnItemWithUnicodeTitle(self): self.item.Title = lambda: '\xc3\xbc'.decode('utf8') tag = self.scaling.tag('image') base = self.item.absolute_url() expected = \ r'<img src="{0}/@@images/([-0-9a-f]{{36}}).(jpeg|gif|png)" ' \ r'alt="\xfc" title="\xfc" height="(\d+)" width="(\d+)" />'.format( base, ) self.assertTrue(re.match(expected, tag).groups()) def testScaledJpegImageQuality(self): """Test image quality setting for jpeg images. Image quality not available for PNG images. """ data = getFile('image.jpg').read() item = DummyContent() item.image = NamedImage(data, 'image/png', u'image.jpg') scaling = ImageScaling(item, None) # scale an image, record its size foo = scaling.scale('image', width=100, height=80) size_foo = foo.data.getSize() # let's pretend p.a.imaging set the scaling quality to "really sloppy" gsm = getGlobalSiteManager() qualitySupplier = DummyQualitySupplier() gsm.registerUtility(qualitySupplier.getQuality, IScaledImageQuality) wait_to_ensure_modified() # now scale again bar = scaling.scale('image', width=100, height=80) size_bar = bar.data.getSize() # first one should be bigger self.assertTrue(size_foo > size_bar) def testOversizedHighPixelDensityScale(self): orig_size = max(self.scaling.getImageSize('image')) scale_size = orig_size / 2 self.scaling.getHighPixelDensityScales = lambda: [{ 'scale': 2, 'quality': 66 }, { 'scale': 3, 'quality': 66 }] foo = self.scaling.scale('image', width=scale_size, height=scale_size) self.assertEqual(len(foo.srcset), 1) self.assertEqual(foo.srcset[0]['scale'], 2)
def testCreateHighPixelDensityScaleWithoutData(self): item = DummyContent() scaling = ImageScaling(item, None) scaling.getHighPixelDensityScales = lambda: [{'scale': 2, 'quality': 66}] foo = scaling.scale('image', width=100, height=80) self.assertFalse(hasattr(foo, 'srcset'))
def __new__(cls, context, request): parent = aq_parent(context) if IImageScaleTraversable.providedBy(parent): return ImageScaling(parent, request) return None
class ImageScalingTests(NamedFileTestCase): def afterSetUp(self): data = getFile('image.gif').read() item = DummyContent() item.image = NamedImage(data, 'image/gif', u'image.gif') self.app._setOb('item', item) self.item = self.app.item self.scaling = ImageScaling(self.app.item, None) def testCreateScale(self): foo = self.scaling.scale('image', width=100, height=80) self.failUnless(foo.uid) self.assertEqual(foo.mimetype, 'image/jpeg') self.assertEqual(foo.width, 80) self.assertEqual(foo.height, 80) self.assertImage(foo.data.data, 'JPEG', (80, 80)) def testCreateScaleWithoutData(self): item = DummyContent() scaling = ImageScaling(item, None) foo = scaling.scale('image', width=100, height=80) self.assertEqual(foo, None) def testGetScaleByName(self): self.scaling.available_sizes = {'foo': (60, 60)} foo = self.scaling.scale('image', scale='foo') self.failUnless(foo.uid) self.assertEqual(foo.mimetype, 'image/jpeg') self.assertEqual(foo.width, 60) self.assertEqual(foo.height, 60) self.assertImage(foo.data.data, 'JPEG', (60, 60)) expected_url = re.compile( r'http://nohost/item/@@images/[-a-z0-9]{36}\.jpeg') self.failUnless(expected_url.match(foo.absolute_url())) self.assertEqual(foo.url, foo.absolute_url()) tag = foo.tag() base = self.item.absolute_url() expected = r'<img src="%s/@@images/([-0-9a-f]{36}).(jpeg|gif|png)" ' \ r'alt="foo" title="foo" height="(\d+)" width="(\d+)" />' % base groups = re.match(expected, tag).groups() self.failUnless(groups, tag) def testGetUnknownScale(self): foo = self.scaling.scale('image', scale='foo?') self.assertEqual(foo, None) def testScaleInvalidation(self): # first get the scale of the original image self.scaling.available_sizes = {'foo': (23, 23)} foo1 = self.scaling.scale('image', scale='foo') # now upload a new one and make sure the scale has changed data = getFile('image.jpg').read() self.item.image = NamedImage(data, 'image/jpeg', u'image.jpg') foo2 = self.scaling.scale('image', scale='foo') self.failIf(foo1.data == foo2.data, 'scale not updated?') def testCustomSizeChange(self): # set custom image sizes & view a scale self.scaling.available_sizes = {'foo': (23, 23)} foo = self.scaling.scale('image', scale='foo') self.assertEqual(foo.width, 23) self.assertEqual(foo.height, 23) # now let's update the scale dimensions, after which the scale # shouldn't be the same... self.scaling.available_sizes = {'foo': (42, 42)} foo = self.scaling.scale('image', scale='foo') self.assertEqual(foo.width, 42) self.assertEqual(foo.height, 42) def testAvailableSizes(self): # by default, no named scales are configured self.assertEqual(self.scaling.available_sizes, {}) # a callable can be used to look up the available sizes def custom_available_sizes(): return {'bar': (10, 10)} sm = getSiteManager() sm.registerUtility(component=custom_available_sizes, provided=IAvailableSizes) self.assertEqual(self.scaling.available_sizes, {'bar': (10, 10)}) sm.unregisterUtility(provided=IAvailableSizes) # for testing purposes, the sizes may also be set directly on # the scaling adapter self.scaling.available_sizes = {'qux': (12, 12)} self.assertEqual(self.scaling.available_sizes, {'qux': (12, 12)}) def testGuardedAccess(self): # make sure it's not possible to access scales of forbidden images self.item.__allow_access_to_unprotected_subobjects__ = 0 self.assertRaises(Unauthorized, self.scaling.guarded_orig_image, 'image') self.item.__allow_access_to_unprotected_subobjects__ = 1 def testGetAvailableSizes(self): self.scaling.available_sizes = {'foo': (60, 60)} assert self.scaling.getAvailableSizes('image') == {'foo': (60, 60)} def testGetImageSize(self): assert self.scaling.getImageSize('image') == (200, 200) def testGetOriginalScaleTag(self): tag = self.scaling.tag('image') base = self.item.absolute_url() expected = r'<img src="%s/@@images/([-0-9a-f]{36}).(jpeg|gif|png)" ' \ r'alt="foo" title="foo" height="(\d+)" width="(\d+)" />' % base self.assertTrue(re.match(expected, tag).groups()) def testScaleOnItemWithNonASCIITitle(self): self.item.title = '\xc3\xbc' tag = self.scaling.tag('image') base = self.item.absolute_url() expected = r'<img src="%s/@@images/([-0-9a-f]{36}).(jpeg|gif|png)" ' \ r'alt="\xfc" title="\xfc" height="(\d+)" width="(\d+)" />' % base self.assertTrue(re.match(expected, tag).groups()) def testScaleOnItemWithUnicodeTitle(self): self.item.Title = lambda: '\xc3\xbc'.decode('utf8') tag = self.scaling.tag('image') base = self.item.absolute_url() expected = r'<img src="%s/@@images/([-0-9a-f]{36}).(jpeg|gif|png)" ' \ r'alt="\xfc" title="\xfc" height="(\d+)" width="(\d+)" />' % base self.assertTrue(re.match(expected, tag).groups()) def testScaledImageQuality(self): # scale an image, record its size foo = self.scaling.scale('image', width=100, height=80) size_foo = foo.data.getSize() # let's pretend p.a.imaging set the scaling quality to "really sloppy" gsm = getGlobalSiteManager() qualitySupplier = DummyQualitySupplier() gsm.registerUtility(qualitySupplier.getQuality, IScaledImageQuality) # now scale again bar = self.scaling.scale('image', width=100, height=80) size_bar = bar.data.getSize() # first one should be bigger self.assertGreater(size_foo, size_bar)
def getSolgemaBandeaux(self): bandeaux = self.getItems() bandeauxList = [] base_ajax_content_load = self.request.get('ajax_content_load') base_ajax_load = self.request.get('ajax_load') setattr(self.request, 'ajax_content_load', 1) setattr(self.request, 'ajax_load', 1) for bandeau in bandeaux: bdict = {} if getattr(bandeau, 'image_sizes', None): height = str(bandeau.image_sizes['base'][1]) url = str(bandeau.getPath() + '/image') try: title = str(bandeau.Description) except: try: title = str(bandeau.Description.encode('utf-8')) except: try: title = str(bandeau.Description.decode('utf-8')) except: title = safe_unicode(bandeau.Description) if getattr(bandeau, 'bannerImageLink', ''): link = str(self.context.absolute_url() + '/resolveuid/' + bandeau.bannerImageLink) else: link = None repeat = getattr(bandeau, 'backgroundRepeat', None) if not repeat: repeat = 'no-repeat' repeat = str(repeat) align = getattr(bandeau, 'backgroundAlign', None) if not align: align = 'left' align = str(align) cssClass = 'bandeau_image' cssStyle = 'position:relative;' if getattr(bandeau, 'backgroundExtend', False): cssClass += ' backgroundExtend' if getattr(bandeau, 'backgroundFixed', False): cssClass += ' backgroundFixed' if len(bandeauxList) == 0: cssClass += ' ' + bandeau.id.replace( '.', '_') + ' carousel-banner-content selected' cssStyle += ' display:block;' else: cssClass += ' ' + bandeau.id.replace( '.', '_') + ' carousel-banner-content' cssStyle += ' display:none;' if link: backgrounddiv = '<a style="display:block; height:%spx; width:100%%; background:transparent url(%s) %s %s top;" title="%s" class="%s" href="%s"></a>' % ( height, url, repeat, align, title, cssClass, link) else: backgrounddiv = '<div style="height:%spx; width:100%%; background:transparent url(%s) %s %s top;" title="%s" class="%s"></div>' % ( height, url, repeat, align, title, cssClass) # bandeauxList.append({'id':bandeau.id, 'content':bandeau.tag(title=bandeau.Description())}) bdict = { 'id': bandeau.id, 'content': backgrounddiv, 'cssClass': cssClass, 'cssStyle': cssStyle, 'url': url, 'link': link, 'align': align, 'repeat': repeat } else: bandeau = bandeau.getObject() if (has_dx and IImage.providedBy(bandeau)) or hasattr( bandeau, 'tag'): if hasattr(bandeau, 'getHeight'): height = bandeau.getHeight() else: height = ImageScaling(bandeau, self.request).scale().height if has_dx and IImage.providedBy(bandeau): url = bandeau.absolute_url() else: url = str(bandeau.absolute_url() + '/image') title = bandeau.title bkg = IBackgroundContent(bandeau, None) repeat = getattr(bkg, 'backgroundRepeat', None) if not repeat: repeat = 'no-repeat' align = getattr(bkg, 'backgroundAlign', None) if not align: align = 'left' align = str(align) cssClass = 'bandeau_image' cssStyle = 'position:relative;' if getattr(bkg, 'backgroundExtend', False): cssClass += ' backgroundExtend' if getattr(bkg, 'backgroundFixed', False): cssClass += ' backgroundFixed' if len(bandeauxList) == 0: cssClass += ' ' + bandeau.id.replace( '.', '_') + ' carousel-banner-content selected' cssStyle += ' display:block;' else: cssClass += ' ' + bandeau.id.replace( '.', '_') + ' carousel-banner-content' cssStyle += ' display:none;' if getattr(bkg, 'bannerImageLink', ''): link = str(self.context.absolute_url() + '/resolveuid/' + bkg.bannerImageLink) else: link = None if link: backgrounddiv = '<a style="display:block; height:%spx; width:100%%; background:transparent url(%s) %s %s top;" title="%s" class="%s" href="%s"></a>' % ( height, url, repeat, align, title, cssClass, link) else: backgrounddiv = '<div style="height:%spx; width:100%%; background:transparent url(%s) %s %s top;" title="%s" class="%s"></div>' % ( height, url, repeat, align, title, cssClass) bdict = { 'id': bandeau.id, 'content': backgrounddiv, 'cssClass': cssClass, 'cssStyle': cssStyle, 'url': url, 'link': link, 'align': align, 'repeat': repeat } elif has_dx and IDocument.providedBy(bandeau): bdict['id'] = bandeau.id bdict['content'] = bandeau.text and bandeau.text.raw or '' elif hasattr(bandeau, 'getText') and not bandeau.portal_type in [ 'Topic', 'Collection' ]: try: bdict['id'] = bandeau.id bdict['content'] = bandeau.getText() except: raise ValueError('error with: ' + str(bandeau)) elif bandeau.portal_type == 'Collage': bdict['id'] = bandeau.id bdict['content'] = ObjectView(bandeau, self.request, 'collage_renderer.pt') elif bandeau.portal_type == 'FlashMovie': bdict['id'] = bandeau.id bdict['content'] = ObjectView( bandeau, self.request, 'flashmovie_macro_flashobject.pt') elif bandeau.portal_type == 'Folder': bdict['id'] = bandeau.id bdict['content'] = ObjectView(bandeau, self.request, 'folder_renderer.pt') else: bdict['id'] = bandeau.id bdict['content'] = bandeau() bandeauxList.append(bdict) if not base_ajax_content_load: delattr(self.request, 'ajax_content_load') if not base_ajax_load: delattr(self.request, 'ajax_load') return bandeauxList
class ImageScalingTests(unittest.TestCase): layer = PLONE_NAMEDFILE_INTEGRATION_TESTING def setUp(self): data = getFile('image.png') item = DummyContent() item.image = NamedImage(data, 'image/png', u'image.png') self.layer['app']._setOb('item', item) self.item = self.layer['app'].item self.scaling = ImageScaling(self.item, None) def testCreateScale(self): foo = self.scaling.scale('image', width=100, height=80) self.assertTrue(foo.uid) self.assertEqual(foo.mimetype, 'image/png') self.assertIsInstance(foo.mimetype, str) self.assertEqual(foo.data.contentType, 'image/png') self.assertIsInstance(foo.data.contentType, str) self.assertEqual(foo.width, 80) self.assertEqual(foo.height, 80) assertImage(self, foo.data.data, 'PNG', (80, 80)) def testCreateHighPixelDensityScale(self): self.scaling.getHighPixelDensityScales = lambda: [{'scale': 2, 'quality': 66}] foo = self.scaling.scale('image', width=100, height=80) self.assertTrue(foo.srcset) self.assertEqual(foo.srcset[0]['mimetype'], 'image/png') self.assertEqual(foo.srcset[0]['height'], 160) self.assertEqual(foo.srcset[0]['width'], 160) assertImage(self, foo.srcset[0]['data'].data, 'PNG', (160, 160)) def testCreateScaleWithoutData(self): item = DummyContent() scaling = ImageScaling(item, None) foo = scaling.scale('image', width=100, height=80) self.assertEqual(foo, None) def testCreateHighPixelDensityScaleWithoutData(self): item = DummyContent() scaling = ImageScaling(item, None) scaling.getHighPixelDensityScales = lambda: [{'scale': 2, 'quality': 66}] foo = scaling.scale('image', width=100, height=80) self.assertFalse(hasattr(foo, 'srcset')) def testGetScaleByName(self): self.scaling.available_sizes = {'foo': (60, 60)} foo = self.scaling.scale('image', scale='foo') self.assertTrue(foo.uid) self.assertEqual(foo.mimetype, 'image/png') self.assertIsInstance(foo.mimetype, str) self.assertEqual(foo.data.contentType, 'image/png') self.assertIsInstance(foo.data.contentType, str) self.assertEqual(foo.width, 60) self.assertEqual(foo.height, 60) assertImage(self, foo.data.data, 'PNG', (60, 60)) expected_url = re.compile( r'http://nohost/item/@@images/[-a-z0-9]{36}\.png') self.assertTrue(expected_url.match(foo.absolute_url())) self.assertEqual(foo.url, foo.absolute_url()) tag = foo.tag() base = self.item.absolute_url() expected = \ r'<img src="{0}/@@images/([-0-9a-f]{{36}}).(jpeg|gif|png)" ' \ r'alt="foo" title="foo" height="(\d+)" width="(\d+)" />'.format( base, ) groups = re.match(expected, tag).groups() self.assertTrue(groups, tag) def testGetHighPixelDensityScaleByName(self): self.scaling.getHighPixelDensityScales = lambda: [{'scale': 2, 'quality': 66}] self.scaling.available_sizes = {'foo': (60, 60)} foo = self.scaling.scale('image', scale='foo') self.assertTrue(foo.srcset) self.assertEqual(foo.srcset[0]['mimetype'], 'image/png') self.assertEqual(foo.srcset[0]['width'], 120) self.assertEqual(foo.srcset[0]['height'], 120) assertImage(self, foo.srcset[0]['data'].data, 'PNG', (120, 120)) tag = foo.tag() base = self.item.absolute_url() expected = ( r'<img src="{0}'.format(base) + r'/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)" ' r'alt="foo" title="foo" height="(\d+)" width="(\d+)" ' r'srcset="http://nohost/item/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)' r' 2x" />') groups = re.match(expected, tag).groups() self.assertTrue(groups, tag) def testGetRetinaScaleByWidthAndHeight(self): self.scaling.getHighPixelDensityScales = lambda: [{'scale': 2, 'quality': 66}] foo = self.scaling.scale('image', width=60, height=60) self.assertTrue(foo.srcset) self.assertEqual(foo.srcset[0]['mimetype'], 'image/png') self.assertEqual(foo.srcset[0]['width'], 120) self.assertEqual(foo.srcset[0]['height'], 120) assertImage(self, foo.srcset[0]['data'].data, 'PNG', (120, 120)) tag = foo.tag() base = self.item.absolute_url() expected = ( r'<img src="{0}'.format(base) + r'/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)" ' r'alt="foo" title="foo" height="(\d+)" width="(\d+)" ' r'srcset="http://nohost/item/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)' r' 2x" />') groups = re.match(expected, tag).groups() self.assertTrue(groups, tag) def testGetRetinaScaleByWidthOnly(self): self.scaling.getHighPixelDensityScales = lambda: [{'scale': 2, 'quality': 66}] foo = self.scaling.scale('image', width=60) self.assertTrue(foo.srcset) self.assertEqual(foo.srcset[0]['mimetype'], 'image/png') self.assertEqual(foo.srcset[0]['width'], 120) self.assertEqual(foo.srcset[0]['height'], 120) assertImage(self, foo.srcset[0]['data'].data, 'PNG', (120, 120)) tag = foo.tag() base = self.item.absolute_url() expected = ( r'<img src="{0}'.format(base) + r'/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)" ' r'alt="foo" title="foo" height="(\d+)" width="(\d+)" ' r'srcset="http://nohost/item/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)' r' 2x" />') groups = re.match(expected, tag).groups() self.assertTrue(groups, tag) def testGetRetinaScaleByHeightOnly(self): self.scaling.getHighPixelDensityScales = lambda: [{'scale': 2, 'quality': 66}] foo = self.scaling.scale('image', height=60) self.assertTrue(foo.srcset) self.assertEqual(foo.srcset[0]['mimetype'], 'image/png') self.assertEqual(foo.srcset[0]['width'], 120) self.assertEqual(foo.srcset[0]['height'], 120) assertImage(self, foo.srcset[0]['data'].data, 'PNG', (120, 120)) tag = foo.tag() base = self.item.absolute_url() expected = ( r'<img src="{0}'.format(base) + r'/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)" ' r'alt="foo" title="foo" height="(\d+)" width="(\d+)" ' r'srcset="http://nohost/item/@@images/([-0-9a-f]{36})' r'.(jpeg|gif|png)' r' 2x" />') groups = re.match(expected, tag).groups() self.assertTrue(groups, tag) def testGetUnknownScale(self): foo = self.scaling.scale('image', scale='foo?') self.assertEqual(foo, None) def testScaleInvalidation(self): # first get the scale of the original image self.scaling.available_sizes = {'foo': (23, 23)} foo1 = self.scaling.scale('image', scale='foo') wait_to_ensure_modified() # now upload a new one and make sure the scale has changed data = getFile('image.jpg') self.item.image = NamedImage(data, 'image/jpeg', u'image.jpg') foo2 = self.scaling.scale('image', scale='foo') self.assertFalse(foo1.data == foo2.data, 'scale not updated?') def testCustomSizeChange(self): # set custom image sizes & view a scale self.scaling.available_sizes = {'foo': (23, 23)} foo = self.scaling.scale('image', scale='foo') self.assertEqual(foo.width, 23) self.assertEqual(foo.height, 23) # now let's update the scale dimensions, after which the scale # shouldn't be the same... self.scaling.available_sizes = {'foo': (42, 42)} foo = self.scaling.scale('image', scale='foo') self.assertEqual(foo.width, 42) self.assertEqual(foo.height, 42) def testAvailableSizes(self): # by default, no named scales are configured self.assertEqual(self.scaling.available_sizes, {}) # a callable can be used to look up the available sizes def custom_available_sizes(): return {'bar': (10, 10)} sm = getSiteManager() sm.registerUtility(component=custom_available_sizes, provided=IAvailableSizes) self.assertEqual(self.scaling.available_sizes, {'bar': (10, 10)}) sm.unregisterUtility(provided=IAvailableSizes) # for testing purposes, the sizes may also be set directly on # the scaling adapter self.scaling.available_sizes = {'qux': (12, 12)} self.assertEqual(self.scaling.available_sizes, {'qux': (12, 12)}) def testGuardedAccess(self): # make sure it's not possible to access scales of forbidden images self.item.__allow_access_to_unprotected_subobjects__ = 0 self.assertRaises(Unauthorized, self.scaling.guarded_orig_image, 'image') self.item.__allow_access_to_unprotected_subobjects__ = 1 def testGetAvailableSizes(self): self.scaling.available_sizes = {'foo': (60, 60)} assert self.scaling.getAvailableSizes('image') == {'foo': (60, 60)} def testGetImageSize(self): assert self.scaling.getImageSize('image') == (200, 200) def testGetOriginalScaleTag(self): tag = self.scaling.tag('image') base = self.item.absolute_url() expected = \ r'<img src="{0}/@@images/([-0-9a-f]{{36}}).(jpeg|gif|png)" ' \ r'alt="foo" title="foo" height="(\d+)" width="(\d+)" />'.format( base, ) self.assertTrue(re.match(expected, tag).groups()) def testScaleOnItemWithNonASCIITitle(self): self.item.title = u'ü' tag = self.scaling.tag('image') base = self.item.absolute_url() expected = \ r'<img src="{0}/@@images/([-0-9a-f]{{36}}).(jpeg|gif|png)" ' \ r'alt="\xfc" title="\xfc" height="(\d+)" width="(\d+)" />'.format( base, ) self.assertTrue(re.match(expected, tag).groups()) def testScaleOnItemWithUnicodeTitle(self): self.item.Title = lambda: u'ü' tag = self.scaling.tag('image') base = self.item.absolute_url() expected = \ r'<img src="{0}/@@images/([-0-9a-f]{{36}}).(jpeg|gif|png)" ' \ r'alt="\xfc" title="\xfc" height="(\d+)" width="(\d+)" />'.format( base, ) self.assertTrue(re.match(expected, tag).groups()) def testScaledJpegImageQuality(self): """Test image quality setting for jpeg images. Image quality not available for PNG images. """ data = getFile('image.jpg') item = DummyContent() item.image = NamedImage(data, 'image/png', u'image.jpg') scaling = ImageScaling(item, None) # scale an image, record its size foo = scaling.scale('image', width=100, height=80) size_foo = foo.data.getSize() # let's pretend p.a.imaging set the scaling quality to "really sloppy" gsm = getGlobalSiteManager() qualitySupplier = DummyQualitySupplier() gsm.registerUtility(qualitySupplier.getQuality, IScaledImageQuality) wait_to_ensure_modified() # now scale again bar = scaling.scale('image', width=100, height=80) size_bar = bar.data.getSize() # first one should be bigger self.assertTrue(size_foo > size_bar) def testOversizedHighPixelDensityScale(self): orig_size = max(self.scaling.getImageSize('image')) scale_size = orig_size / 2 self.scaling.getHighPixelDensityScales = lambda: [ {'scale': 2, 'quality': 66}, {'scale': 3, 'quality': 66}] foo = self.scaling.scale('image', width=scale_size, height=scale_size) self.assertEqual(len(foo.srcset), 1) self.assertEqual(foo.srcset[0]['scale'], 2)