def test_store(self):
"""store successfully stores and deletes avatar"""
User = get_user_model()
test_user = User.objects.create_user('Bob', '*****@*****.**', 'pass123')
test_image = Image.new("RGBA", (100, 100), 0)
store.store_avatar(test_user, test_image)
# Assert that avatar was stored
avatar_dir = store.get_existing_avatars_dir(test_user)
for size in settings.MISAGO_AVATARS_SIZES:
avatar = path('%s/%s_%s.png' % (avatar_dir, test_user.pk, size))
self.assertTrue(avatar.exists())
self.assertTrue(avatar.isfile())
# Delete avatar and assert its gone
store.delete_avatar(test_user)
for size in settings.MISAGO_AVATARS_SIZES:
avatar = path('%s/%s_%s.png' % (avatar_dir, test_user.pk, size))
self.assertFalse(avatar.exists())
# Override new avatar and test that it was changed
store.store_avatar(test_user, test_image)
store.store_new_avatar(test_user, test_image)
for size in settings.MISAGO_AVATARS_SIZES:
avatar = path('%s/%s_%s.png' % (avatar_dir, test_user.pk, size))
self.assertTrue(avatar.exists())
self.assertTrue(avatar.isfile())
# Delete avatar
store.delete_avatar(test_user)
def test_store(self):
"""store successfully stores and deletes avatar"""
User = get_user_model()
test_user = User.objects.create_user('Bob', '*****@*****.**', 'pass123')
test_image = Image.new("RGBA", (100, 100), 0)
store.store_avatar(test_user, test_image)
# Assert that avatar was stored
avatar_dir = store.get_existing_avatars_dir(test_user)
for size in settings.MISAGO_AVATARS_SIZES:
avatar = Path('%s/%s_%s.png' % (avatar_dir, test_user.pk, size))
self.assertTrue(avatar.exists())
self.assertTrue(avatar.isfile())
# Delete avatar and assert its gone
store.delete_avatar(test_user)
for size in settings.MISAGO_AVATARS_SIZES:
avatar = Path('%s/%s_%s.png' % (avatar_dir, test_user.pk, size))
self.assertFalse(avatar.exists())
# Override new avatar and test that it was changed
store.store_avatar(test_user, test_image)
store.store_new_avatar(test_user, test_image)
for size in settings.MISAGO_AVATARS_SIZES:
avatar = Path('%s/%s_%s.png' % (avatar_dir, test_user.pk, size))
self.assertTrue(avatar.exists())
self.assertTrue(avatar.isfile())
# Delete avatar
store.delete_avatar(test_user)
def test_store(self):
"""store successfully stores and deletes avatar"""
User = get_user_model()
test_user = User.objects.create_user('Bob', '*****@*****.**', 'pass123')
test_image = Image.new("RGBA", (100, 100), 0)
store.store_avatar(test_user, test_image)
# Assert that avatar was stored
avatar_dir = store.get_existing_avatars_dir(test_user)
for size in settings.MISAGO_AVATARS_SIZES:
avatar = Path('%s/%s_%s.png' % (avatar_dir, test_user.pk, size))
self.assertTrue(avatar.exists())
self.assertTrue(avatar.isfile())
# Delete avatar and assert its gone
store.delete_avatar(test_user)
for size in settings.MISAGO_AVATARS_SIZES:
avatar = Path('%s/%s_%s.png' % (avatar_dir, test_user.pk, size))
self.assertFalse(avatar.exists())
# Override new avatar and test that it was changed
store.store_avatar(test_user, test_image)
store.store_new_avatar(test_user, test_image)
for size in settings.MISAGO_AVATARS_SIZES:
avatar = Path('%s/%s_%s.png' % (avatar_dir, test_user.pk, size))
self.assertTrue(avatar.exists())
self.assertTrue(avatar.isfile())
# Compute avatar hash
test_user.avatar_hash = store.get_avatar_hash(test_user)
self.assertEqual(len(test_user.avatar_hash), 8)
test_user.save(update_fields=['avatar_hash'])
# Get avatar tokens
tokens = store.get_user_avatar_tokens(test_user)
self.assertEqual(tokens[tokens['org']], 'org')
self.assertEqual(tokens[tokens['tmp']], 'tmp')
# Delete avatar
store.delete_avatar(test_user)
for size in settings.MISAGO_AVATARS_SIZES:
avatar = Path('%s/%s_%s.png' % (avatar_dir, test_user.pk, size))
self.assertFalse(avatar.exists())
def test_store(self):
"""store successfully stores and deletes avatar"""
User = get_user_model()
test_user = User.objects.create_user('Bob', '*****@*****.**', 'pass123')
test_image = Image.new("RGBA", (100, 100), 0)
store.store_avatar(test_user, test_image)
# Assert that avatar was stored
avatar_dir = store.get_existing_avatars_dir(test_user)
for size in settings.MISAGO_AVATARS_SIZES:
avatar = Path('%s/%s_%s.png' % (avatar_dir, test_user.pk, size))
self.assertTrue(avatar.exists())
self.assertTrue(avatar.isfile())
# Delete avatar and assert its gone
store.delete_avatar(test_user)
for size in settings.MISAGO_AVATARS_SIZES:
avatar = Path('%s/%s_%s.png' % (avatar_dir, test_user.pk, size))
self.assertFalse(avatar.exists())
# Override new avatar and test that it was changed
store.store_avatar(test_user, test_image)
store.store_new_avatar(test_user, test_image)
for size in settings.MISAGO_AVATARS_SIZES:
avatar = Path('%s/%s_%s.png' % (avatar_dir, test_user.pk, size))
self.assertTrue(avatar.exists())
self.assertTrue(avatar.isfile())
# Compute avatar hash
test_user.avatar_hash = store.get_avatar_hash(test_user)
self.assertEqual(len(test_user.avatar_hash), 8)
test_user.save(update_fields=['avatar_hash'])
# Get avatar tokens
tokens = store.get_user_avatar_tokens(test_user)
self.assertEqual(tokens[tokens['org']], 'org')
self.assertEqual(tokens[tokens['tmp']], 'tmp')
# Delete avatar
store.delete_avatar(test_user)
for size in settings.MISAGO_AVATARS_SIZES:
avatar = Path('%s/%s_%s.png' % (avatar_dir, test_user.pk, size))
self.assertFalse(avatar.exists())
def setUp(self):
User = get_user_model()
self.user = User.objects.create_user(
'Bob', '*****@*****.**', 'pass123')
store.delete_avatar(self.user)
def tearDown(self):
store.delete_avatar(self.user)
def test_store(self):
"""store successfully stores and deletes avatar"""
user = UserModel.objects.create_user('Bob', '*****@*****.**', 'pass123')
test_image = Image.new("RGBA", (100, 100), 0)
store.store_new_avatar(user, test_image)
# reload user
UserModel.objects.get(pk=user.pk)
# assert that avatars were stored in media
avatars_dict = {}
for avatar in user.avatar_set.all():
self.assertTrue(avatar.image.url)
self.assertEqual(avatar.url, avatar.image.url)
avatars_dict[avatar.size] = avatar
# asserts that user.avatars cache was set
self.assertEqual(len(avatars_dict), len(settings.MISAGO_AVATARS_SIZES))
self.assertEqual(len(user.avatars), len(settings.MISAGO_AVATARS_SIZES))
self.assertEqual(len(user.avatars), len(avatars_dict))
for avatar in user.avatars:
self.assertIn(avatar['size'], settings.MISAGO_AVATARS_SIZES)
self.assertEqual(avatar['url'], avatars_dict[avatar['size']].url)
# another avatar change deleted old avatars
store.store_new_avatar(user, test_image)
for old_avatar in avatars_dict.values():
avatar_path = Path(old_avatar.image.path)
self.assertFalse(avatar_path.exists())
self.assertFalse(avatar_path.is_file())
with self.assertRaises(Avatar.DoesNotExist):
Avatar.objects.get(pk=old_avatar.pk)
# and updated user avatars again
new_avatars_dict = {}
for size in settings.MISAGO_AVATARS_SIZES:
avatar = user.avatar_set.get(size=size)
self.assertTrue(avatar.image.url)
self.assertEqual(avatar.url, avatar.image.url)
new_avatars_dict[size] = avatar
self.assertTrue(avatars_dict != new_avatars_dict)
# asserts that user.avatars cache was updated
self.assertEqual(len(user.avatars), len(settings.MISAGO_AVATARS_SIZES))
for avatar in user.avatars:
self.assertIn(avatar['size'], settings.MISAGO_AVATARS_SIZES)
self.assertEqual(avatar['url'],
new_avatars_dict[avatar['size']].url)
# delete avatar
store.delete_avatar(user)
for removed_avatar in new_avatars_dict.values():
avatar_path = Path(removed_avatar.image.path)
self.assertFalse(avatar_path.exists())
self.assertFalse(avatar_path.is_file())
with self.assertRaises(Avatar.DoesNotExist):
Avatar.objects.get(pk=removed_avatar.pk)
def test_avatar_upload_and_crop(self):
"""avatar can be uploaded and cropped"""
response = self.client.post(self.link, data={'avatar': 'upload'})
self.assertContains(response, "No file was sent.", status_code=400)
with open(TEST_AVATAR_PATH, 'rb') as avatar:
response = self.client.post(self.link, data={'avatar': 'upload', 'image': avatar})
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertTrue(response_json['crop_tmp'])
self.assertEqual(
self.get_current_user().avatar_tmp.url, response_json['crop_tmp']['url']
)
avatar = Path(self.get_current_user().avatar_tmp.path)
self.assertTrue(avatar.exists())
self.assertTrue(avatar.is_file())
response = self.client.post(
self.link,
json.dumps({
'avatar': 'crop_tmp',
'crop': {
'offset': {
'x': 0,
'y': 0
},
'zoom': 1,
},
}),
content_type="application/json",
)
response_json = response.json()
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Uploaded avatar was set.")
self.assertFalse(self.get_current_user().avatar_tmp)
self.assertOldAvatarsAreDeleted(self.user)
avatar = Path(self.get_current_user().avatar_src.path)
self.assertTrue(avatar.exists())
self.assertTrue(avatar.is_file())
response = self.client.post(
self.link,
json.dumps({
'avatar': 'crop_tmp',
'crop': {
'offset': {
'x': 0,
'y': 0
},
'zoom': 1,
},
}),
content_type="application/json",
)
self.assertContains(response, "This avatar type is not allowed.", status_code=400)
response = self.client.post(
self.link,
json.dumps({
'avatar': 'crop_src',
'crop': {
'offset': {
'x': 0,
'y': 0
},
'zoom': 1,
},
}),
content_type="application/json",
)
self.assertContains(response, "Avatar was re-cropped.")
self.assertOldAvatarsAreDeleted(self.user)
# delete user avatars, test if it deletes src and tmp
store.delete_avatar(self.get_current_user())
self.assertTrue(self.get_current_user().avatar_src.path)
avatar = Path(self.get_current_user().avatar_src.path)
self.assertFalse(avatar.exists())
self.assertFalse(avatar.is_file())
def setUp(self):
User = get_user_model()
self.user = User.objects.create_user('Bob', '*****@*****.**',
'pass123')
store.delete_avatar(self.user)
def setUp(self):
super(AvatarUploadTests, self).setUp()
store.delete_avatar(self.user)
def delete_avatar(user):
store.delete_avatar(user)
def delete_avatar(user):
store.delete_avatar(user)
def test_avatar_upload_and_crop(self):
"""avatar can be uploaded and cropped"""
response = self.client.post(self.link, data={'avatar': 'generated'})
self.assertEqual(response.status_code, 200)
self.assertAvatarChanged(response,
"New avatar based on your account was set.")
response = self.client.post(self.link, data={'avatar': 'upload'})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
'detail':
"No file was sent.", # fixme: detail with status 400 is no no
})
with open(TEST_AVATAR_PATH, 'rb') as avatar:
response = self.client.post(self.link,
data={
'avatar': 'upload',
'image': avatar
})
self.assertEqual(response.status_code, 200)
avatar_json = response.json()
self.assertTrue(avatar_json['crop_tmp'])
self.assertEqual(self.get_current_user().avatar_tmp.url,
avatar_json['crop_tmp']['url'])
avatar = Path(self.get_current_user().avatar_tmp.path)
self.assertTrue(avatar.exists())
self.assertTrue(avatar.isfile())
response = self.client.post(
self.link,
json.dumps({
'avatar': 'crop_tmp',
'crop': {
'offset': {
'x': 0,
'y': 0
},
'zoom': 1,
},
}),
content_type="application/json",
)
self.assertEqual(response.status_code, 200)
self.assertAvatarChanged(response, "Uploaded avatar was set.")
self.assertFalse(self.get_current_user().avatar_tmp)
avatar = Path(self.get_current_user().avatar_src.path)
self.assertTrue(avatar.exists())
self.assertTrue(avatar.isfile())
response = self.client.post(
self.link,
json.dumps({
'avatar': 'crop_tmp',
'crop': {
'offset': {
'x': 0,
'y': 0
},
'zoom': 1,
},
}),
content_type="application/json",
)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {
'detail': "This avatar type is not allowed.",
})
response = self.client.post(
self.link,
json.dumps({
'avatar': 'crop_src',
'crop': {
'offset': {
'x': 0,
'y': 0
},
'zoom': 1,
},
}),
content_type="application/json",
)
self.assertAvatarChanged(response, "Avatar was re-cropped.")
# delete user avatars, test if it deletes src and tmp
store.delete_avatar(self.get_current_user())
self.assertTrue(self.get_current_user().avatar_src.path)
avatar = Path(self.get_current_user().avatar_src.path)
self.assertFalse(avatar.exists())
self.assertFalse(avatar.isfile())
def test_store(self):
"""store successfully stores and deletes avatar"""
user = UserModel.objects.create_user('Bob', '*****@*****.**', 'pass123')
test_image = Image.new("RGBA", (100, 100), 0)
store.store_new_avatar(user, test_image)
# reload user
UserModel.objects.get(pk=user.pk)
# assert that avatars were stored in media
avatars_dict = {}
for avatar in user.avatar_set.all():
self.assertTrue(avatar.image.url)
self.assertEqual(avatar.url, avatar.image.url)
avatars_dict[avatar.size] = avatar
# asserts that user.avatars cache was set
self.assertEqual(len(avatars_dict), len(settings.MISAGO_AVATARS_SIZES))
self.assertEqual(len(user.avatars), len(settings.MISAGO_AVATARS_SIZES))
self.assertEqual(len(user.avatars), len(avatars_dict))
for avatar in user.avatars:
self.assertIn(avatar['size'], settings.MISAGO_AVATARS_SIZES)
self.assertEqual(avatar['url'], avatars_dict[avatar['size']].url)
# another avatar change deleted old avatars
store.store_new_avatar(user, test_image)
for old_avatar in avatars_dict.values():
avatar_path = Path(old_avatar.image.path)
self.assertFalse(avatar_path.exists())
self.assertFalse(avatar_path.isfile())
with self.assertRaises(Avatar.DoesNotExist):
Avatar.objects.get(pk=old_avatar.pk)
# and updated user avatars again
new_avatars_dict = {}
for size in settings.MISAGO_AVATARS_SIZES:
avatar = user.avatar_set.get(size=size)
self.assertTrue(avatar.image.url)
self.assertEqual(avatar.url, avatar.image.url)
new_avatars_dict[size] = avatar
self.assertTrue(avatars_dict != new_avatars_dict)
# asserts that user.avatars cache was updated
self.assertEqual(len(user.avatars), len(settings.MISAGO_AVATARS_SIZES))
for avatar in user.avatars:
self.assertIn(avatar['size'], settings.MISAGO_AVATARS_SIZES)
self.assertEqual(avatar['url'], new_avatars_dict[avatar['size']].url)
# delete avatar
store.delete_avatar(user)
for removed_avatar in new_avatars_dict.values():
avatar_path = Path(removed_avatar.image.path)
self.assertFalse(avatar_path.exists())
self.assertFalse(avatar_path.isfile())
with self.assertRaises(Avatar.DoesNotExist):
Avatar.objects.get(pk=removed_avatar.pk)
def setUp(self):
super(AvatarUploadTests, self).setUp()
store.delete_avatar(self.user)
def tearDown(self):
store.delete_avatar(self.user)
def test_avatar_upload_and_crop(self):
"""avatar can be uploaded and cropped"""
response = self.client.post(self.link, data={'avatar': 'generated'})
self.assertEqual(response.status_code, 200)
response = self.client.post(self.link, data={'avatar': 'upload'})
self.assertContains(response, "No file was sent.", status_code=400)
with open(TEST_AVATAR_PATH, 'rb') as avatar:
response = self.client.post(self.link, data={'avatar': 'upload', 'image': avatar})
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertTrue(response_json['crop_tmp'])
self.assertEqual(
self.get_current_user().avatar_tmp.url, response_json['crop_tmp']['url']
)
avatar = Path(self.get_current_user().avatar_tmp.path)
self.assertTrue(avatar.exists())
self.assertTrue(avatar.isfile())
response = self.client.post(
self.link,
json.dumps({
'avatar': 'crop_tmp',
'crop': {
'offset': {
'x': 0,
'y': 0
},
'zoom': 1,
},
}),
content_type="application/json",
)
response_json = response.json()
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Uploaded avatar was set.")
self.assertFalse(self.get_current_user().avatar_tmp)
avatar = Path(self.get_current_user().avatar_src.path)
self.assertTrue(avatar.exists())
self.assertTrue(avatar.isfile())
response = self.client.post(
self.link,
json.dumps({
'avatar': 'crop_tmp',
'crop': {
'offset': {
'x': 0,
'y': 0
},
'zoom': 1,
},
}),
content_type="application/json",
)
self.assertContains(response, "This avatar type is not allowed.", status_code=400)
response = self.client.post(
self.link,
json.dumps({
'avatar': 'crop_src',
'crop': {
'offset': {
'x': 0,
'y': 0
},
'zoom': 1,
},
}),
content_type="application/json",
)
self.assertContains(response, "Avatar was re-cropped.")
# delete user avatars, test if it deletes src and tmp
store.delete_avatar(self.get_current_user())
self.assertTrue(self.get_current_user().avatar_src.path)
avatar = Path(self.get_current_user().avatar_src.path)
self.assertFalse(avatar.exists())
self.assertFalse(avatar.isfile())
