def setUp(self):
fp = "img/test.png"
fmt = "png"
self.authorizer = RulesAuthorizer({
"cookie_secret": b"4rakTQJDyhaYgoew802q78pNnsXR7ClvbYtAF1YC87o=",
"token_secret": b"hyQijpEEe9z1OB9NOkHvmSA4lC1B4lu1n80bKNx0Uz0=",
"salt": b"4rakTQJD4lC1B4lu"
})
self.badInfo = ImageInfo(app=None, src_img_fp=fp, src_format=fmt)
self.okayIdent = "67352ccc-d1b0-11e1-89ae-279075081939.jp2"
self.okayInfo = ImageInfo(app=None,
src_img_fp="img/%s" % self.okayIdent,
src_format="jp2")
self.origin = "localhost"
# role to get access is "test"
# en/decryption defaults to return the plain text
self.emptyRequest = MockRequest()
secret = b'-'.join(
[self.authorizer.token_secret,
self.origin.encode('utf8')])
key = base64.urlsafe_b64encode(self.authorizer.kdf().derive(secret))
self.token_fernet = Fernet(key)
tv = self.token_fernet.encrypt(b"localhost|test")
jwt_tv = jwt.encode({u"sub": u"test"}, secret, algorithm='HS256')
jwt_tv_roles = jwt.encode({u"roles": [u'test']},
secret,
algorithm='HS256')
secret = b'-'.join(
[self.authorizer.cookie_secret,
self.origin.encode('utf8')])
key = base64.urlsafe_b64encode(self.authorizer.kdf().derive(secret))
self.cookie_fernet = Fernet(key)
cv = self.cookie_fernet.encrypt(b"localhost|test")
jwt_cv = jwt.encode({"sub": "test"}, secret, algorithm='HS256')
jwt_cv_roles = jwt.encode({"roles": ['test']},
secret,
algorithm='HS256')
self.tokenRequest = MockRequest(headers={
"Authorization": b"Bearer " + tv,
"origin": self.origin
})
self.cookieRequest = MockRequest(headers={"origin": self.origin},
cookies={'iiif_access_cookie': cv})
self.cookieRequest.path = ".../default.jpg"
self.jwtTokenRequest = MockRequest(headers={
"Authorization": b"Bearer " + jwt_tv,
"origin": self.origin
})
self.jwtCookieRequest = MockRequest(
headers={"origin": self.origin},
cookies={'iiif_access_cookie': jwt_cv})
self.jwtCookieRequest.path = ".../default.jpg"
def setUp(self):
ident = "test"
fp = "img/test.png"
fmt = "png"
self.authorizer = SingleDegradingAuthorizer({})
self.badInfo = ImageInfo(None, ident, fp, fmt)
self.okayInfo = ImageInfo(None, "67352ccc-d1b0-11e1-89ae-279075081939.jp2",\
"img/67352ccc-d1b0-11e1-89ae-279075081939.jp2", "jp2")
self.request = MockRequest()
def setUp(self):
fp = "img/test.png"
fmt = "png"
self.authorizer = SingleDegradingAuthorizer({})
self.badInfo = ImageInfo(app=None, src_img_fp=fp, src_format=fmt)
self.okayIdent = "67352ccc-d1b0-11e1-89ae-279075081939.jp2"
self.okayInfo = ImageInfo(app=None,
src_img_fp="img/%s" % self.okayIdent,
src_format="jp2")
self.request = MockRequest()
def test_rights_licensing_properties_in_iiif_json(self):
info = ImageInfo(
src_img_fp=self.test_jpeg_fp,
src_format=self.test_jpeg_fmt,
license='CC-BY',
logo='logo.png',
attribution='Author unknown',
)
info.from_image_file()
iiif_json = json.loads(
info.to_iiif_json(base_uri='http://localhost/1234'))
assert iiif_json['license'] == 'CC-BY'
assert iiif_json['logo'] == 'logo.png'
assert iiif_json['attribution'] == 'Author unknown'
def test_profile_from_json_one_arg_profile(self):
compliance_uri = 'http://iiif.io/api/image/2/level2.json'
existing_info = {'profile': [compliance_uri]}
info = ImageInfo.from_json(json.dumps(existing_info))
assert info.profile.compliance_uri == compliance_uri
assert info.profile.description == {}
def resolve(self, app, ident, base_uri):
ident = unquote(ident)
local_fp = join(self.cache_root, ident)
logger.debug('local_fp: %s' % (local_fp))
if exists(local_fp):
format_ = 'jp2' # FIXME
logger.debug('src image from local disk: %s' % (local_fp, ))
else:
# get image from S3
bucketname = self.s3bucket
keyname = '{0}{1}'.format(self.prefix, ident).strip("/")
logger.debug(
'Getting img from AWS S3. bucketname, keyname: %s, %s' %
(bucketname, keyname))
s3 = boto3.client('s3')
try:
s3.download_file(bucketname, keyname, local_fp)
except botocore.exceptions.ClientError as e:
message = 'Source image not found for identifier: %s.' % (
ident, )
logger.warn(e, message)
raise ResolverException(404, message)
format_ = 'jp2' #FIXME
logger.debug('src format %s' % (format, ))
return ImageInfo(app=app,
src_img_fp=local_fp,
src_format=format_,
auth_rules={})
def setUp(self):
ident = "test"
fp = "img/test.png"
fmt = "png"
self.authorizer = NooneAuthorizer({})
self.info = ImageInfo(None, ident, fp, fmt)
self.request = MockRequest()
def resolve(self, app, ident, base_uri):
try:
key = urllib.unquote(ident)
info_fp = self._get_key_from_file(key, '.info')
try:
cache_info = CacheInfo.load(info_fp)
except CacheException as e:
src_img_fp = self._get_key_from_file(key, '.cache')
obj = self._bucket.Object(key)
obj.load()
with tempfile.NamedTemporaryFile(dir=self._cache_root,
delete=False) as tmp_file:
obj.download_file(tmp_file.name)
if os.path.exists(src_img_fp):
os.remove(tmp_file.name)
else:
os.rename(tmp_file.name, src_img_fp)
cache_info = CacheInfo(ident, src_img_fp, obj)
cache_info.save(info_fp)
except botocore.exceptions.ClientError as e:
self.raise_boto_for_ident(ident, e)
uri = self.fix_base_uri(base_uri)
source_fp = cache_info.src_img_fp
format = cache_info.src_format
extra = self.get_extra_info(ident, source_fp)
return ImageInfo(app, uri, source_fp, format, extra)
def resolve(self, app, ident, base_uri):
cached_file_path = self.cached_file_for_ident(ident)
if not cached_file_path:
cached_file_path = self.copy_to_cache(ident)
format_ = self.get_format(cached_file_path, None)
uri = self.fix_base_uri(base_uri)
extra = self.get_extra_info(ident, cached_file_path)
return ImageInfo(app, uri, cached_file_path, format_, extra)
def test_extrainfo_appears_in_iiif_json(self):
info = ImageInfo(
src_img_fp=self.test_jpeg_fp,
src_format=self.test_jpeg_fmt,
extra={'extraInfo': {
'license': 'CC-BY',
'logo': 'logo.png',
'service': {'@id': 'my_service'},
'attribution': 'Author unknown',
}}
)
info.from_image_file()
iiif_json = json.loads(info.to_iiif_json())
assert iiif_json['license'] == 'CC-BY'
assert iiif_json['logo'] == 'logo.png'
assert iiif_json['service'] == {'@id': 'my_service'}
assert iiif_json['attribution'] == 'Author unknown'
def resolve(self, app, ident, base_uri):
if not self.is_resolvable(ident):
self.raise_404_for_ident(ident)
source_fp = self.source_file_path(ident)
format_ = self.format_from_ident(ident)
uri = self.fix_base_uri(base_uri)
extra = self.get_extra_info(ident, source_fp)
return ImageInfo(app, uri, source_fp, format_, extra)
def resolve(self, app, ident, base_uri):
cached_file_path = self.cached_file_for_ident(ident)
if not cached_file_path:
cached_file_path = self.copy_to_cache(ident)
format_ = self.get_format(cached_file_path, None)
auth_rules = self.get_auth_rules(ident, cached_file_path)
return ImageInfo(app=app,
src_img_fp=cached_file_path,
src_format=format_,
auth_rules=auth_rules)
def resolve(self, app, ident, base_uri):
if not self.is_resolvable(ident):
self.raise_404_for_ident(ident)
source_fp = self.source_file_path(ident)
format_ = self.format_from_ident(ident)
auth_rules = self.get_auth_rules(ident, source_fp)
return ImageInfo(app=app,
src_img_fp=source_fp,
src_format=format_,
auth_rules=auth_rules)
def test_extrainfo_can_override_attributes(self):
info = ImageInfo(extra={'extraInfo': {
'license': 'CC-BY',
'logo': 'logo.png',
'service': {'@id': 'my_service'},
'attribution': 'Author unknown',
}})
assert info.license == 'CC-BY'
assert info.logo == 'logo.png'
assert info.service == {'@id': 'my_service'}
assert info.attribution == 'Author unknown'
def resolve(self, app, ident, base_uri):
'''Return information about the image, caching it if needed.'''
if not self.is_resolvable(ident):
self.raise_404_for_ident(ident)
if not self.in_cache(ident):
self.copy_to_cache(ident)
cache_file_path = self.cache_file_path(ident)
format_ = self.format_from_ident(ident)
uri = self.fix_base_uri(base_uri)
extra = self.get_extra_info(ident, cache_file_path)
return ImageInfo(app, uri, cache_file_path, format_, extra)
def resolve(self, app, ident, base_uri):
if not self.is_resolvable(ident):
self.raise_404_for_ident(ident)
if not self.in_cache(ident):
self.copy_to_cache(ident)
cache_fp = self.cache_file_path(ident)
format_ = self.format_from_ident(ident)
uri = self.fix_base_uri(base_uri)
extra = self.get_extra_info(ident, cache_fp)
logger.info("Cached copy sent %s", cache_fp)
return ImageInfo(app, uri, cache_fp, format_, extra)
def test_profile_from_json_two_arg_profile(self):
compliance_uri = 'http://iiif.io/api/image/2/level2.json'
description = {
'formats': ['jpg', 'png', 'gif', 'webp', 'tif'],
'qualities': ['default', 'bitonal', 'gray', 'color'],
'supports': [
'canonicalLinkHeader', 'profileLinkHeader', 'mirroring',
'rotationArbitrary', 'sizeAboveFull', 'regionSquare'
]
}
existing_info = {'profile': [compliance_uri, description]}
info = ImageInfo.from_json(json.dumps(existing_info))
assert info.profile.compliance_uri == compliance_uri
assert info.profile.description == description
def test_profile_from_json_no_profile(self):
existing_info = {}
info = ImageInfo.from_json(json.dumps(existing_info))
assert info.profile.compliance_uri == ''
assert info.profile.description == {}
def test_invalid_src_format_is_error(self, src_format):
info = ImageInfo(src_format=src_format)
with pytest.raises(ImageInfoException) as exc:
info.from_image_file()
def test_invalid_extra_info_is_imageinfoexception(self):
with pytest.raises(ImageInfoException) as exc:
ImageInfo(extra={'extraInfo': {'foo': 'bar', 'baz': 'bat'}})
assert 'Invalid parameters in extraInfo' in str(exc.value)
def setUp(self):
fp = "img/test.png"
fmt = "png"
self.authorizer = NooneAuthorizer({})
self.info = ImageInfo(app=None, src_img_fp=fp, src_format=fmt)
self.request = MockRequest()
