def test_scrubs_hacked_svg(self):
hacked_svg = open(self.get_hacked_svg_image_path(), 'rb').read()
responses.add(
responses.GET,
self.test_url,
body=hacked_svg,
status=200
)
status_code, storage_name = fetch_remote_file_to_storage(
self.test_url,
upload_to=self.test_uploaded_path,
allowed_mime_types=self.mime_types
)
saved_svg_path = os.path.join('{base_url}/{file_name}'.format(
base_url= default_storage.location,
file_name=storage_name)
)
saved_svg = open(saved_svg_path, 'rb').read()
self.assertNotIn(b'onload', saved_svg)
self.assertNotIn(b'<script>', saved_svg)
def _fetch_image_and_get_file(url, allowed_mime_types, upload_to=''):
status_code, storage_name = fetch_remote_file_to_storage(
url, upload_to=upload_to, allowed_mime_types=allowed_mime_types)
if status_code == 200:
image = DefaultStorage().open(storage_name)
image.name = storage_name
return image
def import_localbadgeclass_to_issuer(apps, schema_editor):
LocalBadgeClass = apps.get_model('composition', 'LocalBadgeClass')
Issuer = apps.get_model('issuer', 'Issuer')
BadgeClass = apps.get_model('issuer', 'BadgeClass')
for local_badgeclass in LocalBadgeClass.objects.all():
issuer = Issuer.objects.get(source='legacy_local_issuer', source_url=local_badgeclass.issuer.identifier)
remote_image_url = local_badgeclass.json.get('image', None)
if local_badgeclass.image:
image = local_badgeclass.image
elif remote_image_url and local_badgeclass.image_preview_status is None:
try:
status_code, image = fetch_remote_file_to_storage(remote_image_url, upload_to=local_badgeclass.image.field.upload_to)
except IOError:
image = None
else:
image = None
new_badgeclass, created = BadgeClass.objects.get_or_create(
source='legacy_local_badgeclass',
source_url=local_badgeclass.identifier,
defaults={
'created_by': local_badgeclass.created_by,
'name': local_badgeclass.name,
'image': image,
'criteria_text': local_badgeclass.criteria_text,
'issuer': issuer,
'original_json': json.dumps(local_badgeclass.json),
'criteria_url': local_badgeclass.json.get('criteria', None),
'description': local_badgeclass.json.get('description', None),
}
)
new_badgeclass.created_at = new_badgeclass.created_at # Avoid auto-now behavior
new_badgeclass.save()
def test_remote_url_is_data_uri(self):
data_uri_as_url = open(self.get_test_image_data_uri()).read()
status_code, storage_name = fetch_remote_file_to_storage(
data_uri_as_url,
upload_to=self.test_uploaded_path,
allowed_mime_types=self.mime_types)
self.assertEqual(status_code, 200)
def handle(self, *args, **options):
# save the placeholder image to storage if needed
store = DefaultStorage()
placeholder_storage_name = "placeholder/badge-failed.svg"
if not store.exists(placeholder_storage_name):
with open(os.path.join(TOP_DIR, 'apps', 'mainsite', 'static', 'badgr-ui', 'images', 'badge-failed.svg'), 'r') as fh:
store.save(placeholder_storage_name, fh)
report = {
'total': 0,
'saved': 0,
'placeholders_saved': 0,
'status_codes': {},
'ioerrors': [],
'no_image_url': [],
'json_error': []
}
badgeclasses_missing_images = BadgeClass.objects.filter(image='')
report['total'] = len(badgeclasses_missing_images)
self.stdout.write("Processing {} badgeclasses missing images...".format(report['total']))
for badgeclass in badgeclasses_missing_images:
try:
original_json = json.loads(badgeclass.original_json)
except ValueError:
report['json_error'].append(badgeclass.pk)
else:
remote_image_url = original_json.get('image', None)
if remote_image_url:
try:
status_code, image = fetch_remote_file_to_storage(remote_image_url, upload_to=badgeclass.image.field.upload_to)
except IOError as e:
self.stdout.write("IOError fetching '{}': {}".format(remote_image_url, str(e)))
report['ioerrors'].append((remote_image_url, str(e)))
else:
report['status_codes'][status_code] = report['status_codes'].get(status_code, []) + [remote_image_url]
if status_code == 200:
badgeclass.image = image
badgeclass.save()
report['saved'] += 1
self.stdout.write("Saved missing image for badgeclass(pk={}) from '{}'".format(badgeclass.pk, remote_image_url))
continue # shortcircuit failure handling at end of loop
else:
self.stdout.write("Http error fetching '{}': {}".format(remote_image_url, status_code))
else:
report['no_image_url'].append(badgeclass.pk)
self.stdout.write("Unable to determine an image url for badgeclass(pk={})".format(badgeclass.pk))
# all errors should fall through to here
if not badgeclass.image:
report['placeholders_saved'] += 1
badgeclass.image = placeholder_storage_name
badgeclass.save()
self.stdout.write(json.dumps(report, indent=2))
def test_fetch_remote_file_to_storage_with_an_unsupported_mimetype_throws_UnsupportedMediaType(self):
responses.add(
responses.GET,
self.test_url,
body=open(self.get_test_jpeg_image_path(), 'rb').read(),
status=200
)
with self.assertRaises(UnsupportedMediaType):
status_code, storage_name = fetch_remote_file_to_storage(
self.test_url,
upload_to=self.test_uploaded_path,
allowed_mime_types= ['image/png', 'image/svg+xml']
)
def test_svg_with_extension(self):
expected_extension = '.svg'
responses.add(responses.GET,
self.test_url,
body=open(self.get_test_svg_image_path()).read(),
status=200)
status_code, storage_name = fetch_remote_file_to_storage(
self.test_url,
upload_to=self.test_uploaded_path,
allowed_mime_types=self.mime_types)
self.assertTrue(storage_name.endswith(expected_extension))
self.assertTrue(default_storage.size(storage_name) > 0)
def test_fetch_store_and_resize_png_height_from_800_to_512_1to1_ratio(self):
expected_extension = '.png'
responses.add(
responses.GET,
self.test_url,
body=open(self.get_test_image_800x800(), 'rb').read(),
status=200
)
status_code, storage_name = fetch_remote_file_to_storage(
self.test_url,
upload_to=self.test_uploaded_path,
allowed_mime_types=self.mime_types,
resize_to_height=512
)
image = Image.open(os.path.join(self.path_to_mediafiles, storage_name))
self.assertEqual(image.width, 512)
self.assertEqual(image.height, 512)
self.assertTrue(storage_name.endswith(expected_extension))
self.assertTrue(default_storage.size(storage_name) > 0)
def fetch_and_process_logo_uri(self, logo_uri):
return fetch_remote_file_to_storage(
logo_uri,
upload_to='remote/application',
allowed_mime_types=['image/png', 'image/svg+xml'],
resize_to_height=512)
def patched_fetch_and_process_logo_uri(self, logo_uri):
return fetch_remote_file_to_storage(
logo_uri,
upload_to=upload_to_path,
allowed_mime_types=['image/png', 'image/svg+xml'],
resize_to_height=512)
def _fetch_image_and_get_file(url, upload_to=''):
status_code, storage_name = fetch_remote_file_to_storage(url, upload_to=upload_to)
if status_code == 200:
image = DefaultStorage().open(storage_name)
image.name = storage_name
return image
