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 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 _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_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_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 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 _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 _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_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_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 _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 setUp(self):
self.client = Client()
self.user = amcattest.create_test_user()
self.user.is_superuser = True
self.user.save()
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()
def setUp(self):
self.user = amcattest.create_test_user()
def test_create(self):
"""Test whether we can create a user"""
u = amcattest.create_test_user()
self.assertIsNotNone(u)
