def test_project_user_add(self): project = amcattest.create_test_project() project_admin = User.objects.first() plebs = amcattest.create_test_user() admin = amcattest.create_test_user() admin.is_superuser = True admin.save() url = "/projects/{}/users/add/".format(project.id) # Adding a user as plebs should not be possible self.assertEqual(1, ProjectRole.objects.count()) admin_role = Role.objects.get(label="admin") response = self.post(url, plebs, {"role": admin_role.id, "user": plebs.id}) self.assertEqual(403, response.status_code) self.assertEqual(1, ProjectRole.objects.count()) # Adding as superuser should be possible reader_role = Role.objects.get(label="reader") response = self.post(url, admin, {"role": reader_role.id, "user": plebs.id}) self.assertEqual(302, response.status_code) self.assertEqual(2, ProjectRole.objects.count()) # Plebs gonna be plebs admin_role = Role.objects.get(label="admin") response = self.post(url, plebs, {"role": admin_role.id, "user": plebs.id}) self.assertEqual(403, response.status_code) self.assertEqual(2, ProjectRole.objects.count()) # Test remove if admin on project response = self.post(url, project_admin, {"role": "", "user": plebs.id}) self.assertEqual(302, response.status_code) self.assertEqual(1, ProjectRole.objects.count())
def setUp(self): if not User.objects.filter(username='******').exists(): create_test_user(username='******', password='******') self.cb = amcattest.create_test_codebook() from django.test import Client self.client = Client() response = self.client.post('/accounts/login/', {'username': '******', 'password': '******'}) self.assert_status(response, 302)
def setUp(self): self.project = amcattest.create_test_project() self.non_member = amcattest.create_test_user() self.member = amcattest.create_test_user() self.owner = amcattest.create_test_user() ProjectRole.objects.create(project=self.project, user=self.member, role_id=ROLE_PROJECT_WRITER) ProjectRole.objects.create(project=self.project, user=self.owner, role_id=ROLE_PROJECT_WRITER) self.query = amcattest.create_test_query(user=self.owner, project=self.project, parameters='[1,2,"ab"]') self.client = Client()
def setUp(self): from amcat.models.coding.coding import CodingValue # create a coding job set with a sensible schema and some articles to 'code' self.schema = amcattest.create_test_schema() self.codebook = amcattest.create_test_codebook() self.code = amcattest.create_test_code(label="CODED") self.codebook.add_code(self.code) texttype = CodingSchemaFieldType.objects.get(pk=1) inttype = CodingSchemaFieldType.objects.get(pk=2) codetype = CodingSchemaFieldType.objects.get(pk=5) create = CodingSchemaField.objects.create self.textfield = create(codingschema=self.schema, fieldnr=1, fieldtype=texttype, label="Text") self.intfield = create(codingschema=self.schema, fieldnr=2, fieldtype=inttype, label="Number") self.codefield = create(codingschema=self.schema, fieldnr=3, fieldtype=codetype, label="Code", codebook=self.codebook) self.users = [amcattest.create_test_user() for _x in range(2)] self.articles, self.jobs, self.asets = [], [], [] for i, user in enumerate([0, 0, 0, 0, 1]): aset = amcattest.create_test_set(articles=2 * (i + 1)) self.articles += list(aset.articles.all()) self.asets.append(aset) job = amcattest.create_test_job(articleschema=self.schema, unitschema=self.schema, coder=self.users[user], articleset=aset) self.jobs.append(job) self.an1 = Coding.objects.create(codingjob=self.jobs[0], article=self.articles[0]) self.an2 = Coding.objects.create(codingjob=self.jobs[0], article=self.articles[1]) self.an2.set_status(STATUS_COMPLETE) self.an2.comments = 'Makkie!' self.an2.save() sent = amcattest.create_test_sentence() self.sa1 = Coding.objects.create(codingjob=self.jobs[0], article=self.articles[0], sentence=sent) self.sa2 = Coding.objects.create(codingjob=self.jobs[0], article=self.articles[0], sentence=sent) create = CodingValue.objects.create create(coding=self.sa1, field=self.intfield, intval=1) create(coding=self.sa1, field=self.textfield, strval="bla") create(coding=self.sa2, field=self.textfield, strval="blx") create(coding=self.sa1, field=self.codefield, intval=self.code.id)
def test_queries(self): """Test the list_queries context manager""" u = amcattest.create_test_user() with list_queries() as l: amcattest.create_test_project(owner=u) #query_list_to_table(l, output=print) self.assertEquals(len(l), 2) # create project, create role for owner
def test_get_form(self): u = amcattest.create_test_user() #f = AddProject.get_empty_form() #self.assertEqual(f.fields['owner'].initial, current_user().id) # current_user() doesn't exist anymore f = AddProject.get_empty_form(user=u) self.assertEqual(f.fields['owner'].initial, u.id)
def test_article_split_view(self): from amcat.models import Role, ProjectRole article, sentences = self.create_test_sentences() aset = amcattest.create_test_set(0) aset.add_articles([article]) user = amcattest.create_test_user(username="******", password="******") ProjectRole.objects.create(user=user, project=aset.project, role=Role.objects.get(label="admin", projectlevel=True)) # Only test the very basic; if a simple split works we trust the view # to use handle_split(), which is tested more extensively below. url = reverse(ArticleSplitView.get_view_name(), args=[aset.project.id, article.id]) client = Client() client.login(username="******", password="******") response = client.post(url, { "add_to_new_set": "test_article_split_view_set", "remove_from_all_sets": "on", "add_splitted_to_new_set": "", "sentence-%s" % sentences[1].id: "on" }) new_set = ArticleSet.objects.filter(name="test_article_split_view_set") self.assertEqual(response.status_code, 200) self.assertTrue(new_set.exists()) self.assertEqual(article, new_set[0].articles.all()[0])
def test_filter(self): from amcat.models import Role from api.rest.resources import ProjectResource r = Role.objects.get(label='admin') p = amcattest.create_test_project(name="test") p2 = amcattest.create_test_project(name="not a test", guest_role=r) p3 = amcattest.create_test_project(name="anothertest") # no filter self.assertEqual(self._get_ids(ProjectResource), {p.id, p2.id, p3.id}) # Filter on simple fields: id, pk, and name self.assertEqual(self._get_ids(ProjectResource, id=p2.id), {p2.id}) self.assertEqual(self._get_ids(ProjectResource, name=p.name), {p.id}) self.assertEqual(self._get_ids(ProjectResource, pk=p.id), {p.id}) # Filter on directly related fields self.assertEqual(self._get_ids(ProjectResource, guest_role__id=r.id), {p2.id}) # Filter on 1-to-many field #aset = amcattest.create_test_set(project=p) #self.assertEqual(self._get_ids(ProjectResource, articlesets_set__id=aset.id), {p.id}) # Filter on more n-on-m field: project roles u = amcattest.create_test_user() self.assertEqual(self._get_ids(ProjectResource, projectrole__user__id=u.id), set()) from amcat.models import ProjectRole ProjectRole.objects.create(project=p3, user=u, role=r) self.assertEqual(self._get_ids(ProjectResource, projectrole__user__id=u.id), {p3.id}) # Filter on multiple values of same key. Expect them to be OR'ed. #self.assertEqual(self._get_ids(ProjectResource, id=[p.id, p2.id]), {p2.id, p.id}) self.assertEqual(self._get_ids(ProjectResource, pk=[p.id, p2.id]), {p2.id, p.id})
def test_article_split_view(self): from amcat.models import Role, ProjectRole article, sentences = self.create_test_sentences() aset = amcattest.create_test_set(0) aset.add_articles([article]) user = amcattest.create_test_user(username="******", password="******") ProjectRole.objects.create(user=user, project=aset.project, role=Role.objects.get(label="admin", projectlevel=True)) # Only test the very basic; if a simple split works we trust the view # to use handle_split(), which is tested more extensively below. url = reverse(ArticleSplitView.get_view_name(), args=[aset.project.id, article.id]) client = Client() client.login(username="******", password="******") response = client.post( url, { "add_to_new_set": "test_article_split_view_set", "remove_from_all_sets": "on", "add_splitted_to_new_set": "", "sentence-%s" % sentences[1].id: "on" }) new_set = ArticleSet.objects.filter(name="test_article_split_view_set") self.assertEqual(response.status_code, 200) self.assertTrue(new_set.exists()) self.assertEqual(article, new_set[0].articles.all()[0])
def _get_json(self, url): self.user = amcattest.create_test_user(username="******".format(uuid4()), password="******") c = Client() c.login(username=self.user.username, password="******") r = c.get(url) self.assertEqual(r.status_code, 200) return json.loads(r.content.decode('utf-8'))
def test_add(self): u = amcattest.create_test_user() p = AddProject(owner=u.id, name='test', description='test', insert_user=u.id).run() #self.assertEqual(p.insert_user, current_user()) # current_user() doesn't exist anymore self.assertEqual(p.owner, u)
def test_update_visited(self): u = amcattest.create_test_user() p = amcattest.create_test_project(owner=u) dt = datetime.now() (rp, _) = RecentProject.update_visited(u.userprofile, p, date_visited=dt) qs = RecentProject.objects.filter(user=u.userprofile, project=p, date_visited=dt) self.assertQuerysetEqual(qs, [repr(rp)])
def test_project_user_add(self): project = amcattest.create_test_project() project_admin = User.objects.first() plebs = amcattest.create_test_user() admin = amcattest.create_test_user() admin.is_superuser = True admin.save() url = "/projects/{}/users/add/".format(project.id) # Adding a user as plebs should not be possible self.assertEqual(1, ProjectRole.objects.count()) admin_role = Role.objects.get(label="admin") response = self.post(url, plebs, { "role": admin_role.id, "user": plebs.id }) self.assertEqual(403, response.status_code) self.assertEqual(1, ProjectRole.objects.count()) # Adding as superuser should be possible reader_role = Role.objects.get(label="reader") response = self.post(url, admin, { "role": reader_role.id, "user": plebs.id }) self.assertEqual(302, response.status_code) self.assertEqual(2, ProjectRole.objects.count()) # Plebs gonna be plebs admin_role = Role.objects.get(label="admin") response = self.post(url, plebs, { "role": admin_role.id, "user": plebs.id }) self.assertEqual(403, response.status_code) self.assertEqual(2, ProjectRole.objects.count()) # Test remove if admin on project response = self.post(url, project_admin, { "role": "", "user": plebs.id }) self.assertEqual(302, response.status_code) self.assertEqual(1, ProjectRole.objects.count())
def test_get_class(self): user = amcattest.create_test_user() task = Task.objects.create( uuid="bar", task_name="foo", class_name="amcat.tests.test_task._TestTaskScript", user=user) self.assertEqual(_TestTaskScript.__name__, task.get_class().__name__)
def setUp(self): self.user = amcattest.create_test_user() self.project = amcattest.create_test_project(guest_role=None) ProjectRole.objects.create( user=self.user, project=self.project, role=Role.objects.get(id=ROLE_PROJECT_METAREADER))
def test_get_async_result(self): user = amcattest.create_test_user() task = self._get_task() task_model = Task.objects.create(uuid=task.id, class_name=":)", user=user) self.assertEqual(task.id, task_model.get_async_result().id)
def test_get_handler(self): user = amcattest.create_test_user() task = Task.objects.create( class_name="amcat.tests.test_task._TestTaskWebScript", handler_class_name="amcat.tests.test_task._TestHandler", user=user) self.assertEqual(task.get_handler().__class__, _TestHandler)
def setUp(self): self.user = amcattest.create_test_user() self.project = amcattest.create_test_project(guest_role=None) ProjectRole.objects.create( user=self.user, project=self.project, role=Role.objects.get(id=ROLE_PROJECT_METAREADER) )
def test_get_result(self): user = amcattest.create_test_user() task = self._get_task() task_model = Task.objects.create(uuid=task.id, task_name=task.task_name, class_name=":)", user=user) self.assertEqual(task.id, task_model.uuid) self.assertEqual(task.id, task_model.get_async_result().id) self.assertEqual(task.task_name, task_model.get_async_result().task_name) self.assertEqual(task, task_model.get_async_result())
def test_create_codingjob_batches(self): a = amcattest.create_test_set(10) cj = CodingJob() cj.project = a.project cj.name = "foo" cj.unitschema = amcattest.create_test_schema(project=a.project) cj.articleschema = amcattest.create_test_schema(isarticleschema=True, project=a.project) cj.coder = amcattest.create_test_user() cj.insertuser = amcattest.create_test_user() arts = a.articles.all().values_list("id", flat=True) cjs = create_codingjob_batches(cj, arts, 2) self.assertEqual(5, len(cjs)) cjs = create_codingjob_batches(cj, arts, 3) self.assertEqual(4, len(cjs))
def test_can_create(self): """Are only admins allowed to create new plugins??""" from amcat.models.authorisation import Role u = amcattest.create_test_user() u.role = Role.objects.get(label="reader", projectlevel=False) self.assertFalse(Plugin.can_create(u)) u.role = Role.objects.get(label="admin", projectlevel=False) u.save() self.assertTrue(Plugin.can_create(u))
def setUp(self): username = "******".format(uuid4()) user = create_test_user(username=username, password='******') self.project = amcattest.create_test_project(owner=user) self.cb = amcattest.create_test_codebook(project=self.project) from django.test import Client self.client = Client() success = self.client.login(username=username, password='******') self.assertTrue(success)
def test_cache(self): project = amcattest.create_test_project() aset = amcattest.create_test_set(project=project) user = project.owner # Defeat caches remaining after tests.. query = str(uuid.uuid4()) asets = ArticleSet.objects.filter(id__in=[aset.id]) qa = FooBarQueryAction(user, project, asets, data={ "query": query, "output_type": "text/foo" }) form = qa.get_form() form.full_clean() self.assertTrue(form.is_valid()) self.assertEqual(form.cleaned_data["output_type"], "text/foo") self.assertRaises(NotInCacheError, qa.get_cache) # Test small string qa.set_cache("abc") self.assertEqual(qa.get_cache(), "abc") # Test complex number qa.set_cache(2+1j) self.assertEqual(qa.get_cache(), 2+1j) # Test very large easily compressible string (5 MiB) large_string = "a" * (1024 * 1024 * 5) qa.set_cache(large_string) self.assertEqual(qa.get_cache(), large_string) # Test very large uncompressible string (again ~5 MiB) large_string = ''.join(str(uuid.uuid4()) for _ in range(100000)) self.assertRaises(pylibmc.Error, qa.set_cache, large_string) # If we change only output_type, it should not raise an error qa.set_cache("a") self.assertEqual(qa.get_cache(), "a") qa = FooBarQueryAction(user, project, asets, data={ "query": query, "output_type": "text/bar" }) self.assertEqual(qa.get_cache(), "a") # Change the user. Does it yield a cache error? user = amcattest.create_test_user() qa = FooBarQueryAction(user, project, asets, data={ "query": query, "output_type": "text/foo" }) self.assertRaises(NotInCacheError, qa.get_cache)
def test_permissions(self): # articles should be visible if any of the sets it is in has the correct permissions role_metareader = Role.objects.get(label="metareader", projectlevel=True) role_reader = Role.objects.get(label="reader", projectlevel=True) user = amcattest.create_test_user(username="******", password="******") p1 = amcattest.create_test_project(name="p1") p2 = amcattest.create_test_project(name="p2", owner=user) s1 = amcattest.create_test_set(project=p1) a1 = amcattest.create_test_article(project=p1, articleset=s1, text="Dit is de tekst", headline="hoofdlijn") client = Client() client.login(username="******", password="******") url = reverse("navigator:" + ArticleDetailsView.get_view_name(), args=[p1.id, s1.id, a1.id]) def test(url, can_view=True, can_read_article=True): response = client.get(url) self.assertEqual(response.status_code, 200 if can_view else 403) if can_view: self.assertEqual(response.context['can_view_text'], can_read_article) return response # fred can read it if p1 is reader p1.guest_role = role_reader p1.save() response = test(url) self.assertIn(b"Dit is de tekst", response.content) # but not if guest role is metareader p1.guest_role = role_metareader p1.save() response = test(url, can_read_article=False) self.assertNotIn(b"Dit is de tekst", response.content) self.assertIn(b"hoofdlijn", response.content) # and an error if there is no guest role at all p1.guest_role = None p1.save() test(url, can_view=False) # Unless the article set is added to project 2 (where Fred is owner) p2.articlesets.add(s1) test(url) # Also if project 1 has metareader as guest role p1.guest_role = role_metareader p1.save() test(url)
def test_permissions(self): # articles should be visible if any of the sets it is in has the correct permissions role_metareader = Role.objects.get(label="metareader") role_reader = Role.objects.get(label="reader") user = amcattest.create_test_user(username="******", password="******") p1 = amcattest.create_test_project(name="p1") p2 = amcattest.create_test_project(name="p2", owner=user) s1 = amcattest.create_test_set(project=p1) a1 = amcattest.create_test_article(project=p1, articleset=s1, text="Dit is de tekst", title="hoofdlijn") client = Client() client.login(username="******", password="******") url = reverse("navigator:" + ArticleDetailsView.get_view_name(), args=[p1.id, s1.id, a1.id]) def test(url, can_view=True, can_read_article=True): response = client.get(url) self.assertEqual(response.status_code, 200 if can_view else 403) if can_view: self.assertEqual(response.context['can_view_text'], can_read_article) return response # fred can read it if p1 is reader p1.guest_role = role_reader p1.save() response = test(url) self.assertIn(b"Dit is de tekst", response.content) # but not if guest role is metareader p1.guest_role = role_metareader p1.save() response = test(url, can_read_article=False) self.assertNotIn(b"Dit is de tekst", response.content) self.assertIn(b"hoofdlijn", response.content) # and an error if there is no guest role at all p1.guest_role = None p1.save() test(url, can_view=False) # Unless the article set is added to project 2 (where Fred is owner) p2.articlesets.add(s1) test(url) # Also if project 1 has metareader as guest role p1.guest_role = role_metareader p1.save() test(url)
def _get_args(self, n_articles): s = amcattest.create_test_set(articles=n_articles) u = amcattest.create_test_user() uschema = amcattest.create_test_schema() aschema = amcattest.create_test_schema(isarticleschema=True) return dict(project=s.project.id, articleset=s.id, coder=u.id, articleschema=aschema.id, unitschema=uschema.id, insertuser=u.id)
def _get_args(self, n_articles): s = amcattest.create_test_set(articles=n_articles) u = amcattest.create_test_user() uschema = amcattest.create_test_schema() aschema = amcattest.create_test_schema(isarticleschema=True) return { "project": s.project.id, "articleset": s.id, "coder": u.id, "articleschema": aschema.id, "unitschema": uschema.id, "insertuser": u.id, }
def setUp(self): from amcat.models.coding.coding import CodingValue # create a coding job set with a sensible schema and some articles to 'code' self.schema = amcattest.create_test_schema() self.codebook = amcattest.create_test_codebook() self.code = amcattest.create_test_code(label="CODED") self.codebook.add_code(self.code) texttype = CodingSchemaFieldType.objects.get(pk=1) inttype = CodingSchemaFieldType.objects.get(pk=2) codetype = CodingSchemaFieldType.objects.get(pk=5) create = CodingSchemaField.objects.create self.textfield = create(codingschema=self.schema, fieldnr=1, fieldtype=texttype, label="Text") self.intfield = create(codingschema=self.schema, fieldnr=2, fieldtype=inttype, label="Number") self.codefield = create(codingschema=self.schema, fieldnr=3, fieldtype=codetype, label="Code", codebook=self.codebook) self.users = [amcattest.create_test_user() for _x in range(2)] self.articles, self.jobs, self.asets = [], [], [] for i, user in enumerate([0, 0, 0, 0, 1]): aset = amcattest.create_test_set(articles=2 * (i+1)) self.articles += list(aset.articles.all()) self.asets.append(aset) job = amcattest.create_test_job(articleschema=self.schema, unitschema=self.schema, coder = self.users[user], articleset=aset) self.jobs.append(job) self.an1 = Coding.objects.create(codingjob=self.jobs[0], article=self.articles[0]) self.an2 = Coding.objects.create(codingjob=self.jobs[0], article=self.articles[1]) self.an2.set_status(STATUS_COMPLETE) self.an2.comments = 'Makkie!' self.an2.save() sent = amcattest.create_test_sentence() self.sa1 = Coding.objects.create(codingjob=self.jobs[0], article=self.articles[0], sentence=sent) self.sa2 = Coding.objects.create(codingjob=self.jobs[0], article=self.articles[0], sentence=sent) create = CodingValue.objects.create create(coding=self.sa1, field=self.intfield, intval=1) create(coding=self.sa1, field=self.textfield, strval="bla") create(coding=self.sa2, field=self.textfield, strval="blx") create(coding=self.sa1, field=self.codefield, intval=self.code.id)
def test_has_role(self): metareader_role = Role.objects.get(id=ROLE_PROJECT_METAREADER) reader_role = Role.objects.get(id=ROLE_PROJECT_READER) writer_role = Role.objects.get(id=ROLE_PROJECT_WRITER) admin_role = Role.objects.get(id=ROLE_PROJECT_ADMIN) project = amcattest.create_test_project(guest_role=reader_role) admin = User.objects.first() anon = AnonymousUser() # Anonymous user has project role self.assertTrue(project.has_role(anon, metareader_role)) self.assertTrue(project.has_role(anon, metareader_role.id)) self.assertTrue(project.has_role(anon, metareader_role.label)) self.assertTrue(project.has_role(anon, reader_role)) self.assertTrue(project.has_role(anon, reader_role.id)) self.assertTrue(project.has_role(anon, reader_role.label)) self.assertFalse(project.has_role(anon, writer_role)) self.assertFalse(project.has_role(anon, writer_role.id)) self.assertFalse(project.has_role(anon, writer_role.label)) self.assertFalse(project.has_role(anon, admin_role)) self.assertFalse(project.has_role(anon, admin_role.id)) self.assertFalse(project.has_role(anon, admin_role.label)) # I think we tested string/object/id enough at this point :-) # Superuser is omnipotent superuser = amcattest.create_test_user() superuser.is_superuser = True superuser.save() self.assertTrue(project.has_role(superuser, metareader_role)) self.assertTrue(project.has_role(superuser, reader_role)) self.assertTrue(project.has_role(superuser, writer_role)) self.assertTrue(project.has_role(superuser, admin_role)) # Project admin as well self.assertTrue(project.has_role(admin, metareader_role)) self.assertTrue(project.has_role(admin, reader_role)) self.assertTrue(project.has_role(admin, writer_role)) self.assertTrue(project.has_role(admin, admin_role))
def test_ordered_by_time_desc(self): u = amcattest.create_test_user() profile = u.userprofile p1 = amcattest.create_test_project(owner=u) p2 = amcattest.create_test_project(owner=u) p3 = amcattest.create_test_project(owner=u) dt1 = datetime(2015, 8, 1) dt2 = datetime(2015, 7, 1) dt3 = datetime(2015, 9, 1) (rp1, _) = RecentProject.update_visited(profile, p1, date_visited=dt1) (rp2, _) = RecentProject.update_visited(profile, p2, date_visited=dt2) (rp3, _) = RecentProject.update_visited(profile, p3, date_visited=dt3) #latest date first order = [rp3, rp1, rp2] qs = RecentProject.get_recent_projects(profile) self.assertQuerysetEqual(qs, map(repr, order))
def test_filter(self): from amcat.models import Role from api.rest.resources import ProjectResource r = Role.objects.get(label='admin', projectlevel=True) p = amcattest.create_test_project(name="test") p2 = amcattest.create_test_project(name="not a test", guest_role=r) p3 = amcattest.create_test_project(name="anothertest") # no filter self.assertEqual(self._get_ids(ProjectResource), {p.id, p2.id, p3.id}) # Filter on simple fields: id, pk, and name self.assertEqual(self._get_ids(ProjectResource, id=p2.id), {p2.id}) self.assertEqual(self._get_ids(ProjectResource, name=p.name), {p.id}) self.assertEqual(self._get_ids(ProjectResource, pk=p.id), {p.id}) # Filter on directly related fields self.assertEqual(self._get_ids(ProjectResource, guest_role__id=r.id), {p2.id}) # Filter on 1-to-many field #aset = amcattest.create_test_set(project=p) #self.assertEqual(self._get_ids(ProjectResource, articlesets_set__id=aset.id), {p.id}) # Filter on more n-on-m field: project roles u = amcattest.create_test_user() self.assertEqual( self._get_ids(ProjectResource, projectrole__user__id=u.id), set()) from amcat.models import ProjectRole ProjectRole.objects.create(project=p3, user=u, role=r) self.assertEqual( self._get_ids(ProjectResource, projectrole__user__id=u.id), {p3.id}) # Filter on multiple values of same key. Expect them to be OR'ed. #self.assertEqual(self._get_ids(ProjectResource, id=[p.id, p2.id]), {p2.id, p.id}) self.assertEqual(self._get_ids(ProjectResource, pk=[p.id, p2.id]), {p2.id, p.id})
def setUpClass(cls): super().setUpClass() cls.order = ["noaccess", "readmeta", "read", "write", "admin"] cls.users = {k: amcattest.create_test_user(username="******".format(k)) for k in cls.order} cls.clients = {} for k, v in cls.users.items(): client = Client() client.login(username=v.username, password="******") cls.clients[k] = client cls.litter = amcattest.create_test_project(id=LITTER_PROJECT_ID, owner=cls.users["admin"], guest_role=None) cls.project = amcattest.create_test_project(name="permission-project", owner=cls.users["admin"], guest_role=None) cls.articleset = amcattest.create_test_set(articles=5, project=cls.project) cls.article = cls.articleset.articles.all()[0] cls.alt_project = amcattest.create_test_project(name="alt-permission-project", guest_role_id=ROLE_PROJECT_READER) cls.alt_articleset = amcattest.create_test_set(articles=5, project=cls.alt_project) cls.alt_article = cls.alt_articleset.articles.all()[0] cls.articleset.add_articles([art.id for art in cls.alt_articleset.articles.all()]) ProjectRole.objects.create(project=cls.project, user=cls.users["readmeta"], role_id=ROLE_PROJECT_METAREADER) ProjectRole.objects.create(project=cls.project, user=cls.users["read"], role_id=ROLE_PROJECT_READER) ProjectRole.objects.create(project=cls.project, user=cls.users["write"], role_id=ROLE_PROJECT_WRITER)
def setUp(self): self.u1 = create_test_user() self.u2 = create_test_user() self.c = Client() self.c.login(username=self.u1.username, password="******")
def test_cache(self): project = amcattest.create_test_project() aset = amcattest.create_test_set(project=project) user = project.owner # Defeat caches remaining after tests.. query = str(uuid.uuid4()) asets = ArticleSet.objects.filter(id__in=[aset.id]) qa = FooBarQueryAction(user, project, asets, data={ "query": query, "output_type": "text/foo" }) form = qa.get_form() form.full_clean() self.assertTrue(form.is_valid()) self.assertEqual(form.cleaned_data["output_type"], "text/foo") self.assertRaises(NotInCacheError, qa.get_cache) # Test small string qa.set_cache("abc") self.assertEqual(qa.get_cache(), "abc") # Test complex number qa.set_cache(2 + 1j) self.assertEqual(qa.get_cache(), 2 + 1j) # Test very large easily compressible string (5 MiB) large_string = "a" * (1024 * 1024 * 5) qa.set_cache(large_string) self.assertEqual(qa.get_cache(), large_string) # If we change only output_type, it should not raise an error qa.set_cache("a") self.assertEqual(qa.get_cache(), "a") qa = FooBarQueryAction(user, project, asets, data={ "query": query, "output_type": "text/bar" }) self.assertEqual(qa.get_cache(), "a") # Change the user. Does it yield a cache error? user = amcattest.create_test_user() qa = FooBarQueryAction(user, project, asets, data={ "query": query, "output_type": "text/foo" }) self.assertRaises(NotInCacheError, qa.get_cache)
def setUp(self): self.client = Client() self.user = amcattest.create_test_user() self.user.is_superuser = True self.user.save()
def test_queries(self): """Test the list_queries context manager""" u = amcattest.create_test_user() with list_queries() as l: amcattest.create_test_project(owner=u) self.assertEquals(len(l), 3) # create project, create role for owner, create plugin settings
def test_add(self): u = amcattest.create_test_user() p = AddProject(owner=u.id, name='test', description='test',insert_user=u.id).run() #self.assertEqual(p.insert_user, current_user()) # current_user() doesn't exist anymore self.assertEqual(p.owner, u)
def test_permissions(self): from amcat.models import Role, ProjectRole metareader = Role.objects.get(label='metareader') reader = Role.objects.get(label='reader') p1 = amcattest.create_test_project(guest_role=None) p2 = amcattest.create_test_project(guest_role=metareader) p3 = amcattest.create_test_project(guest_role=reader) p4 = amcattest.create_test_project(guest_role=reader) s1 = amcattest.create_test_set(project=p1) p2.add_set(s1) p3.add_set(s1) s2 = amcattest.create_test_set(project=p2) nobody = amcattest.create_test_user() # anonymous user shoud be able to read articles on p2 and p3 self._get_articles(projectid=p3.id, setid=s1.id, expected_status=200, as_user=nobody) self._get_articles(projectid=p2.id, setid=s1.id, expected_status=200, as_user=nobody) self._get_articles(projectid=p1.id, setid=s1.id, expected_status=403, as_user=nobody) # anonymous user shoud be able to read articles on p3 only self._get_articles(projectid=p3.id, setid=s1.id, expected_status=200, as_user=nobody, text=True) self._get_articles(projectid=p2.id, setid=s1.id, expected_status=403, as_user=nobody, text=True) self._get_articles(projectid=p1.id, setid=s1.id, expected_status=403, as_user=nobody, text=True) # it is illegal to view an articleset through a project it is not a member of self._get_articles(projectid=p4.id, setid=s1.id, expected_status=404) # owner and project readers can access project and (linked) article sets u = p1.owner self._get_articles(projectid=p1.id, setid=s1.id, expected_status=200, as_user=u) self._get_articles(projectid=p2.id, setid=s1.id, expected_status=200, as_user=p2.owner) ProjectRole.objects.create(project=p2, user=u, role=reader) self._get_articles(projectid=p2.id, setid=s1.id, expected_status=200, as_user=u) # User u should be able to add articles to set 1 via p1, but not via p2 or to s2 body = test_article() self._post_articles(body, projectid=p1.id, setid=s1.id, as_user=u, expected_status=201) self._post_articles(body, projectid=p2.id, setid=s2.id, as_user=u, expected_status=403) # You can't modify a linked resource self._post_articles(body, projectid=p2.id, setid=s1.id, as_user=u, expected_status=403) self._post_articles(body, projectid=p2.id, setid=s1.id, as_user=p2.owner, expected_status=403) # You can only add articles to an articleset if you can (1) modify the set, and (2) read the articles a = amcattest.create_test_article(articleset=s1) self._post_articles(a.id, projectid=p2.id, setid=s2.id, as_user=p2.owner, expected_status=201) self._post_articles(a.id, projectid=p2.id, setid=s2.id, as_user=u, expected_status=403) # cannot write # project owner 4 can read s1 (via p3), so it's ok s4 = amcattest.create_test_set(project=p4) a1 = amcattest.create_test_article(articleset=s1) self._post_articles(a1.id, projectid=p4.id, setid=s4.id, as_user=p4.owner, expected_status=201) # but he can't read s2: a2 = amcattest.create_test_article(articleset=s2) self._post_articles(a2.id, projectid=p4.id, setid=s4.id, as_user=p4.owner, expected_status=403) # so he also can't post both of them: self._post_articles([a1.id, a2.id], projectid=p4.id, setid=s4.id, as_user=p4.owner, expected_status=403) # unless he gets read access to project 2 ProjectRole.objects.create(project=p2, user=p4.owner, role=reader) self._post_articles([a1.id, a2.id], projectid=p4.id, setid=s4.id, as_user=p4.owner, expected_status=201)
def test_queries(self): """Test the list_queries context manager""" with list_queries() as l: amcattest.create_test_user() #query_list_to_table(l, output=print) self.assertIn(len(l), [4, 5]) # get affil., create user, select user x2, (pg) get idval
def test_get_class(self): user = amcattest.create_test_user() task = Task.objects.create(uuid="bar", task_name="foo", class_name="amcat.tests.test_task._TestTaskScript", user=user) self.assertEqual(_TestTaskScript.__name__, task.get_class().__name__)
def test_create(self): """Test whether we can create a user""" u = amcattest.create_test_user() self.assertIsNotNone(u)
def setUp(self): self.user = amcattest.create_test_user()