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
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')
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)
