mirror of
https://github.com/ae-utbm/sith.git
synced 2026-05-02 19:36:08 +00:00
imperosol
108 lines
4.0 KiB
Python
108 lines
4.0 KiB
Python
from io import BytesIO
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
from django.core.files.base import ContentFile
|
|
from django.test import TestCase
|
|
from model_bakery import baker
|
|
from PIL import Image
|
|
|
|
from core.baker_recipes import old_subscriber_user, subscriber_user
|
|
from core.models import User
|
|
from sas.baker_recipes import picture_recipe
|
|
from sas.models import PeoplePictureRelation, Picture
|
|
|
|
|
|
class TestPictureQuerySet(TestCase):
|
|
@classmethod
|
|
def setUpTestData(cls):
|
|
Picture.objects.all().delete()
|
|
cls.pictures = picture_recipe.make(_quantity=10, _bulk_create=True)
|
|
Picture.objects.filter(pk=cls.pictures[0].id).update(is_moderated=False)
|
|
|
|
def test_root(self):
|
|
root = baker.make(User, is_superuser=True)
|
|
pictures = list(Picture.objects.viewable_by(root).order_by("id"))
|
|
assert pictures == self.pictures
|
|
|
|
def test_subscriber(self):
|
|
"""Test that subscribed users see moderated pictures and pictures they own."""
|
|
subscriber = subscriber_user.make()
|
|
old_subcriber = old_subscriber_user.make()
|
|
qs = Picture.objects.filter(pk=self.pictures[1].id)
|
|
qs.update(is_moderated=False)
|
|
for user in (subscriber, old_subcriber):
|
|
qs.update(owner=user)
|
|
pictures = list(Picture.objects.viewable_by(user).order_by("id"))
|
|
assert pictures == self.pictures[1:]
|
|
|
|
def test_not_subscribed_identified(self):
|
|
"""Public users should only see moderated photos on which they are identified."""
|
|
user = baker.make(
|
|
# This is the guy who asked the feature of making pictures
|
|
# available for tagged users, even if not subscribed
|
|
User,
|
|
first_name="Pierrick",
|
|
last_name="Dheilly",
|
|
nick_name="Sahmer",
|
|
)
|
|
user.pictures.create(picture=self.pictures[0]) # non-moderated
|
|
user.pictures.create(picture=self.pictures[1]) # moderated
|
|
pictures = list(Picture.objects.viewable_by(user))
|
|
assert pictures == [self.pictures[1]]
|
|
|
|
|
|
@pytest.mark.django_db
|
|
def test_identifications_viewable_by_user():
|
|
picture = baker.make(Picture)
|
|
identifications = baker.make(
|
|
PeoplePictureRelation, picture=picture, _quantity=10, _bulk_create=True
|
|
)
|
|
identifications[0].user.is_viewable = False
|
|
identifications[0].user.save()
|
|
|
|
assert (
|
|
list(picture.people.viewable_by(old_subscriber_user.make()))
|
|
== identifications[1:]
|
|
)
|
|
assert (
|
|
list(picture.people.viewable_by(baker.make(User, is_superuser=True)))
|
|
== identifications
|
|
)
|
|
assert list(picture.people.viewable_by(identifications[1].user)) == [
|
|
identifications[1]
|
|
]
|
|
|
|
|
|
@pytest.mark.django_db
|
|
@pytest.mark.parametrize("save", [True, False])
|
|
@pytest.mark.parametrize("initially_saved", [True, False])
|
|
@pytest.mark.parametrize("pass_img_kwarg", [True, False])
|
|
def test_generate_thumbnail(save, initially_saved, pass_img_kwarg):
|
|
"""Test that Picture.generate_thumbnails works properly"""
|
|
image = Image.new("RGB", (2, 1))
|
|
image.putdata([(255, 0, 0), (0, 255, 0)])
|
|
buffer = BytesIO()
|
|
image.save(buffer, format="PNG")
|
|
file = ContentFile(buffer.getvalue(), "img.png")
|
|
picture: Picture = picture_recipe.prepare(
|
|
file=file,
|
|
name=file.name,
|
|
mime_type="image/png",
|
|
_save_related=True,
|
|
)
|
|
if initially_saved:
|
|
picture.save()
|
|
picture.generate_thumbnails(img=image if pass_img_kwarg else None, save=save)
|
|
storage = picture.file.storage
|
|
for f in picture.file, picture.compressed, picture.thumbnail:
|
|
# the tested picture is alone in its album,
|
|
# so there should be a single file in each folder
|
|
assert storage.exists(f.name)
|
|
_dirs, files = storage.listdir(str(Path(f.path).parent))
|
|
assert files == [Path(f.name).name]
|
|
new_img = Image.open(picture.file)
|
|
assert new_img.get_flattened_data() == image.get_flattened_data()
|
|
assert Image.open(picture.thumbnail).size == (200, 100)
|
|
assert Image.open(picture.compressed).size == (1200, 600)
|