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_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_but_not_objective_author_so_cant_change_ability(self):
form_data = {
'objective_pk': self.course_objective_not_author.id,
'taxonomy_level': self.course_objective_not_author.taxonomy_level.name,
'objective_reusable': False,
'ability': 'Aahaha i am a little hacker'
}
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.assertEquals(CourseObjective.objects.filter(objective=self.objective_1,
course=self.public_course).get().objective.ability,
self.course_objective_not_author.objective.ability)
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,
language="en")
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_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_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_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_usage_resource_view_as_author_public_resource_used_twice(self):
a1 = Activity.objects.create(author=self.ws, name="test1")
a2 = Activity.objects.create(author=self.acd, name="test2")
a1.resources.add(self.ws_resource)
a2.resources.add(self.ws_resource)
self.assertEqual(2, self.ws_resource.activities.count())
self.ws_resource.access = ResourceAccess.PUBLIC.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.assertContains(response, "table-resource-usage")
self.assertContains(response, "usage-activity-row", count=2)
self.assertNotContains(response, "alert-not-used")
page_obj = response.context.get('page_obj')
self.assertIsNotNone(page_obj)
self.assertEqual(2, len(page_obj.object_list))
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)
def test_get_detail_usage_activity_view_as_author_public_resource_used_twice(self):
c1 = Course.objects.create(author=self.ws, name="test1")
c2 = Course.objects.create(author=self.acd, name="test2")
CourseActivity.objects.create(activity=self.ws_activity, rank=1, course=c1)
CourseActivity.objects.create(activity=self.ws_activity, rank=1, course=c2)
self.assertEqual(2, self.ws_activity.course_activities.count())
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.assertContains(response, "table-activity-usage")
self.assertContains(response, "usage-activity-row", count=2)
self.assertNotContains(response, "alert-not-used")
page_obj = response.context.get('page_obj')
self.assertIsNotNone(page_obj)
self.assertEqual(2, len(page_obj.object_list))
def test_get_detail_activity_view_as_author_private_resource_one_resource(self):
self.ws_activity.resources.add(self.resource1)
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, "btn-change-activity", count=1)
self.assertContains(response, "btn-delete-activity", count=1)
self.assertNotContains(response, "activity-no-resource")
self.assertContains(
response, "add-resource-on-activity-{}".format(self.ws_activity.slug), count=3
)
activity = response.context.get('activity')
self.assertContains(response, "resource-block-for-{}".format(self.resource1.slug))
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_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,
language="en")
r2 = Resource.objects.create(name="A sample resource 2",
author=self.lt,
language="en")
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_similar_activity_view_as_author_public_activity_used_twice(self):
self.ws_activity.tags.add("tag1")
self.ws_activity.tags.add("tag2")
for tag in self.ws_activity.tags.all():
self.acd_activity.tags.add(tag)
self.lt_activity.tags.add(tag)
self.acd_activity.save()
self.lt_activity.save()
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, "alert-no-similar-activity")
self.assertContains(response, "similar-activities")
page_obj = response.context.get('page_obj')
self.assertIsNotNone(page_obj)
self.assertEqual(2, len(page_obj.object_list))
def test_course_detail_objective_list_as_owner_but_not_as_objective_author(self):
self.public_course.remove_objective(self.objective)
self.public_course.add_objective(objective=self.objective_1,
objective_reusable=True,
taxonomy_level=TaxonomyLevel.EVALUATION
)
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_1)
self.assertNotIn("author-of-objective-change-fields", content)
# Check that user can't delete objective
self.assertNotIn("form-delete-object-objective-{}".format(self.objective_1.slug), content)
self.assertNotIn("objective-delete-{}-pk".format(self.objective_1.slug), content)
self.assertNotIn("object-objective-{}-delete".format(self.objective_1.slug), content)
def test_get_detail_resource_view_as_author_public_resource(self):
self.ws_resource.access = ResourceAccess.PUBLIC.name
self.ws_resource.media.save("sample_detail.txt",
get_temporary_file("sample_detail.txt"),
save=True)
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, "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.assertContains(response, "media-description")
self.common_contains_resource_detail_view(response)
resource = response.context.get('resource')
self.assertEqual(resource, self.ws_resource)
self.assertIsNotNone(resource.media.name)
self.assertIn("sample_detail", resource.media.name)
def test_update_get_activity_without_being_author_forbidden(self):
response = ClientFactory.get_client_for_user("acd").get(
reverse("learning:activity/update",
kwargs={'slug': self.ws_activity.slug}))
self.assertEqual(403, response.status_code)
def test_update_get_activity_as_author(self):
response = ClientFactory.get_client_for_user("ws").get(
reverse("learning:activity/update", kwargs={'slug': self.ws_activity.slug})
)
self.assertEqual(200, response.status_code)
self.assertTemplateUsed(response, "learning/activity/details/change.html")
def test_attach_on_activity_no_perm(self):
self.assertNotIn("change_activity", self.ws_activity.get_user_perms(self.acd))
response = ClientFactory.get_client_for_user("acd").get(
reverse("learning:activity/detail/resource/attach", kwargs={'slug': self.ws_activity.slug})
)
self.assertEqual(403, response.status_code)
def test_post_detail_resource_view_method_not_allowed(self):
response = ClientFactory.get_client_for_user("ws").post(
reverse("learning:resource/detail", kwargs={'slug': self.ws_resource.slug})
)
self.assertEqual(405, response.status_code)
def test_get_create_activity_view(self):
response = ClientFactory.get_client_for_user("ws").get(
reverse("learning:activity/add"))
self.assertEqual(200, response.status_code)
self.assertTemplateUsed(response, "learning/activity/add.html")
def test_delete_resource_get_as_author(self):
response = ClientFactory.get_client_for_user("ws").get(
reverse("learning:resource/delete", kwargs={'slug': self.ws_resource.slug})
)
self.assertEqual(200, response.status_code)
self.assertTemplateUsed(response, "learning/resource/delete.html")
def test_delete_resource_post_without_being_author_forbidden(self):
response = ClientFactory.get_client_for_user("acd").post(
reverse("learning:resource/delete", kwargs={'slug': self.ws_resource.slug})
)
self.assertEqual(403, response.status_code)
def test_post_create_resource_error_missing_all_fields(self):
response = ClientFactory.get_client_for_user("ws").post(reverse("learning:resource/add"))
self.assertEqual(200, response.status_code)
self.assertTemplateUsed(response, "learning/resource/add.html")
self.assertContains(response, "is-invalid", count=9)
def test_get_create_resource_view(self):
response = ClientFactory.get_client_for_user("ws").get(reverse("learning:resource/add"))
self.assertEqual(200, response.status_code)
self.assertTemplateUsed(response, "learning/resource/add.html")
self.assertContains(response, """id="resource_add_form" enctype=\"multipart/form-data\"""")
def test_teacher_progression_for_student(self):
response = ClientFactory.get_client_for_user("louis-xiv").get(
reverse("learning:course/detail/progression/teacher", kwargs={'slug': self.public_course.slug}))
self.assertEquals(response.status_code, 403)
def test_post_detail_similar_activity_view_method_not_allowed(self):
response = ClientFactory.get_client_for_user("ws").post(
reverse("learning:activity/detail/similar",
kwargs={'slug': self.ws_activity.slug}))
self.assertEqual(405, response.status_code)
def test_btn_new_question_in_agora_page(self):
response = ClientFactory.get_client_for_user("ws").get(reverse("learning:course/detail/agora", kwargs={'slug': self.public_course.slug}))
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "learning/course/details/agora/agora.html")
content = response.content.decode("utf-8")
self.assertIn("btn-new-question", content)
def test_student_progression_for_author(self):
response = ClientFactory.get_client_for_user("isaac-newton").get(
reverse("learning:course/detail/progression/student", kwargs={'slug': self.public_course.slug}))
self.assertEquals(response.status_code, 200)
def test_btn_new_question_on_course(self):
response = ClientFactory.get_client_for_user("ws").get(reverse("learning:course/detail", kwargs={'slug': self.public_course.slug}))
content = response.content.decode("utf-8")
self.assertTemplateUsed(response, "learning/course/detail.html")
self.assertIn("btn-new-question", content)
