def test_get_detail_usage_activity_view_as_author_public_not_used(self):
self.ws_activity.access = ResourceAccess.PUBLIC.name
self.ws_activity.save()
response = ClientFactory.get_client_for_user("ws").get(
reverse("learning:activity/detail/usage",
kwargs={'slug': self.ws_activity.slug}))
self.assertIn("view_usage_activity",
self.ws_activity.get_user_perms(self.ws))
self.assertEqual(200, response.status_code)
activity = response.context.get('activity')
self.assertEqual(activity, self.ws_activity)
self.assertNotContains(response, "table-activity-usage")
self.assertContains(response, "alert-not-used")
def test_get_detail_similar_resource_view_as_author_public_resource_empty(
self):
self.ws_resource.access = ResourceAccess.PUBLIC.name
self.ws_resource.save()
response = ClientFactory.get_client_for_user("ws").get(
reverse("learning:resource/detail/similar",
kwargs={'slug': self.ws_resource.slug}))
self.assertIn("view_similar_resource",
self.ws_resource.get_user_perms(self.ws))
self.assertEqual(200, response.status_code)
resource = response.context.get('resource')
self.assertEqual(resource, self.ws_resource)
self.assertNotContains(response, "similar-resources")
self.assertContains(response, "alert-no-similar-resource")
def test_post_create_resource_error_missing_tags_name_description_language(
self):
form_data = {
'type': ResourceType.FILE.name,
'licence': Licences.CC_BY.name,
'access': ResourceAccess.PUBLIC.name,
'reuse': ResourceReuse.ONLY_AUTHOR.name,
'duration': Duration.NOT_SPECIFIED.name,
}
response = ClientFactory.get_client_for_user("ws").post(
reverse("learning:resource/add"), form_data)
self.assertEqual(200, response.status_code)
self.assertTemplateUsed(response, "learning/resource/add.html")
self.assertContains(response, "is-invalid", count=4)
def test_update_post_activity_as_author_errors(self):
form_data = {
'name': "",
'description': "",
'language': 'fakelanguage',
'access': ActivityAccess.PUBLIC.name,
'reuse': ActivityReuse.ONLY_AUTHOR.name,
'tags': "A"
}
response = ClientFactory.get_client_for_user("ws").post(
reverse("learning:activity/update",
kwargs={'slug': self.ws_activity.slug}), form_data)
self.assertEqual(200, response.status_code)
self.assertContains(response, "is-invalid", count=3)
def test_get_detail_similar_activity_view_as_author_public_activity_empty(
self):
self.ws_activity.access = ActivityAccess.PUBLIC.name
self.ws_activity.save()
response = ClientFactory.get_client_for_user("ws").get(
reverse("learning:activity/detail/similar",
kwargs={'slug': self.ws_activity.slug}))
self.assertIn("view_similar_activity",
self.ws_activity.get_user_perms(self.ws))
self.assertEqual(200, response.status_code)
activity = response.context.get('activity')
self.assertEqual(activity, self.ws_activity)
self.assertNotContains(response, "similar-activities")
self.assertContains(response, "alert-no-similar-activity")
def test_update_get_resource_form_with_attachment(self):
filename = "sample_update_{date}.txt".format(date=datetime.now().timestamp())
self.ws_resource.attachment.save(filename, get_temporary_file(), save=True)
self.ws_resource.save()
self.assertIsNotNone(self.ws_resource.attachment.name)
self.assertIn("sample_update", self.ws_resource.attachment.name)
self.assertTrue(os.path.isfile(os.path.join(settings.MEDIA_ROOT, "resources", str(self.ws_resource.id), filename)))
response = ClientFactory.get_client_for_user("ws").get(
reverse("learning:resource/update", kwargs={'slug': self.ws_resource.slug})
)
self.assertEqual(200, response.status_code)
self.assertTemplateUsed(response, "learning/resource/details/change.html")
self.assertContains(response, "column-clear-attachment")
self.assertContains(response, "column-download-attachment")
def test_post_unlink_does_not_exist_on_activity_view(self):
self.assertIn("change_activity", self.ws_activity.get_user_perms(self.ws))
r1 = Resource.objects.create(name="A sample resource", author=self.acd)
self.ws_activity.resources.add(r1)
self.assertIn(r1, self.ws_activity.resources.all())
response = ClientFactory.get_client_for_user("ws").post(
reverse(
"learning:activity/detail/resource/unlink",
kwargs={'slug': self.ws_activity.slug, },
),
{'resource': r1.id + 1}
)
self.assertEqual(404, response.status_code)
self.assertIn(r1, self.ws_activity.resources.all())
def test_get_resource_on_activity_no_perm_on_resource(self):
r1 = Resource.objects.create(
author=self.acd, name="A first resource", access=ResourceAccess.PRIVATE.name
)
self.ws_activity.resources.add(r1)
self.assertNotIn("view_resource", r1.get_user_perms(self.ws))
self.assertIn("view_activity", self.ws_activity.get_user_perms(self.ws))
response = ClientFactory.get_client_for_user("ws").get(
reverse(
"learning:activity/resource/detail",
kwargs={'slug': self.ws_activity.slug, 'resource_slug': r1.slug}
)
)
self.assertEqual(403, response.status_code)
def test_get_detail_usage_resource_view_as_author_private_resource_empty(
self):
self.ws_resource.access = ResourceAccess.PRIVATE.name
self.ws_resource.save()
response = ClientFactory.get_client_for_user("ws").get(
reverse("learning:resource/detail/usage",
kwargs={'slug': self.ws_resource.slug}))
self.assertIn("view_usage_resource",
self.ws_resource.get_user_perms(self.ws))
self.assertEqual(200, response.status_code)
resource = response.context.get('resource')
self.assertEqual(resource, self.ws_resource)
self.assertNotContains(response, "table-resource-usage")
self.assertContains(response, "alert-not-used")
def test_get_resource_on_activity(self):
r1 = Resource.objects.create(author=self.ws, name="A first resource")
self.ws_activity.resources.add(r1)
response = ClientFactory.get_client_for_user("ws").get(
reverse("learning:activity/resource/detail",
kwargs={
'slug': self.ws_activity.slug,
'resource_slug': r1.slug
}))
self.assertEqual(200, response.status_code)
self.assertContains(response, self.ws_activity.name, count=3)
self.assertContains(response, "A first resource", count=3)
self.assertEqual(self.ws_activity, response.context.get('object'))
self.assertEqual(self.ws_activity, response.context.get('activity'))
self.assertEqual(r1, response.context.get('resource'))
def test_post_attach_on_activity_view(self):
self.assertIn("change_activity", self.ws_activity.get_user_perms(self.ws))
r1 = Resource.objects.create(name="A sample resource", author=self.acd, reuse=ResourceReuse.NO_RESTRICTION.name)
self.assertTrue(r1.is_reusable(self.ws_activity))
self.assertNotIn(r1, self.ws_activity.resources.all())
response = ClientFactory.get_client_for_user("ws").post(
reverse("learning:activity/detail/resource/attach", kwargs={'slug': self.ws_activity.slug}),
{'resource': r1.id}
)
self.assertRedirects(
response,
status_code=302, target_status_code=200,
expected_url=reverse("learning:activity/detail/resource/attach", kwargs={'slug': self.ws_activity.slug})
)
self.assertIn(r1, self.ws_activity.resources.all())
def test_update_post_resource_without_being_author_forbidden(self):
form_data = {
'name': "A sample name that changed",
'description': "A short description",
'type': ResourceType.FILE.name,
'language': 'fr',
'licence': Licences.CC_BY.name,
'access': ResourceAccess.PUBLIC.name,
'reuse': ResourceReuse.ONLY_AUTHOR.name,
'duration': Duration.NOT_SPECIFIED.name,
}
response = ClientFactory.get_client_for_user("acd").post(
reverse("learning:resource/update", kwargs={'slug': self.ws_resource.slug}), form_data
)
self.assertEqual(403, response.status_code)
def test_update_post_resource_as_author_too_big_resource(self):
filename = "sample_update_{date}.txt".format(
date=datetime.now().timestamp())
self.ws_resource.media.save(filename, get_temporary_file(), save=True)
self.ws_resource.save()
self.assertIsNotNone(self.ws_resource.media.name)
self.assertIn("sample_update", self.ws_resource.media.name)
self.assertTrue(
os.path.isfile(os.path.join(settings.MEDIA_ROOT, filename)))
resource = Resource.objects.get(pk=self.ws_resource.id)
self.assertIsNotNone(resource.media.name)
self.assertIn("sample_update", resource.media.name)
self.assertTrue(
os.path.isfile(os.path.join(settings.MEDIA_ROOT, filename)))
form_data = {
'name': "A sample name that changed",
'description': "A short description",
'type': ResourceType.FILE.name,
'language': 'fr',
'licence': Licences.CC_BY.name,
'access': ResourceAccess.PUBLIC.name,
'reuse': ResourceReuse.ONLY_AUTHOR.name,
'duration': Duration.NOT_SPECIFIED.name,
"tags": "B",
"media": get_temporary_file(file_size=2**21)
}
response = ClientFactory.get_client_for_user("ws").post(
reverse("learning:resource/update",
kwargs={'slug': self.ws_resource.slug}), form_data)
self.assertEqual(200, response.status_code)
self.assertIsNotNone(response.context.get('form').errors)
self.assertContains(response, "sample_update",
count=2) # link and title
self.assertContains(response, filesizeformat(2**21), count=1)
self.assertIsNotNone(self.ws_resource.media.name)
self.assertIn("sample_update", self.ws_resource.media.name)
self.assertTrue(
os.path.isfile(os.path.join(settings.MEDIA_ROOT, filename)))
resource = Resource.objects.get(pk=self.ws_resource.id)
self.assertIsNotNone(resource.media.name)
self.assertIn("sample_update", resource.media.name)
self.assertTrue(
os.path.isfile(os.path.join(settings.MEDIA_ROOT, filename)))
def test_update_get_resource_form_with_media(self):
self.ws_resource.media.save("sample_update.txt",
get_temporary_file("sample_update.txt"),
save=True)
self.ws_resource.save()
self.assertIsNotNone(self.ws_resource.media.name)
self.assertIn("sample_update", self.ws_resource.media.name)
self.assertTrue(os.path.isfile(self.ws_resource.media.path))
response = ClientFactory.get_client_for_user("ws").get(
reverse("learning:resource/update",
kwargs={'slug': self.ws_resource.slug}))
self.assertEqual(200, response.status_code)
self.assertTemplateUsed(response,
"learning/resource/details/change.html")
self.assertContains(response, "column-clear-media")
self.assertContains(response, "column-download-media")
def test_update_post_activity_as_author(self):
form_data = {
'name': "A sample name that changed",
'description': "A short description",
'language': 'fr',
'access': ActivityAccess.PUBLIC.name,
'reuse': ActivityReuse.ONLY_AUTHOR.name,
'tags': "A"
}
response = ClientFactory.get_client_for_user("ws").post(
reverse("learning:activity/update", kwargs={'slug': self.ws_activity.slug}), form_data
)
self.assertRedirects(
response, status_code=302, target_status_code=200,
expected_url=reverse("learning:activity/detail", kwargs={'slug': "a-sample-name-that-changed"})
)
def test_delete_resource_post_as_author_with_media(self):
self.ws_resource.media.save("sample_update.txt",
get_temporary_file("sample_update.txt"),
save=True)
self.ws_resource.save()
self.assertIsNotNone(self.ws_resource.media.name)
self.assertIn("sample_update", self.ws_resource.media.name)
self.assertTrue(os.path.isfile(self.ws_resource.media.path))
response = ClientFactory.get_client_for_user("ws").post(
reverse("learning:resource/delete",
kwargs={'slug': self.ws_resource.slug}))
self.assertRedirects(response,
status_code=302,
target_status_code=200,
expected_url=reverse("learning:resource/my"))
self.assertFalse(os.path.isfile(self.ws_resource.media.path))
def test_teacher_student_registered_progression_for_teacher_owner(self):
self.public_course.register(get_user_model().objects.filter(username="******").get())
self.assertIn(get_user_model().objects.filter(username="******").get(),
self.public_course.students.all())
response = ClientFactory.get_client_for_user("isaac-newton").get(
reverse("learning:course/detail/progression/teacher/",
kwargs={'slug': self.public_course.slug, 'username_id': get_user_model().objects.filter(
username="******").get().id}))
self.assertEquals(response.status_code, 200)
content = response.content.decode("utf-8")
self.assertIn(
"active-student-{}-list".format(get_user_model().objects.filter(username="******").get().id), content)
self.assertIn(self.objective.ability, content)
object_objective = CourseObjective.objects.filter(objective=self.objective, course=self.public_course).get()
self.assertIn(object_objective.taxonomy_level, content)
self.assertIn("Working", content)
def test_delete_resource_post_as_author_with_attachment(self):
filename = "sample_update_{date}.txt".format(date=datetime.now().timestamp())
self.ws_resource.attachment.save(filename, get_temporary_file(), save=True)
self.ws_resource.save()
self.assertIsNotNone(self.ws_resource.attachment.name)
self.assertIn("sample_update", self.ws_resource.attachment.name)
self.assertTrue(os.path.isfile(os.path.join(settings.MEDIA_ROOT, "resources", str(self.ws_resource.id), filename)))
response = ClientFactory.get_client_for_user("ws").post(
reverse("learning:resource/delete", kwargs={'slug': self.ws_resource.slug})
)
self.assertRedirects(
response,
status_code=302, target_status_code=200,
expected_url=reverse("learning:resource/my")
)
self.assertFalse(os.path.isfile(os.path.join(settings.MEDIA_ROOT, filename)))
def test_course_detail_objective_list_as_owner_as_objective_author(self):
response = ClientFactory.get_client_for_user("isaac-newton").get(
reverse("learning:course/detail", kwargs={'slug': self.public_course.slug}))
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed("learning/detail.html")
content = response.content.decode("utf-8")
# Checking if table is here
self.assertIn("table-object-objective-list", content)
self.assert_basic_test_for_owner(content, self.objective)
self.assertIn("author-of-objective-change-fields", content)
# Check that user can delete objective
self.assertIn("form-delete-object-objective-{}".format(self.objective.slug), content)
self.assertIn("objective-delete-{}-pk".format(self.objective.slug), content)
self.assertIn("object-objective-{}-delete".format(self.objective.slug), content)
def test_post_attach_on_activity_view_already_linked(self):
self.assertIn("change_activity", self.ws_activity.get_user_perms(self.ws))
r1 = Resource.objects.create(name="A sample resource", author=self.acd)
r2 = Resource.objects.create(name="A sample resource 2", author=self.lt)
self.ws_activity.resources.add(r1)
self.assertIn(r1, self.ws_activity.resources.all())
self.assertNotIn(r2, self.ws_activity.resources.all())
response = ClientFactory.get_client_for_user("ws").post(
reverse(
"learning:activity/detail/resource/attach",
kwargs={'slug': self.ws_activity.slug, },
),
{'resource': r1.id}
)
self.assertEqual(302, response.status_code)
self.assertIn(r1, self.ws_activity.resources.all())
self.assertNotIn(r2, self.ws_activity.resources.all())
def test_get_detail_activity_view_registered_user_public_activity(self):
self.ws_activity.resources.add(self.resource1)
self.ws_activity.access = ActivityAccess.PUBLIC.name
self.ws_activity.save()
response = ClientFactory.get_client_for_user("acd").get(
reverse("learning:activity/detail", kwargs={'slug': self.ws_activity.slug})
)
self.assertIn("view_activity", self.ws_activity.get_user_perms(self.acd))
self.assertEqual(200, response.status_code)
self.assertNotContains(response, "link-activity-usage")
self.assertNotContains(response, "link-activity-similar")
self.assertNotContains(response, "link-activity-add-resource")
self.assertNotContains(response, "btn-change-activity")
self.assertNotContains(response, "btn-delete-activity")
self.assertNotContains(response, "activity-no-resource")
activity = response.context.get('activity')
self.assertContains(response, "resource-block-for-{}".format(self.resource1.slug))
self.assertEqual(activity, self.ws_activity)
def test_update_view_for_owner_not_objective_author_change_objective_reusable(self):
form_data = {
'objective_pk': self.course_objective_not_author.id,
'taxonomy_level': self.course_objective_not_author.taxonomy_level.name,
'objective_reusable': False,
}
form = BasicModelDetailObjectiveUpdateView.ObjectivePKForm(data=form_data)
form_objective = CourseObjectiveUpdateForm(data=form_data)
self.assertTrue(form.is_valid())
self.assertTrue(form_objective.is_valid())
response = ClientFactory.get_client_for_user("isaac-newton").post(
reverse("learning:course/detail/objective/change", kwargs={'slug': self.public_course.slug}),
form_data
)
self.assertEquals(response.status_code, 302)
self.assertFalse(CourseObjective.objects.filter(objective=self.objective_1,
course=self.public_course).get().objective_reusable)
def test_post_unlink_on_activity_view(self):
self.assertIn("change_activity", self.ws_activity.get_user_perms(self.ws))
r1 = Resource.objects.create(name="A sample resource", author=self.acd)
self.ws_activity.resources.add(r1)
self.assertIn(r1, self.ws_activity.resources.all())
response = ClientFactory.get_client_for_user("ws").post(
reverse(
"learning:activity/detail/resource/unlink",
kwargs={'slug': self.ws_activity.slug, },
),
{'resource': r1.id}
)
self.assertRedirects(
response,
status_code=302, target_status_code=200,
expected_url=reverse("learning:activity/detail", kwargs={'slug': self.ws_activity.slug})
)
self.assertNotIn(r1, self.ws_activity.resources.all())
def test_get_detail_resource_view_user_public_resource(self):
self.ws_resource.access = ResourceAccess.PUBLIC.name
self.ws_resource.save()
response = ClientFactory.get_client_for_user("acd").get(
reverse("learning:resource/detail",
kwargs={'slug': self.ws_resource.slug}))
self.assertIn("view_resource",
self.ws_resource.get_user_perms(self.acd))
self.assertEqual(200, response.status_code)
self.assertNotContains(response, "btn-edit-resource")
self.assertNotContains(response, "btn-delete-resource")
self.assertContains(response, "link-resource-detail", count=1)
self.assertNotContains(response, "link-resource-usage")
self.assertNotContains(response, "link-resource-similar")
self.assertNotContains(response, "media-description")
self.common_contains_resource_detail_view(response)
resource = response.context.get('resource')
self.assertEqual(resource, self.ws_resource)
def test_get_detail_activity_view_as_author_private_resource_no_resource(
self):
self.ws_activity.access = ActivityAccess.PRIVATE.name
self.ws_activity.save()
response = ClientFactory.get_client_for_user("ws").get(
reverse("learning:activity/detail",
kwargs={'slug': self.ws_activity.slug}))
self.assertIn("view_activity",
self.ws_activity.get_user_perms(self.ws))
self.assertEqual(200, response.status_code)
self.assertContains(response, "link-activity-usage", count=1)
self.assertContains(response, "link-activity-similar", count=1)
self.assertContains(response, "link-activity-add-resource", count=2)
self.assertContains(response, "link-activity-attach-resource", count=1)
self.assertContains(response, "btn-change-activity", count=1)
self.assertContains(response, "btn-delete-activity", count=1)
self.assertContains(response, "activity-no-resource", count=2)
activity = response.context.get('activity')
self.assertEqual(activity, self.ws_activity)
def test_post_create_activity(self):
form_data = {
'name': "A sample name",
'description': "A short description",
'language': 'fr',
'reuse': ActivityReuse.NO_RESTRICTION.name,
'access': ActivityAccess.PUBLIC.name,
'tags': "A",
}
response = ClientFactory.get_client_for_user("ws").post(reverse("learning:activity/add"), form_data)
# Check redirection after resource creation
self.assertRedirects(
response,
status_code=302, target_status_code=200,
expected_url=reverse("learning:activity/detail", kwargs={'slug': "a-sample-name"})
)
# The author is the request sender
resource = Activity.objects.get(pk=4)
self.assertEqual(self.ws, resource.author)
def test_get_detail_similar_resource_view_as_author_public_resource_used_twice(self):
for tag in self.ws_resource.tags.all():
self.acd_resource.tags.add(tag)
self.lt_resource.tags.add(tag)
self.acd_resource.save()
self.lt_resource.save()
self.ws_resource.access = ResourceAccess.PUBLIC.name
self.ws_resource.save()
response = ClientFactory.get_client_for_user("ws").get(
reverse("learning:resource/detail/similar", kwargs={'slug': self.ws_resource.slug})
)
self.assertIn("view_similar_resource", self.ws_resource.get_user_perms(self.ws))
self.assertEqual(200, response.status_code)
resource = response.context.get('resource')
self.assertEqual(resource, self.ws_resource)
self.assertNotContains(response, "alert-no-similar-resource")
self.assertContains(response, "similar-resources")
page_obj = response.context.get('page_obj')
self.assertIsNotNone(page_obj)
self.assertEqual(2, len(page_obj.object_list))
def test_post_create_resource_on_activity_invalid_form(self):
form_data = {
'description': "A short description",
'type': ResourceType.FILE.name,
'language': 'fr',
'licence': Licences.CC_BY.name,
'access': ResourceAccess.PUBLIC.name,
'reuse': ResourceReuse.NO_RESTRICTION.name,
'duration': Duration.NOT_SPECIFIED.name,
'tags': "A",
"media": get_temporary_file(name="sample.txt")
}
response = ClientFactory.get_client_for_user("ws").post(
reverse("learning:activity/detail/resource/add", kwargs={'slug': self.ws_activity.slug}), form_data
)
self.assertEqual(200, response.status_code)
self.assertFalse(Resource.objects.filter(name="A sample name").exists())
self.assertEqual(0, self.ws_activity.resources.count())
self.assertEqual(1, len(response.context.get('form').errors.as_data()))
self.assertEqual(0, self.ws_activity.resources.count())
def test_update_post_resource_as_author_replace_media(self):
filename = "sample_update_{date}.txt".format(
date=datetime.now().timestamp())
self.ws_resource.media.save(filename, get_temporary_file(), save=True)
self.ws_resource.save()
self.assertIsNotNone(self.ws_resource.media.name)
self.assertIn("sample_update", self.ws_resource.media.name)
self.assertTrue(
os.path.isfile(os.path.join(settings.MEDIA_ROOT, filename)))
temp_file = get_temporary_file(file_size=2**5)
form_data = {
'name': "A sample name that changed",
'description': "A short description",
'type': ResourceType.FILE.name,
'language': 'fr',
'licence': Licences.CC_BY.name,
'access': ResourceAccess.PUBLIC.name,
'reuse': ResourceReuse.ONLY_AUTHOR.name,
'duration': Duration.NOT_SPECIFIED.name,
"tags": "B",
"media": temp_file
}
response = ClientFactory.get_client_for_user("ws").post(
reverse("learning:resource/update",
kwargs={'slug': self.ws_resource.slug}), form_data)
self.assertRedirects(response,
status_code=302,
target_status_code=200,
expected_url=reverse(
"learning:resource/detail",
kwargs={'slug':
"a-sample-name-that-changed"}))
resource = Resource.objects.get(pk=self.ws_resource.id)
self.assertIsNotNone(resource.media.name)
self.assertIn(os.path.basename(temp_file.name), resource.media.name)
# Current file exists and previous has been removed
self.assertTrue(os.path.isfile(resource.media.path))
self.assertFalse(
os.path.isfile(os.path.join(settings.MEDIA_ROOT, filename)))
def test_get_detail_resource_view_as_author_private_resource(self):
self.ws_resource.access = ResourceAccess.PRIVATE.name
self.ws_resource.save()
response = ClientFactory.get_client_for_user("ws").get(
reverse("learning:resource/detail", kwargs={'slug': self.ws_resource.slug})
)
self.assertIn("view_resource", self.ws_resource.get_user_perms(self.ws))
self.assertEqual(200, response.status_code)
self.assertContains(response, "access-badge", count=1)
self.assertContains(response, "reuse-badge", count=1)
self.assertContains(response, "licence-badge", count=1)
self.assertContains(response, "duration-badge", count=1)
self.assertContains(response, "btn-edit-resource", count=1)
self.assertContains(response, "btn-delete-resource", count=1)
self.assertContains(response, "link-resource-detail", count=1)
self.assertContains(response, "link-resource-usage", count=1)
self.assertContains(response, "link-resource-similar", count=1)
self.assertNotContains(response, "attachment-description")
self.common_contains_resource_detail_view(response)
resource = response.context.get('resource')
self.assertEqual(resource, self.ws_resource)
