def test_can_transform_meta_with_orientation(self):
data = TestData(source_width=800,
source_height=600,
target_width=100,
target_height=100,
halign="right",
valign="top",
focal_points=[],
crop_left=None,
crop_top=None,
crop_right=None,
crop_bottom=None,
meta=True)
ctx = data.to_context()
ctx.config.RESPECT_ORIENTATION = True
engine = ctx.modules.engine
trans = Transformer(ctx)
trans.transform(self.handle_transform_with_meta(engine))
expect(self.has_handled).to_be_true()
def test_can_extract_cover(self):
data = TestData(
source_width=800, source_height=600,
target_width=-800, target_height=-600,
halign="right", valign="top",
focal_points=[],
crop_left=None, crop_top=None, crop_right=None, crop_bottom=None
)
ctx = data.to_context()
ctx.request.filters = 'cover()'
ctx.request.image = 'some.gif'
ctx.request.extension = 'GIF'
ctx.request.engine.extension = '.gif'
ctx.config.USE_GIFSICLE_ENGINE = True
engine = ctx.modules.engine
trans = Transformer(ctx)
trans.transform(self.handle_extract_cover(engine))
expect(self.has_handled).to_be_true()
def test_can_resize_with_stretch():
data = TestData(source_width=800,
source_height=600,
target_width=800,
target_height=200,
halign="right",
valign="top",
focal_points=[],
crop_left=None,
crop_top=None,
crop_right=None,
crop_bottom=None,
stretch=True)
ctx = data.to_context()
engine = ctx.modules.engine
trans = Transformer(ctx)
trans.transform(lambda: None)
expect(engine.calls['resize']).to_equal([{
'width': 800,
'height': 200
}])
expect(engine.calls['crop']).to_be_empty()
async def test_invalid_crop(self):
data = TestData(
source_width=800,
source_height=600,
target_width=800,
target_height=600,
halign="right",
valign="top",
focal_points=[],
crop_left=200,
crop_top=0,
crop_right=100,
crop_bottom=100,
)
ctx = data.to_context()
engine = ctx.modules.engine
trans = Transformer(ctx)
await trans.transform()
expect(engine.calls["crop"]).to_be_empty()
async def test_can_transform_with_flip(self):
data = TestData(
source_width=800,
source_height=600,
target_width=-800,
target_height=-600,
halign="right",
valign="top",
focal_points=[],
crop_left=None,
crop_top=None,
crop_right=None,
crop_bottom=None,
)
ctx = data.to_context()
engine = ctx.modules.engine
trans = Transformer(ctx)
await trans.transform()
expect(engine.calls["horizontal_flip"]).to_equal(1)
expect(engine.calls["vertical_flip"]).to_equal(1)
def get_filter(self, filter_name, params_string="", config_context=None):
config = Config(FILTERS=[filter_name],
LOADER='thumbor.loaders.file_loader',
FILE_LOADER_ROOT_PATH=join(dirname(realpath(__file__)),
'fixtures', 'filters'))
importer = Importer(config)
importer.import_modules()
req = RequestParameters()
context = Context(config=config, importer=importer)
context.request = req
context.request.engine = context.modules.engine
if config_context is not None:
config_context(context)
fltr = importer.filters[0]
fltr.pre_compile()
context.transformer = Transformer(context)
return fltr(params_string, context=context)
async def test_get_target_dimensions(self):
data = TestData(
source_width=800,
source_height=600,
target_width=600,
target_height=400,
halign="right",
valign="top",
focal_points=[],
crop_left=200,
crop_top=0,
crop_right=100,
crop_bottom=100,
)
ctx = data.to_context()
trans = Transformer(ctx)
dimensions = trans.get_target_dimensions()
expect(dimensions).to_equal((600, 400))
await trans.transform()
expect(dimensions).to_equal((600, 400))
async def test_can_transform_meta_with_orientation(self):
data = TestData(
source_width=800,
source_height=600,
target_width=100,
target_height=100,
halign="right",
valign="top",
focal_points=[],
crop_left=None,
crop_top=None,
crop_right=None,
crop_bottom=None,
meta=True,
)
ctx = data.to_context()
ctx.config.RESPECT_ORIENTATION = True
engine = ctx.modules.engine
trans = Transformer(ctx)
await trans.transform()
expect(engine.calls["reorientate"]).to_equal(1)
async def test_can_resize_images_with_detection_error_not_ignoring_it(
self, ):
test_data = TestData(
source_width=800,
source_height=600,
target_width=400,
target_height=150,
halign="center",
valign="middle",
focal_points=[],
crop_left=0,
crop_top=75,
crop_right=800,
crop_bottom=375,
)
context = test_data.to_context(detectors=[MockErrorSyncDetector],
ignore_detector_error=False)
trans = Transformer(context)
with expect.error_to_happen(Exception, message="x"):
await trans.transform()
expect(test_data.engine.calls["resize"]).to_length(0)
def assert_proper_operations(data):
trans = Transformer(data.to_context())
trans.transform()
assert data.has_cropped_properly(), data.crop_error_message
assert data.has_resized_properly(), data.resize_error_message
def topic(self, callback, topic):
self.test_data = topic
context = topic.to_context(detectors=[MockSyncDetector])
trans = Transformer(context)
trans.transform(callback)
def topic(self, callback, topic):
self.test_data = topic
context = topic.to_context()
trans = Transformer(context)
trans.transform(callback)
async def get_image(self):
"""
This function is called after the PRE_LOAD filters have been applied.
It applies the AFTER_LOAD filters on the result, then crops the image.
"""
try:
result = await self._fetch(self.context.request.image_url)
if not result.successful:
if result.loader_error == LoaderResult.ERROR_NOT_FOUND:
self._error(404)
return
if result.loader_error == LoaderResult.ERROR_UPSTREAM:
# Return a Bad Gateway status if the error
# came from upstream
self._error(502)
return
if result.loader_error == LoaderResult.ERROR_TIMEOUT:
# Return a Gateway Timeout status if upstream
# timed out (i.e. 599)
self._error(504)
return
if isinstance(result.loader_error, int):
self._error(result.loader_error)
return
if (hasattr(result, "engine_error") and result.engine_error
== EngineResult.COULD_NOT_LOAD_IMAGE):
self._error(400)
return
self._error(500)
return
except Exception as error:
msg = (
"[BaseHandler] get_image failed for url `{url}`. error: `{error}`"
).format(url=self.context.request.image_url, error=error)
self.log_exception(*sys.exc_info())
if "cannot identify image file" in str(error):
logger.warning(msg)
self._error(400)
else:
logger.error(msg)
self._error(500)
return
normalized = result.normalized
buffer = result.buffer
engine = result.engine
req = self.context.request
if engine is None:
if buffer is None:
self._error(504)
return
engine = self.context.request.engine
try:
engine.load(buffer, self.context.request.extension)
except Exception as error:
logger.exception("Loading image failed with %s", error)
self._error(504)
return
self.context.transformer = Transformer(self.context)
await self.filters_runner.apply_filters(
thumbor.filters.PHASE_AFTER_LOAD)
self.normalize_crops(normalized, req, engine)
if req.meta:
self.context.transformer.engine = self.context.request.engine = JSONEngine(
engine, req.image_url, req.meta_callback)
await self.context.transformer.transform()
await self.after_transform()
def get_image(self):
"""
This function is called after the PRE_LOAD filters have been applied.
It applies the AFTER_LOAD filters on the result, then crops the image.
"""
try:
result = yield self._fetch(
self.context.request.image_url
)
if not result.successful:
if result.loader_error == LoaderResult.ERROR_NOT_FOUND:
self._error(404)
return
elif result.loader_error == LoaderResult.ERROR_UPSTREAM:
# Return a Bad Gateway status if the error came from upstream
self._error(502)
return
elif result.loader_error == LoaderResult.ERROR_TIMEOUT:
# Return a Gateway Timeout status if upstream timed out (i.e. 599)
self._error(504)
return
elif hasattr(result, 'engine_error') and result.engine_error == EngineResult.COULD_NOT_LOAD_IMAGE:
self._error(400)
return
else:
self._error(500)
return
except Exception as e:
msg = '[BaseHandler] get_image failed for url `{url}`. error: `{error}`'.format(
url=self.context.request.image_url,
error=e
)
self.log_exception(*sys.exc_info())
if 'cannot identify image file' in e.message:
logger.warning(msg)
self._error(400)
else:
logger.error(msg)
self._error(500)
return
normalized = result.normalized
buffer = result.buffer
engine = result.engine
req = self.context.request
if engine is None:
if buffer is None:
self._error(504)
return
engine = self.context.request.engine
try:
engine.load(buffer, self.context.request.extension)
except Exception:
self._error(504)
return
self.context.transformer = Transformer(self.context)
def transform():
self.normalize_crops(normalized, req, engine)
if req.meta:
self.context.transformer.engine = \
self.context.request.engine = \
JSONEngine(engine, req.image_url, req.meta_callback)
after_transform_cb = functools.partial(self.after_transform, self.context)
self.context.transformer.transform(after_transform_cb)
self.filters_runner.apply_filters(thumbor.filters.PHASE_AFTER_LOAD, transform)
def test_can_resize_images(self):
for item in TESTITEMS:
context = item.to_context()
trans = Transformer(context)
trans.transform(self.validate_resize(item))
def test_can_resize_images_with_detectors(self):
for item in TESTITEMS:
context = item.to_context(detectors=[MockSyncDetector])
trans = Transformer(context)
trans.transform(self.validate_resize(item))
