class ImageTest(TestCase):
def setUp(self):
self.gallery = GalleryFactory()
self.image = ImageFactory(gallery=self.gallery)
def tearDown(self):
self.image.delete()
self.gallery.delete()
def test_get_absolute_url(self):
absolute_url = '{0}/{1}'.format(settings.MEDIA_URL, self.image.physical).replace('//', '/')
self.assertEqual(absolute_url, self.image.get_absolute_url())
def test_get_extension(self):
self.assertEqual('jpg', self.image.get_extension())
def test_save_and_delete_image(self):
test_image = ImageFactory(gallery=self.gallery)
image_path = test_image.physical.path
self.assertTrue(os.path.isfile(image_path))
test_image.delete()
self.assertFalse(os.path.isfile(image_path))
class ImageTest(TestCase):
def setUp(self):
self.gallery = GalleryFactory()
self.image = ImageFactory(gallery=self.gallery)
def tearDown(self):
self.image.delete()
self.gallery.delete()
def test_unicode(self):
self.assertEqual(self.image.slug, self.image.__unicode__())
def test_get_absolute_url(self):
absolute_url = u'{0}/{1}'.format(settings.MEDIA_URL, self.image.physical)
self.assertEqual(absolute_url, self.image.get_absolute_url())
def test_get_extension(self):
self.assertEqual('jpg', self.image.get_extension())
def test_save_image(self):
test_image = ImageFactory(gallery=self.gallery)
self.assertTrue(os.path.isfile(test_image.physical.path))
test_image.delete()
self.assertFalse(os.path.isfile(test_image.physical.path))
class UserGalleryTest(TestCase):
def setUp(self):
self.profile = ProfileFactory()
self.gallery = GalleryFactory()
self.image1 = ImageFactory(gallery=self.gallery)
self.image2 = ImageFactory(gallery=self.gallery)
self.user_gallery = UserGalleryFactory(user=self.profile.user, gallery=self.gallery)
def tearDown(self):
self.image1.delete()
self.image2.delete()
self.user_gallery.delete()
self.gallery.delete()
def test_can_write(self):
self.user_gallery.mode = 'W'
self.assertTrue(self.user_gallery.can_write())
self.assertFalse(self.user_gallery.can_read())
def test_can_read(self):
self.user_gallery.mode = 'R'
self.assertFalse(self.user_gallery.can_write())
self.assertTrue(self.user_gallery.can_read())
def test_get_images(self):
self.assertEqual(2, len(self.user_gallery.get_images()))
self.assertEqual(self.image1, self.user_gallery.get_images()[0])
self.assertEqual(self.image2, self.user_gallery.get_images()[1])
class GalleryTest(TestCase):
def setUp(self):
self.profile = ProfileFactory()
self.gallery = GalleryFactory()
self.image1 = ImageFactory(gallery=self.gallery)
self.image2 = ImageFactory(gallery=self.gallery)
self.user_gallery = UserGalleryFactory(user=self.profile.user, gallery=self.gallery)
def tearDown(self):
self.image1.delete()
self.image2.delete()
self.user_gallery.delete()
self.gallery.delete()
def test_unicode(self):
self.assertEqual(self.gallery.title, self.gallery.__unicode__())
def test_get_absolute_url(self):
absolute_url = reverse('zds.gallery.views.gallery_details',
args=[self.gallery.pk, self.gallery.slug])
self.assertEqual(absolute_url, self.gallery.get_absolute_url())
def test_get_users(self):
self.assertEqual(1, len(self.gallery.get_users()))
self.assertEqual(self.user_gallery, self.gallery.get_users()[0])
def test_get_images(self):
self.assertEqual(2, len(self.gallery.get_images()))
self.assertEqual(self.image1, self.gallery.get_images()[0])
self.assertEqual(self.image2, self.gallery.get_images()[1])
def test_get_last_image(self):
self.assertEqual(self.image2, self.gallery.get_last_image())
def test_delete_gallery_with_image(self):
test_gallery = GalleryFactory()
test_image = ImageFactory(gallery=test_gallery)
path_gallery = test_gallery.get_gallery_path()
self.assertTrue(os.path.isdir(path_gallery))
path_image = test_image.physical.path
self.assertTrue(os.path.isfile(path_image))
# Destroy the gallery and the image
test_gallery.delete()
self.assertFalse(os.path.isdir(path_gallery))
self.assertFalse(os.path.isfile(path_image))
def setUp(self):
self.gallery = GalleryFactory()
self.profile1 = ProfileFactory()
self.profile2 = ProfileFactory()
self.profile3 = ProfileFactory()
self.user_gallery1 = UserGalleryFactory(user=self.profile1.user, gallery=self.gallery, mode='W')
self.user_gallery2 = UserGalleryFactory(user=self.profile2.user, gallery=self.gallery, mode='R')
class UserGalleryTest(TestCase):
def setUp(self):
self.profile = ProfileFactory()
self.gallery = GalleryFactory()
self.image1 = ImageFactory(gallery=self.gallery)
self.image2 = ImageFactory(gallery=self.gallery)
self.user_gallery = UserGalleryFactory(user=self.profile.user, gallery=self.gallery)
def tearDown(self):
self.image1.delete()
self.image2.delete()
self.user_gallery.delete()
self.gallery.delete()
def test_unicode(self):
result = u'Galerie "{0}" envoye par {1}'.format(self.gallery, self.profile.user)
self.assertEqual(result, self.user_gallery.__unicode__())
def test_is_write(self):
self.user_gallery.mode = 'W'
self.assertTrue(self.user_gallery.is_write())
self.assertFalse(self.user_gallery.is_read())
def test_is_read(self):
self.user_gallery.mode = 'R'
self.assertFalse(self.user_gallery.is_write())
self.assertTrue(self.user_gallery.is_read())
def test_get_images(self):
self.assertEqual(2, len(self.user_gallery.get_images()))
self.assertEqual(self.image1, self.user_gallery.get_images()[0])
self.assertEqual(self.image2, self.user_gallery.get_images()[1])
def test_get_gallery(self):
gallery_results = self.user_gallery.get_gallery(self.profile.user)
self.assertEqual(1, len(gallery_results))
self.assertEqual(self.gallery, gallery_results[0])
class GalleryTest(TestCase):
def setUp(self):
self.profile = ProfileFactory()
self.gallery = GalleryFactory()
self.image1 = ImageFactory(gallery=self.gallery)
self.image2 = ImageFactory(gallery=self.gallery)
self.user_gallery = UserGalleryFactory(user=self.profile.user, gallery=self.gallery)
def tearDown(self):
self.image1.delete()
self.image2.delete()
self.user_gallery.delete()
self.gallery.delete()
def test_get_absolute_url(self):
absolute_url = reverse('gallery-details',
args=[self.gallery.pk, self.gallery.slug])
self.assertEqual(absolute_url, self.gallery.get_absolute_url())
def test_get_linked_users(self):
self.assertEqual(1, len(self.gallery.get_linked_users()))
self.assertEqual(self.user_gallery, self.gallery.get_linked_users()[0])
def test_get_images(self):
self.assertEqual(2, len(self.gallery.get_images()))
self.assertEqual(self.image1, self.gallery.get_images()[0])
self.assertEqual(self.image2, self.gallery.get_images()[1])
def test_get_last_image(self):
self.assertEqual(self.image2, self.gallery.get_last_image())
def test_delete_empty_gallery(self):
test_gallery = GalleryFactory()
path = test_gallery.get_gallery_path()
test_gallery.delete()
self.assertFalse(os.path.isdir(path))
def test_delete_gallery_with_image(self):
test_gallery = GalleryFactory()
test_image = ImageFactory(gallery=test_gallery)
path_gallery = test_gallery.get_gallery_path()
self.assertTrue(os.path.isdir(path_gallery))
path_image = test_image.physical.path
self.assertTrue(os.path.isfile(path_image))
# Destroy the gallery and the image
test_gallery.delete()
self.assertFalse(os.path.isdir(path_gallery))
self.assertFalse(os.path.isfile(path_image))
class NewImageViewTest(TestCase):
def setUp(self):
self.gallery = GalleryFactory()
self.profile1 = ProfileFactory()
self.profile2 = ProfileFactory()
self.profile3 = ProfileFactory()
self.user_gallery1 = UserGalleryFactory(user=self.profile1.user, gallery=self.gallery, mode='W')
self.user_gallery2 = UserGalleryFactory(user=self.profile2.user, gallery=self.gallery, mode='R')
def test_success_new_image_write_permission(self):
login_check = self.client.login(username=self.profile1.user.username, password='******')
self.assertTrue(login_check)
self.assertEqual(0, len(self.gallery.get_images()))
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'), 'rb') as fp:
response = self.client.post(
reverse(
'gallery-image-new',
args=[self.gallery.pk]
),
{
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True
)
self.assertEqual(200, response.status_code)
self.assertEqual(1, len(self.gallery.get_images()))
self.assertEqual(3, len(os.listdir(self.gallery.get_gallery_path()))) # New image and thumbnail
self.gallery.get_images()[0].delete()
def test_fail_new_image_with_read_permission(self):
login_check = self.client.login(username=self.profile2.user.username, password='******')
self.assertTrue(login_check)
self.assertEqual(0, len(self.gallery.get_images()))
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'), 'rb') as fp:
response = self.client.post(
reverse(
'gallery-image-new',
args=[self.gallery.pk]
),
{
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True
)
self.assertEqual(403, response.status_code)
self.assertEqual(0, len(self.gallery.get_images()))
def test_fail_new_image_with_no_permission(self):
login_check = self.client.login(username=self.profile3.user.username, password='******')
self.assertTrue(login_check)
self.assertEqual(0, len(self.gallery.get_images()))
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'), 'rb') as fp:
response = self.client.post(
reverse(
'gallery-image-new',
args=[self.gallery.pk]
),
{
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True
)
self.assertEqual(403, response.status_code)
self.assertEqual(0, len(self.gallery.get_images()))
def test_fail_gallery_not_exist(self):
login_check = self.client.login(username=self.profile1.user.username, password='******')
self.assertTrue(login_check)
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'), 'rb') as fp:
response = self.client.post(
reverse(
'gallery-image-new',
args=[156]
),
{
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True
)
self.assertEqual(404, response.status_code)
def test_import_images_in_gallery(self):
login_check = self.client.login(username=self.profile1.user.username, password='******')
self.assertTrue(login_check)
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'archive-gallery.zip'), 'rb') as fp:
response = self.client.post(
reverse(
'gallery-image-import',
args=[self.gallery.pk]
),
{
'file': fp
},
follow=False
)
self.assertEqual(302, response.status_code)
img = self.gallery.get_images()[0]
self.assertEqual(Image.objects.filter(gallery=self.gallery).count(), 1)
self.assertEqual('jpg', img.get_extension())
response = self.client.post(
reverse('gallery-image-delete', kwargs={'pk_gallery': self.gallery.pk}),
{
'delete': '',
'image': img.pk
},
follow=True,
)
self.assertEqual(200, response.status_code)
def test_import_images_in_gallery_no_archive(self):
login_check = self.client.login(username=self.profile1.user.username, password='******')
self.assertTrue(login_check)
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'archive-gallery.zip'), 'rb'):
response = self.client.post(
reverse(
'gallery-image-import',
args=[self.gallery.pk]
),
{
# normally we have
# 'file': fp
# but here we want to act as if we forgot it
},
follow=False
)
self.assertEqual(200, response.status_code)
self.assertEqual(Image.objects.filter(gallery=self.gallery).count(), 0)
def test_denies_import_images_in_gallery(self):
login_check = self.client.login(username=self.profile2.user.username, password='******')
self.assertTrue(login_check)
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'archive-gallery.zip'), 'rb') as fp:
response = self.client.post(
reverse(
'gallery-image-import',
args=[self.gallery.pk]
),
{
'file': fp
},
follow=True
)
self.assertEqual(403, response.status_code)
self.assertEqual(Image.objects.filter(gallery=self.gallery).count(), 0)
def setUp(self):
self.profile = ProfileFactory()
self.gallery = GalleryFactory()
self.image1 = ImageFactory(gallery=self.gallery)
self.image2 = ImageFactory(gallery=self.gallery)
self.user_gallery = UserGalleryFactory(user=self.profile.user, gallery=self.gallery)
class EditImageViewTest(TestCase):
def setUp(self):
self.gallery = GalleryFactory()
self.image = ImageFactory(gallery=self.gallery)
self.profile1 = ProfileFactory()
self.profile2 = ProfileFactory()
self.profile3 = ProfileFactory()
self.user_gallery1 = UserGalleryFactory(user=self.profile1.user, gallery=self.gallery, mode='W')
self.user_gallery2 = UserGalleryFactory(user=self.profile2.user, gallery=self.gallery, mode='R')
def tearDown(self):
self.image.delete()
def test_fail_member_no_permission_can_edit_image(self):
login_check = self.client.login(username=self.profile3.user.username, password='******')
self.assertTrue(login_check)
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'), 'rb') as fp:
self.client.post(
reverse(
'gallery-image-edit',
args=[self.gallery.pk, self.image.pk]
),
{
'title': 'modify with no perms',
'legend': 'test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True
)
image_test = Image.objects.get(pk=self.image.pk)
self.assertNotEqual('modify with no perms', image_test.title)
image_test.delete()
def test_success_member_edit_image(self):
login_check = self.client.login(username=self.profile1.user.username, password='******')
self.assertTrue(login_check)
nb_files = len(os.listdir(self.gallery.get_gallery_path()))
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'), 'rb') as fp:
response = self.client.post(
reverse(
'gallery-image-edit',
args=[self.gallery.pk, self.image.pk]
),
{
'title': 'edit title',
'legend': 'dit legend',
'slug': 'edit-slug',
'physical': fp
},
follow=True
)
self.assertEqual(200, response.status_code)
self.assertEqual(nb_files + 3, len(os.listdir(self.gallery.get_gallery_path())))
image_test = Image.objects.get(pk=self.image.pk)
self.assertEqual('edit title', image_test.title)
image_test.delete()
# picture AND thumbnail should be gone
self.assertEqual(nb_files, len(os.listdir(self.gallery.get_gallery_path())))
def test_access_permission(self):
login_check = self.client.login(username=self.profile1.user.username, password='******')
self.assertTrue(login_check)
response = self.client.get(reverse(
'gallery-image-edit',
args=[self.gallery.pk, self.image.pk]
))
self.assertEqual(200, response.status_code)
def setUp(self):
self.gallery = GalleryFactory()
self.image = ImageFactory(gallery=self.gallery)
class EditImageViewTest(TestCase):
def setUp(self):
self.gallery = GalleryFactory()
self.image = ImageFactory(gallery=self.gallery)
self.profile1 = ProfileFactory()
self.profile2 = ProfileFactory()
self.profile3 = ProfileFactory()
self.user_gallery1 = UserGalleryFactory(user=self.profile1.user,
gallery=self.gallery,
mode="W")
self.user_gallery2 = UserGalleryFactory(user=self.profile2.user,
gallery=self.gallery,
mode="R")
def tearDown(self):
self.image.delete()
def test_fail_member_no_permission_can_edit_image(self):
login_check = self.client.login(username=self.profile3.user.username,
password="******")
self.assertTrue(login_check)
with (settings.BASE_DIR / "fixtures" / "logo.png").open("rb") as fp:
self.client.post(
reverse("gallery-image-edit",
args=[self.gallery.pk, self.image.pk]),
{
"title": "modify with no perms",
"legend": "test legend",
"slug": "test-slug",
"physical": fp
},
follow=True,
)
image_test = Image.objects.get(pk=self.image.pk)
self.assertNotEqual("modify with no perms", image_test.title)
image_test.delete()
def test_success_member_edit_image(self):
login_check = self.client.login(username=self.profile1.user.username,
password="******")
self.assertTrue(login_check)
nb_files = len(os.listdir(self.gallery.get_gallery_path()))
with (settings.BASE_DIR / "fixtures" / "logo.png").open("rb") as fp:
response = self.client.post(
reverse("gallery-image-edit",
args=[self.gallery.pk, self.image.pk]),
{
"title": "edit title",
"legend": "dit legend",
"slug": "edit-slug",
"physical": fp
},
follow=True,
)
self.assertEqual(200, response.status_code)
self.assertEqual(nb_files + 3,
len(os.listdir(self.gallery.get_gallery_path())))
image_test = Image.objects.get(pk=self.image.pk)
self.assertEqual("edit title", image_test.title)
image_test.delete()
# picture AND thumbnail should be gone
self.assertEqual(nb_files,
len(os.listdir(self.gallery.get_gallery_path())))
def test_access_permission(self):
login_check = self.client.login(username=self.profile1.user.username,
password="******")
self.assertTrue(login_check)
response = self.client.get(
reverse("gallery-image-edit",
args=[self.gallery.pk, self.image.pk]))
self.assertEqual(200, response.status_code)
class NewImageViewTest(TestCase):
def setUp(self):
self.gallery = GalleryFactory()
self.profile1 = ProfileFactory()
self.profile2 = ProfileFactory()
self.profile3 = ProfileFactory()
self.user_gallery1 = UserGalleryFactory(user=self.profile1.user,
gallery=self.gallery,
mode='W')
self.user_gallery2 = UserGalleryFactory(user=self.profile2.user,
gallery=self.gallery,
mode='R')
def test_success_new_image_write_permission(self):
login_check = self.client.login(username=self.profile1.user.username,
password='******')
self.assertTrue(login_check)
self.assertEqual(0, len(self.gallery.get_images()))
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'),
'rb') as fp:
response = self.client.post(reverse('gallery-image-new',
args=[self.gallery.pk]), {
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True)
self.assertEqual(200, response.status_code)
self.assertEqual(1, len(self.gallery.get_images()))
self.assertEqual(3, len(os.listdir(
self.gallery.get_gallery_path()))) # New image and thumbnail
self.gallery.get_images()[0].delete()
def test_fail_new_image_with_read_permission(self):
login_check = self.client.login(username=self.profile2.user.username,
password='******')
self.assertTrue(login_check)
self.assertEqual(0, len(self.gallery.get_images()))
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'),
'rb') as fp:
response = self.client.post(reverse('gallery-image-new',
args=[self.gallery.pk]), {
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True)
self.assertEqual(403, response.status_code)
self.assertEqual(0, len(self.gallery.get_images()))
def test_fail_new_image_with_no_permission(self):
login_check = self.client.login(username=self.profile3.user.username,
password='******')
self.assertTrue(login_check)
self.assertEqual(0, len(self.gallery.get_images()))
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'),
'rb') as fp:
response = self.client.post(reverse('gallery-image-new',
args=[self.gallery.pk]), {
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True)
self.assertEqual(403, response.status_code)
self.assertEqual(0, len(self.gallery.get_images()))
def test_fail_gallery_not_exist(self):
login_check = self.client.login(username=self.profile1.user.username,
password='******')
self.assertTrue(login_check)
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'),
'rb') as fp:
response = self.client.post(reverse('gallery-image-new',
args=[156]), {
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True)
self.assertEqual(404, response.status_code)
def test_import_images_in_gallery(self):
login_check = self.client.login(username=self.profile1.user.username,
password='******')
self.assertTrue(login_check)
with open(
os.path.join(settings.BASE_DIR, 'fixtures',
'archive-gallery.zip'), 'rb') as fp:
response = self.client.post(reverse('gallery-image-import',
args=[self.gallery.pk]),
{'file': fp},
follow=False)
self.assertEqual(302, response.status_code)
img = self.gallery.get_images()[0]
self.assertEqual(Image.objects.filter(gallery=self.gallery).count(), 1)
self.assertEqual('jpg', img.get_extension())
response = self.client.post(
reverse('gallery-image-delete',
kwargs={'pk_gallery': self.gallery.pk}),
{
'delete': '',
'image': img.pk
},
follow=True,
)
self.assertEqual(200, response.status_code)
def test_import_images_in_gallery_no_archive(self):
login_check = self.client.login(username=self.profile1.user.username,
password='******')
self.assertTrue(login_check)
with open(
os.path.join(settings.BASE_DIR, 'fixtures',
'archive-gallery.zip'), 'rb'):
response = self.client.post(
reverse('gallery-image-import', args=[self.gallery.pk]),
{
# normally we have
# 'file': fp
# but here we want to act as if we forgot it
},
follow=False)
self.assertEqual(200, response.status_code)
self.assertEqual(Image.objects.filter(gallery=self.gallery).count(), 0)
def test_denies_import_images_in_gallery(self):
login_check = self.client.login(username=self.profile2.user.username,
password='******')
self.assertTrue(login_check)
with open(
os.path.join(settings.BASE_DIR, 'fixtures',
'archive-gallery.zip'), 'rb') as fp:
response = self.client.post(reverse('gallery-image-import',
args=[self.gallery.pk]),
{'file': fp},
follow=True)
self.assertEqual(403, response.status_code)
self.assertEqual(Image.objects.filter(gallery=self.gallery).count(), 0)
class NewImageViewTest(TestCase):
def setUp(self):
self.gallery = GalleryFactory()
self.profile1 = ProfileFactory()
self.profile2 = ProfileFactory()
self.profile3 = ProfileFactory()
self.user_gallery1 = UserGalleryFactory(user=self.profile1.user,
gallery=self.gallery,
mode="W")
self.user_gallery2 = UserGalleryFactory(user=self.profile2.user,
gallery=self.gallery,
mode="R")
def test_success_new_image_write_permission(self):
login_check = self.client.login(username=self.profile1.user.username,
password="******")
self.assertTrue(login_check)
self.assertEqual(0, len(self.gallery.get_images()))
with (settings.BASE_DIR / "fixtures" / "logo.png").open("rb") as fp:
response = self.client.post(
reverse("gallery-image-new", args=[self.gallery.pk]),
{
"title": "Test title",
"legend": "Test legend",
"slug": "test-slug",
"physical": fp
},
follow=True,
)
self.assertEqual(200, response.status_code)
self.assertEqual(1, len(self.gallery.get_images()))
self.assertEqual(3, len(os.listdir(
self.gallery.get_gallery_path()))) # New image and thumbnail
self.gallery.get_images()[0].delete()
def test_fail_new_image_with_read_permission(self):
login_check = self.client.login(username=self.profile2.user.username,
password="******")
self.assertTrue(login_check)
self.assertEqual(0, len(self.gallery.get_images()))
with (settings.BASE_DIR / "fixtures" / "logo.png").open("rb") as fp:
response = self.client.post(
reverse("gallery-image-new", args=[self.gallery.pk]),
{
"title": "Test title",
"legend": "Test legend",
"slug": "test-slug",
"physical": fp
},
follow=True,
)
self.assertEqual(403, response.status_code)
self.assertEqual(0, len(self.gallery.get_images()))
def test_fail_new_image_with_no_permission(self):
login_check = self.client.login(username=self.profile3.user.username,
password="******")
self.assertTrue(login_check)
self.assertEqual(0, len(self.gallery.get_images()))
with (settings.BASE_DIR / "fixtures" / "logo.png").open("rb") as fp:
response = self.client.post(
reverse("gallery-image-new", args=[self.gallery.pk]),
{
"title": "Test title",
"legend": "Test legend",
"slug": "test-slug",
"physical": fp
},
follow=True,
)
self.assertEqual(403, response.status_code)
self.assertEqual(0, len(self.gallery.get_images()))
def test_fail_gallery_not_exist(self):
login_check = self.client.login(username=self.profile1.user.username,
password="******")
self.assertTrue(login_check)
with (settings.BASE_DIR / "fixtures" / "logo.png").open("rb") as fp:
response = self.client.post(
reverse("gallery-image-new", args=[156]),
{
"title": "Test title",
"legend": "Test legend",
"slug": "test-slug",
"physical": fp
},
follow=True,
)
self.assertEqual(404, response.status_code)
def test_import_images_in_gallery(self):
login_check = self.client.login(username=self.profile1.user.username,
password="******")
self.assertTrue(login_check)
with (settings.BASE_DIR / "fixtures" /
"archive-gallery.zip").open("rb") as fp:
response = self.client.post(reverse("gallery-image-import",
args=[self.gallery.pk]),
{"file": fp},
follow=False)
self.assertEqual(302, response.status_code)
img = self.gallery.get_images()[0]
self.assertEqual(Image.objects.filter(gallery=self.gallery).count(), 1)
self.assertEqual("jpg", img.get_extension())
response = self.client.post(
reverse("gallery-image-delete",
kwargs={"pk_gallery": self.gallery.pk}),
{
"delete": "",
"image": img.pk
},
follow=True,
)
self.assertEqual(200, response.status_code)
def test_import_images_in_gallery_no_archive(self):
login_check = self.client.login(username=self.profile1.user.username,
password="******")
self.assertTrue(login_check)
with (settings.BASE_DIR / "fixtures" /
"archive-gallery.zip").open("rb"):
response = self.client.post(
reverse("gallery-image-import", args=[self.gallery.pk]),
{
# normally we have
# 'file': fp
# but here we want to act as if we forgot it
},
follow=False,
)
self.assertEqual(200, response.status_code)
self.assertEqual(Image.objects.filter(gallery=self.gallery).count(), 0)
def test_denies_import_images_in_gallery(self):
login_check = self.client.login(username=self.profile2.user.username,
password="******")
self.assertTrue(login_check)
with (settings.BASE_DIR / "fixtures" /
"archive-gallery.zip").open("rb") as fp:
response = self.client.post(reverse("gallery-image-import",
args=[self.gallery.pk]),
{"file": fp},
follow=True)
self.assertEqual(403, response.status_code)
self.assertEqual(Image.objects.filter(gallery=self.gallery).count(), 0)
def test_unregister(self):
"""
To test that unregistering user is working.
"""
# test not logged user can't unregister.
self.client.logout()
result = self.client.post(reverse('zds.member.views.unregister'),
follow=False)
self.assertEqual(result.status_code, 302)
# test logged user can register.
user = ProfileFactory()
login_check = self.client.login(username=user.user.username,
password='******')
self.assertEqual(login_check, True)
result = self.client.post(reverse('zds.member.views.unregister'),
follow=False)
self.assertEqual(result.status_code, 302)
self.assertEqual(
User.objects.filter(username=user.user.username).count(), 0)
# Attach a user at tutorials, articles, topics and private topics. After that,
# unregister this user and check that he is well removed in all contents.
user = ProfileFactory()
user2 = ProfileFactory()
alone_gallery = GalleryFactory()
UserGalleryFactory(gallery=alone_gallery, user=user.user)
shared_gallery = GalleryFactory()
UserGalleryFactory(gallery=shared_gallery, user=user.user)
UserGalleryFactory(gallery=shared_gallery, user=user2.user)
# first case : a published tutorial with only one author
published_tutorial_alone = PublishedContentFactory(type='TUTORIAL')
published_tutorial_alone.authors.add(user.user)
published_tutorial_alone.save()
# second case : a published tutorial with two authors
published_tutorial_2 = PublishedContentFactory(type='TUTORIAL')
published_tutorial_2.authors.add(user.user)
published_tutorial_2.authors.add(user2.user)
published_tutorial_2.save()
# third case : a private tutorial with only one author
writing_tutorial_alone = PublishableContentFactory(type='TUTORIAL')
writing_tutorial_alone.authors.add(user.user)
writing_tutorial_alone.save()
writing_tutorial_alone_galler_path = writing_tutorial_alone.gallery.get_gallery_path(
)
# fourth case : a private tutorial with at least two authors
writing_tutorial_2 = PublishableContentFactory(type='TUTORIAL')
writing_tutorial_2.authors.add(user.user)
writing_tutorial_2.authors.add(user2.user)
writing_tutorial_2.save()
self.client.login(username=self.staff.username, password="******")
# same thing for articles
published_article_alone = PublishedContentFactory(type='ARTICLE')
published_article_alone.authors.add(user.user)
published_article_alone.save()
published_article_2 = PublishedContentFactory(type='ARTICLE')
published_article_2.authors.add(user.user)
published_article_2.authors.add(user2.user)
published_article_2.save()
writing_article_alone = PublishableContentFactory(type='ARTICLE')
writing_article_alone.authors.add(user.user)
writing_article_alone.save()
writing_article_2 = PublishableContentFactory(type='ARTICLE')
writing_article_2.authors.add(user.user)
writing_article_2.authors.add(user2.user)
writing_article_2.save()
# beta content
beta_forum = ForumFactory(category=CategoryFactory())
beta_content = BetaContentFactory(author_list=[user.user],
forum=beta_forum)
beta_content_2 = BetaContentFactory(
author_list=[user.user, user2.user], forum=beta_forum)
# about posts and topics
authored_topic = TopicFactory(author=user.user, forum=self.forum11)
answered_topic = TopicFactory(author=user2.user, forum=self.forum11)
PostFactory(topic=answered_topic, author=user.user, position=2)
edited_answer = PostFactory(topic=answered_topic,
author=user.user,
position=3)
edited_answer.editor = user.user
edited_answer.save()
upvoted_answer = PostFactory(topic=answered_topic,
author=user2.user,
position=4)
upvoted_answer.like += 1
upvoted_answer.save()
CommentLike.objects.create(user=user.user, comments=upvoted_answer)
private_topic = PrivateTopicFactory(author=user.user)
private_topic.participants.add(user2.user)
private_topic.save()
PrivatePostFactory(author=user.user,
privatetopic=private_topic,
position_in_topic=1)
# login and unregister:
login_check = self.client.login(username=user.user.username,
password='******')
self.assertEqual(login_check, True)
result = self.client.post(reverse('zds.member.views.unregister'),
follow=False)
self.assertEqual(result.status_code, 302)
# check that the bot have taken authorship of tutorial:
self.assertEqual(published_tutorial_alone.authors.count(), 1)
self.assertEqual(published_tutorial_alone.authors.first().username,
settings.ZDS_APP["member"]["external_account"])
self.assertFalse(os.path.exists(writing_tutorial_alone_galler_path))
self.assertEqual(published_tutorial_2.authors.count(), 1)
self.assertEqual(
published_tutorial_2.authors.filter(
username=settings.ZDS_APP["member"]
["external_account"]).count(), 0)
# check that published tutorials remain published and accessible
self.assertIsNotNone(
published_tutorial_2.public_version.get_prod_path())
self.assertTrue(
os.path.exists(
published_tutorial_2.public_version.get_prod_path()))
self.assertIsNotNone(
published_tutorial_alone.public_version.get_prod_path())
self.assertTrue(
os.path.exists(
published_tutorial_alone.public_version.get_prod_path()))
self.assertEqual(
self.client.get(reverse('tutorial:view',
args=[
published_tutorial_alone.pk,
published_tutorial_alone.slug
]),
follow=False).status_code, 200)
self.assertEqual(
self.client.get(reverse(
'tutorial:view',
args=[published_tutorial_2.pk, published_tutorial_2.slug]),
follow=False).status_code, 200)
# test that published articles remain accessible
self.assertTrue(
os.path.exists(
published_article_alone.public_version.get_prod_path()))
self.assertEqual(
self.client.get(reverse('article:view',
args=[
published_article_alone.pk,
published_article_alone.slug
]),
follow=True).status_code, 200)
self.assertEqual(
self.client.get(reverse(
'article:view',
args=[published_article_2.pk, published_article_2.slug]),
follow=True).status_code, 200)
# check that the tutorial for which the author was alone does not exists anymore
self.assertEqual(
PublishableContent.objects.filter(
pk=writing_tutorial_alone.pk).count(), 0)
self.assertFalse(os.path.exists(
writing_tutorial_alone.get_repo_path()))
# check that bot haven't take the authorship of the tuto with more than one author
self.assertEqual(writing_tutorial_2.authors.count(), 1)
self.assertEqual(
writing_tutorial_2.authors.filter(
username=settings.ZDS_APP["member"]
["external_account"]).count(), 0)
# authorship for the article for which user was the only author
self.assertEqual(published_article_alone.authors.count(), 1)
self.assertEqual(published_article_alone.authors.first().username,
settings.ZDS_APP["member"]["external_account"])
self.assertEqual(published_article_2.authors.count(), 1)
self.assertEqual(
PublishableContent.objects.filter(
pk=writing_article_alone.pk).count(), 0)
self.assertFalse(os.path.exists(writing_article_alone.get_repo_path()))
# not bot if another author:
self.assertEqual(
published_article_2.authors.filter(
username=settings.ZDS_APP["member"]
["external_account"]).count(), 0)
self.assertEqual(writing_article_2.authors.count(), 1)
self.assertEqual(
writing_article_2.authors.filter(
username=settings.ZDS_APP["member"]
["external_account"]).count(), 0)
# topics, gallery and PMs:
self.assertEqual(
Topic.objects.filter(author__username=user.user.username).count(),
0)
self.assertEqual(
Post.objects.filter(author__username=user.user.username).count(),
0)
self.assertEqual(
Post.objects.filter(editor__username=user.user.username).count(),
0)
self.assertEqual(
PrivatePost.objects.filter(
author__username=user.user.username).count(), 0)
self.assertEqual(
PrivateTopic.objects.filter(
author__username=user.user.username).count(), 0)
self.assertIsNotNone(Topic.objects.get(pk=authored_topic.pk))
self.assertIsNotNone(PrivateTopic.objects.get(pk=private_topic.pk))
self.assertIsNotNone(Gallery.objects.get(pk=alone_gallery.pk))
self.assertEquals(alone_gallery.get_linked_users().count(), 1)
self.assertEquals(shared_gallery.get_linked_users().count(), 1)
self.assertEquals(
UserGallery.objects.filter(user=user.user).count(), 0)
self.assertEquals(
CommentLike.objects.filter(user=user.user).count(), 0)
self.assertEquals(
Post.objects.filter(pk=upvoted_answer.id).first().like, 0)
# zep 12, published contents and beta
self.assertIsNotNone(
PublishedContent.objects.filter(
content__pk=published_tutorial_alone.pk).first())
self.assertIsNotNone(
PublishedContent.objects.filter(
content__pk=published_tutorial_2.pk).first())
self.assertTrue(
Topic.objects.get(pk=beta_content.beta_topic.pk).is_locked)
self.assertFalse(
Topic.objects.get(pk=beta_content_2.beta_topic.pk).is_locked)
def setUp(self):
self.profile = ProfileFactory()
self.gallery = GalleryFactory()
self.image1 = ImageFactory(gallery=self.gallery)
self.image2 = ImageFactory(gallery=self.gallery)
self.user_gallery = UserGalleryFactory(user=self.profile.user, gallery=self.gallery)
def test_toggle(self):
author = ProfileFactory()
login_check = self.client.login(username=author.user.username, password="******")
self.assertTrue(login_check)
# create topic and toggle request
category = ForumCategoryFactory(position=1)
forum = ForumFactory(category=category, position_in_category=1)
topic = TopicFactory(forum=forum, author=author.user)
response = self.client.post(
reverse("topic-edit") + "?topic={}".format(topic.pk),
{"request_featured": 1},
HTTP_X_REQUESTED_WITH="XMLHttpRequest",
)
self.assertEqual(200, response.status_code)
self.assertEqual(FeaturedRequested.objects.count(), 1)
r = FeaturedRequested.objects.last()
self.assertEqual(r.content_object, topic)
self.assertIn(author.user, r.users_voted.all())
# lock topic: cannot vote anymore
topic.is_locked = True
topic.save()
response = self.client.post(
reverse("topic-edit") + "?topic={}".format(topic.pk),
{"request_featured": 1},
HTTP_X_REQUESTED_WITH="XMLHttpRequest",
)
self.assertEqual(403, response.status_code)
self.assertEqual(FeaturedRequested.objects.count(), 1)
# create tutorial and toggle request
tutorial = PublishedContentFactory(author_list=[author.user])
gallery = GalleryFactory()
image = ImageFactory(gallery=gallery)
tutorial.image = image
tutorial.save()
response = self.client.post(
reverse("content:request-featured", kwargs={"pk": tutorial.pk}),
{"request_featured": 1},
HTTP_X_REQUESTED_WITH="XMLHttpRequest",
)
self.assertEqual(200, response.status_code)
self.assertEqual(FeaturedRequested.objects.count(), 2)
r = FeaturedRequested.objects.last()
self.assertEqual(r.content_object, tutorial)
self.assertIn(author.user, r.users_voted.all())
# create opinion: cannot toggle request!
opinion = PublishedContentFactory(type="OPINION", author_list=[author.user])
gallery = GalleryFactory()
image = ImageFactory(gallery=gallery)
opinion.image = image
opinion.save()
response = self.client.post(
reverse("content:request-featured", kwargs={"pk": opinion.pk}),
{"request_featured": 1},
HTTP_X_REQUESTED_WITH="XMLHttpRequest",
)
self.assertEqual(403, response.status_code)
self.assertEqual(FeaturedRequested.objects.count(), 2)
# set tutorial as obsolete: cannot toggle
tutorial.is_obsolete = True
tutorial.save()
response = self.client.post(
reverse("content:request-featured", kwargs={"pk": tutorial.pk}),
{"request_featured": 1},
HTTP_X_REQUESTED_WITH="XMLHttpRequest",
)
self.assertEqual(403, response.status_code)
r = FeaturedRequested.objects.get(pk=r.pk)
self.assertEqual(r.content_object, tutorial)
self.assertIn(author.user, r.users_voted.all())
# reject tutorial proposition
tutorial.is_obsolete = False # can vote again
tutorial.save()
r = FeaturedRequested.objects.get(pk=r.pk)
r.rejected = True
r.save()
# upvote with other user
other = ProfileFactory()
login_check = self.client.login(username=other.user.username, password="******")
self.assertTrue(login_check)
response = self.client.post(
reverse("content:request-featured", kwargs={"pk": tutorial.pk}),
{"request_featured": 1},
HTTP_X_REQUESTED_WITH="XMLHttpRequest",
)
self.assertEqual(200, response.status_code)
r = FeaturedRequested.objects.get(pk=r.pk)
self.assertIn(other.user, r.users_voted.all())
self.assertFalse(r.rejected) # not rejected anymore
# reject for good, cannot vote anymore!
r.rejected_for_good = True
r.save()
response = self.client.post(
reverse("content:request-featured", kwargs={"pk": tutorial.pk}),
{"request_featured": 1},
HTTP_X_REQUESTED_WITH="XMLHttpRequest",
)
self.assertEqual(403, response.status_code)
r = FeaturedRequested.objects.get(pk=r.pk)
self.assertIn(other.user, r.users_voted.all())
def test_invalid_user_gallery_form_noexist_user(self):
gallery = GalleryFactory()
data = {"action": "add", "user": "******", "mode": "W"}
form = UserGalleryForm(gallery=gallery, data=data)
self.assertFalse(form.is_valid())
class NewImageViewTest(TestCase):
def setUp(self):
self.gallery = GalleryFactory()
self.profile1 = ProfileFactory()
self.profile2 = ProfileFactory()
self.profile3 = ProfileFactory()
self.user_gallery1 = UserGalleryFactory(user=self.profile1.user, gallery=self.gallery, mode='W')
self.user_gallery2 = UserGalleryFactory(user=self.profile2.user, gallery=self.gallery, mode='R')
def test_denies_anonymous(self):
response = self.client.get(reverse('zds.gallery.views.new_image', args=[1]), follow=True)
self.assertRedirects(response,
reverse('zds.member.views.login_view')
+ '?next=' + urllib.quote(reverse('zds.gallery.views.new_image', args=[1]), ''))
def test_success_new_image_write_permission(self):
login_check = self.client.login(username=self.profile1.user.username, password='******')
self.assertTrue(login_check)
self.assertEqual(0, len(self.gallery.get_images()))
with open(os.path.join(settings.SITE_ROOT, 'fixtures', 'logo.png'), 'r') as fp:
response = self.client.post(
reverse(
'zds.gallery.views.new_image',
args=[self.gallery.pk]
),
{
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True
)
self.assertEqual(200, response.status_code)
self.assertEqual(1, len(self.gallery.get_images()))
self.gallery.get_images()[0].delete()
def test_fail_new_image_with_read_permission(self):
login_check = self.client.login(username=self.profile2.user.username, password='******')
self.assertTrue(login_check)
self.assertEqual(0, len(self.gallery.get_images()))
with open(os.path.join(settings.SITE_ROOT, 'fixtures', 'logo.png'), 'r') as fp:
response = self.client.post(
reverse(
'zds.gallery.views.new_image',
args=[self.gallery.pk]
),
{
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True
)
self.assertEqual(403, response.status_code)
self.assertEqual(0, len(self.gallery.get_images()))
def test_fail_new_image_with_no_permission(self):
login_check = self.client.login(username=self.profile3.user.username, password='******')
self.assertTrue(login_check)
self.assertEqual(0, len(self.gallery.get_images()))
with open(os.path.join(settings.SITE_ROOT, 'fixtures', 'logo.png'), 'r') as fp:
response = self.client.post(
reverse(
'zds.gallery.views.new_image',
args=[self.gallery.pk]
),
{
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True
)
self.assertEqual(403, response.status_code)
self.assertEqual(0, len(self.gallery.get_images()))
def test_fail_gallery_not_exist(self):
login_check = self.client.login(username=self.profile1.user.username, password='******')
self.assertTrue(login_check)
with open(os.path.join(settings.SITE_ROOT, 'fixtures', 'logo.png'), 'r') as fp:
response = self.client.post(
reverse(
'zds.gallery.views.new_image',
args=[156]
),
{
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True
)
self.assertEqual(404, response.status_code)
def setUp(self):
self.gallery = GalleryFactory()
self.image = ImageFactory(gallery=self.gallery)
class EditImageViewTest(TestCase):
def setUp(self):
self.gallery = GalleryFactory()
self.image = ImageFactory(gallery=self.gallery)
self.profile1 = ProfileFactory()
self.profile2 = ProfileFactory()
self.profile3 = ProfileFactory()
self.user_gallery1 = UserGalleryFactory(user=self.profile1.user,
gallery=self.gallery,
mode='W')
self.user_gallery2 = UserGalleryFactory(user=self.profile2.user,
gallery=self.gallery,
mode='R')
def tearDown(self):
self.image.delete()
def test_denies_anonymous(self):
response = self.client.get(reverse('gallery-image-edit',
args=[15, 156]),
follow=True)
self.assertRedirects(
response,
reverse('zds.member.views.login_view') + '?next=' +
urllib.quote(reverse('gallery-image-edit', args=[15, 156]), ''))
def test_fail_member_no_permission_can_edit_image(self):
login_check = self.client.login(username=self.profile3.user.username,
password='******')
self.assertTrue(login_check)
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'),
'r') as fp:
self.client.post(reverse('gallery-image-edit',
args=[self.gallery.pk, self.image.pk]), {
'title': 'modify with no perms',
'legend': 'test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True)
image_test = Image.objects.get(pk=self.image.pk)
self.assertNotEqual('modify with no perms', image_test.title)
image_test.delete()
def test_success_member_edit_image(self):
login_check = self.client.login(username=self.profile1.user.username,
password='******')
self.assertTrue(login_check)
nb_files = len(os.listdir(self.gallery.get_gallery_path()))
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'),
'r') as fp:
response = self.client.post(reverse(
'gallery-image-edit', args=[self.gallery.pk, self.image.pk]), {
'title': 'edit title',
'legend': 'dit legend',
'slug': 'edit-slug',
'physical': fp
},
follow=True)
self.assertEqual(200, response.status_code)
# should have one picture and 2 thumbnails, so 3 new images
self.assertEqual(nb_files + 3,
len(os.listdir(self.gallery.get_gallery_path())))
image_test = Image.objects.get(pk=self.image.pk)
self.assertEqual('edit title', image_test.title)
image_test.delete()
# picture AND thumbnail should be gone
self.assertEqual(nb_files,
len(os.listdir(self.gallery.get_gallery_path())))
def test_access_permission(self):
login_check = self.client.login(username=self.profile1.user.username,
password='******')
self.assertTrue(login_check)
response = self.client.get(
reverse('gallery-image-edit',
args=[self.gallery.pk, self.image.pk]))
self.assertEqual(200, response.status_code)
class NewImageViewTest(TestCase):
def setUp(self):
self.gallery = GalleryFactory()
self.profile1 = ProfileFactory()
self.profile2 = ProfileFactory()
self.profile3 = ProfileFactory()
self.user_gallery1 = UserGalleryFactory(user=self.profile1.user,
gallery=self.gallery,
mode='W')
self.user_gallery2 = UserGalleryFactory(user=self.profile2.user,
gallery=self.gallery,
mode='R')
def test_denies_anonymous(self):
response = self.client.get(reverse('gallery-image-new', args=[1]),
follow=True)
self.assertRedirects(
response,
reverse('zds.member.views.login_view') + '?next=' +
urllib.quote(reverse('gallery-image-new', args=[1]), ''))
def test_success_new_image_write_permission(self):
login_check = self.client.login(username=self.profile1.user.username,
password='******')
self.assertTrue(login_check)
self.assertEqual(0, len(self.gallery.get_images()))
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'),
'r') as fp:
response = self.client.post(reverse('gallery-image-new',
args=[self.gallery.pk]), {
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True)
self.assertEqual(200, response.status_code)
self.assertEqual(1, len(self.gallery.get_images()))
self.gallery.get_images()[0].delete()
def test_fail_new_image_with_read_permission(self):
login_check = self.client.login(username=self.profile2.user.username,
password='******')
self.assertTrue(login_check)
self.assertEqual(0, len(self.gallery.get_images()))
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'),
'r') as fp:
response = self.client.post(reverse('gallery-image-new',
args=[self.gallery.pk]), {
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True)
self.assertEqual(403, response.status_code)
self.assertEqual(0, len(self.gallery.get_images()))
def test_fail_new_image_with_no_permission(self):
login_check = self.client.login(username=self.profile3.user.username,
password='******')
self.assertTrue(login_check)
self.assertEqual(0, len(self.gallery.get_images()))
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'),
'r') as fp:
response = self.client.post(reverse('gallery-image-new',
args=[self.gallery.pk]), {
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True)
self.assertEqual(403, response.status_code)
self.assertEqual(0, len(self.gallery.get_images()))
def test_fail_gallery_not_exist(self):
login_check = self.client.login(username=self.profile1.user.username,
password='******')
self.assertTrue(login_check)
with open(os.path.join(settings.BASE_DIR, 'fixtures', 'logo.png'),
'r') as fp:
response = self.client.post(reverse('gallery-image-new',
args=[156]), {
'title': 'Test title',
'legend': 'Test legend',
'slug': 'test-slug',
'physical': fp
},
follow=True)
self.assertEqual(404, response.status_code)
def test_import_images_in_gallery(self):
login_check = self.client.login(username=self.profile1.user.username,
password='******')
self.assertTrue(login_check)
with open(
os.path.join(settings.BASE_DIR, 'fixtures',
'archive-gallery.zip'), 'r') as fp:
response = self.client.post(reverse('gallery-image-import',
args=[self.gallery.pk]),
{'file': fp},
follow=False)
self.assertEqual(302, response.status_code)
self.assertEqual(Image.objects.filter(gallery=self.gallery).count(), 1)
def test_denies_import_images_in_gallery(self):
login_check = self.client.login(username=self.profile2.user.username,
password='******')
self.assertTrue(login_check)
with open(
os.path.join(settings.BASE_DIR, 'fixtures',
'archive-gallery.zip'), 'r') as fp:
response = self.client.post(reverse('gallery-image-import',
args=[self.gallery.pk]),
{'file': fp},
follow=True)
self.assertEqual(403, response.status_code)
self.assertEqual(Image.objects.filter(gallery=self.gallery).count(), 0)
def test_delete_empty_gallery(self):
test_gallery = GalleryFactory()
path = test_gallery.get_gallery_path()
test_gallery.delete()
self.assertFalse(os.path.isdir(path))
def test_valid_user_gallery_form(self):
gallery = GalleryFactory()
data = {"action": "add", "user": self.profile, "mode": "R"}
form = UserGalleryForm(gallery=gallery, data=data)
self.assertTrue(form.is_valid())
def test_filters(self):
# create topic and content and toggle request
author = ProfileFactory().user
category = ForumCategoryFactory(position=1)
forum = ForumFactory(category=category, position_in_category=1)
topic = TopicFactory(forum=forum, author=author)
FeaturedRequested.objects.toogle_request(topic, author)
tutorial = PublishedContentFactory(author_list=[author])
gallery = GalleryFactory()
image = ImageFactory(gallery=gallery)
tutorial.image = image
tutorial.save()
FeaturedRequested.objects.toogle_request(tutorial, author)
# without filter
staff = StaffProfileFactory()
login_check = self.client.login(username=staff.user.username, password="******")
self.assertTrue(login_check)
response = self.client.get(reverse("featured-resource-requests"))
self.assertEqual(200, response.status_code)
self.assertEqual(len(response.context["featured_request_list"]), 2)
self.assertTrue(any(r.content_object == topic for r in response.context["featured_request_list"]))
self.assertTrue(any(r.content_object == tutorial for r in response.context["featured_request_list"]))
# filter topic
response = self.client.get(reverse("featured-resource-requests") + "?type=topic")
self.assertEqual(200, response.status_code)
self.assertEqual(len(response.context["featured_request_list"]), 1)
self.assertTrue(any(r.content_object == topic for r in response.context["featured_request_list"]))
self.assertFalse(any(r.content_object == tutorial for r in response.context["featured_request_list"]))
# filter tuto
response = self.client.get(reverse("featured-resource-requests") + "?type=content")
self.assertEqual(200, response.status_code)
self.assertEqual(len(response.context["featured_request_list"]), 1)
self.assertFalse(any(r.content_object == topic for r in response.context["featured_request_list"]))
self.assertTrue(any(r.content_object == tutorial for r in response.context["featured_request_list"]))
# reject topic
content_type = ContentType.objects.get_for_model(topic)
q = FeaturedRequested.objects.get(object_id=topic.pk, content_type__pk=content_type.pk)
q.rejected = True
q.save()
response = self.client.get(reverse("featured-resource-requests") + "?type=topic")
self.assertEqual(200, response.status_code)
self.assertEqual(len(response.context["featured_request_list"]), 0)
# filter ignored
response = self.client.get(reverse("featured-resource-requests") + "?type=ignored")
self.assertEqual(200, response.status_code)
self.assertEqual(len(response.context["featured_request_list"]), 1)
self.assertTrue(any(r.content_object == topic for r in response.context["featured_request_list"]))
# put back vote count to 0 for tutorial
FeaturedRequested.objects.toogle_request(tutorial, author)
response = self.client.get(reverse("featured-resource-requests") + "?type=content")
self.assertEqual(200, response.status_code)
self.assertEqual(len(response.context["featured_request_list"]), 0) # does not appear with no votes
# upvote topic
other = ProfileFactory().user
FeaturedRequested.objects.toogle_request(topic, other)
response = self.client.get(reverse("featured-resource-requests") + "?type=topic")
self.assertEqual(200, response.status_code)
self.assertEqual(len(response.context["featured_request_list"]), 1) # it is back!
