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 _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_unicode(self):
"""Test whether the export can handle unicode in column names and cell values"""
schema = amcattest.create_test_schema(isarticleschema=True)
s1 = 'S1 \xc4\u0193 \u02a2 \u038e\u040e'
s2 = 'S2 \u053e\u06a8 \u090c \u0b8f\u0c8a'
f = CodingSchemaField.objects.create(codingschema=schema,
fieldnr=1,
label=s1,
fieldtype_id=1,
codebook=None)
job = amcattest.create_test_job(unitschema=schema,
articleschema=schema,
narticles=5)
articles = list(job.articleset.articles.all())
amcattest.create_test_coding(
codingjob=job, article=articles[0]).update_values({f: s2})
# test csv
s = self._get_results_script([job], {f: {}}, export_format='csv')
data = base64.b64decode(s.run()['data']).decode('utf-8')
table = [[cell for cell in row] for row in csv.reader(StringIO(data))]
self.assertEqual(table, [[s1], [s2]])
# test json
s = self._get_results_script([job], {f: {}}, export_format='json')
self.assertEqual(json.loads(s.run()),
[[s2]]) # json export has no header (?)
def test_unicode_excel(self):
"""Test whether the export can handle unicode in column names and cell values"""
try:
import openpyxl
except ImportError:
raise unittest.SkipTest(
"OpenPyxl not installed, skipping excel test")
schema = amcattest.create_test_schema(isarticleschema=True)
s1 = u'S1 \xc4\u0193 \u02a2 \u038e\u040e'
s2 = u'S2 \u053e\u06a8 \u090c \u0b8f\u0c8a'
f = CodingSchemaField.objects.create(codingschema=schema,
fieldnr=1,
label=s1,
fieldtype_id=1,
codebook=None)
job = amcattest.create_test_job(unitschema=schema,
articleschema=schema,
narticles=5)
articles = list(job.articleset.articles.all())
coding = amcattest.create_test_coding(codingjob=job,
article=articles[0])
coding.update_values({f: s2})
# test excel, can't test content but we can test output and no error
s = self._get_results_script([job], {f: {}}, export_format='xlsx')
self.assertTrue(s.run())
def test_create_field(self):
"""Can we create a schema field object on a schema"""
fieldtype = CodingSchemaFieldType.objects.get(pk=1)
a = amcattest.create_test_schema()
f = CodingSchemaField.objects.create(codingschema=a,
fieldnr=1,
fieldtype=fieldtype)
self.assertIsNotNone(f)
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_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_create(self):
"""Can we create an coding?"""
schema2 = amcattest.create_test_schema()
j = amcattest.create_test_job(unitschema=self.schema, articleschema=schema2)
a = amcattest.create_test_coding(codingjob=j)
self.assertIsNotNone(a)
self.assertIn(a.coded_article.article, j.articleset.articles.all())
self.assertEqual(a.schema, schema2)
a2 = amcattest.create_test_coding(codingjob=j,
sentence=amcattest.create_test_sentence())
self.assertEqual(a2.schema, self.schema)
def test_create(self):
"""Can we create an coding?"""
schema2 = amcattest.create_test_schema()
j = amcattest.create_test_job(unitschema=self.schema, articleschema=schema2)
a = amcattest.create_test_coding(codingjob=j)
self.assertIsNotNone(a)
self.assertIn(a.article, j.articleset.articles.all())
self.assertEqual(a.schema, schema2)
a2 = amcattest.create_test_coding(codingjob=j,
sentence=amcattest.create_test_sentence())
self.assertEqual(a2.schema, self.schema)
def _create_job(self, fieldtypes):
"""Create a job whose schemas contain the given fields"""
schema = amcattest.create_test_schema()
for i, t in enumerate(fieldtypes):
CodingSchemaField.objects.create(codingschema=schema,
fieldnr=i,
fieldtype=t,
label="field%i" % i,
codebook=self.codebook)
return amcattest.create_test_job(articleschema=schema,
unitschema=schema)
def test_get_schemas(self):
"""Does get_schemas give the right results in the face of multiply imported schemas??"""
p = amcattest.create_test_project()
p2 = amcattest.create_test_project()
p3 = amcattest.create_test_project()
from django import forms
cs = amcattest.create_test_schema(project=p)
p.codingschemas.add(cs)
p2.codingschemas.add(cs)
class TestForm(forms.Form):
c = forms.ModelChoiceField(queryset=p.get_codingschemas())
self.assertEqual(len(p.get_codingschemas().filter(pk=cs.id)), 1)
self.assertEqual(len(p2.get_codingschemas().filter(pk=cs.id)), 1)
self.assertEqual(len(p3.get_codingschemas().filter(pk=cs.id)), 0)
def test_get_schemas(self):
"""Does get_schemas give the right results in the face of multiply imported schemas??"""
p = amcattest.create_test_project()
p2 = amcattest.create_test_project()
p3 = amcattest.create_test_project()
from django import forms
cs = amcattest.create_test_schema(project=p)
p.codingschemas.add(cs)
p2.codingschemas.add(cs)
class TestForm(forms.Form):
c = forms.ModelChoiceField(queryset=p.get_codingschemas())
self.assertEqual(len(p.get_codingschemas().filter(pk=cs.id)), 1)
self.assertEqual(len(p2.get_codingschemas().filter(pk=cs.id)), 1)
self.assertEqual(len(p3.get_codingschemas().filter(pk=cs.id)), 0)
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_update_values(self):
"""Does update_values on an coding work?"""
a = amcattest.create_test_coding(codingjob=self.job)
self.assertEqual(_valuestr(a), "")
a.set_value(self.intfield, 12)
self.assertEqual(_valuestr(a), "number:12")
a.update_values({self.strfield:"bla"})
self.assertEqual(_valuestr(a), "text:bla")
a.update_values({self.strfield:None, self.intfield:"999", self.codefield:self.c})
self.assertEqual(_valuestr(a), "code:CODED;number:999")
newfield = CodingSchemaField.objects.create(
codingschema=amcattest.create_test_schema(),
label="text", fieldtype=self.strfield.fieldtype)
self.assertRaises(ValueError, a.update_values, {newfield : "3"})
def test_unicode_excel(self):
"""Test whether the export can handle unicode in column names and cell values"""
try:
import openpyxl
except ImportError:
raise unittest.SkipTest("OpenPyxl not installed, skipping excel test")
schema = amcattest.create_test_schema(isarticleschema=True)
s1 = u'S1 \xc4\u0193 \u02a2 \u038e\u040e'
s2 = u'S2 \u053e\u06a8 \u090c \u0b8f\u0c8a'
f = CodingSchemaField.objects.create(codingschema=schema, fieldnr=1, label=s1,
fieldtype_id=1, codebook=None)
job = amcattest.create_test_job(unitschema=schema, articleschema=schema, narticles=5)
articles = list(job.articleset.articles.all())
amcattest.create_test_coding(codingjob=job, article=articles[0]).update_values({f:s2})
# test excel, can't test content but we can test output and no error
s = self._get_results_script([job], {f : {}}, export_format='xlsx')
self.assertTrue(s.run())
def test_update_values(self):
"""Does update_values on an coding work?"""
a = amcattest.create_test_coding(codingjob=self.job)
self.assertEqual(_valuestr(a), "")
a.set_value(self.intfield, 12)
self.assertEqual(_valuestr(a), "number:12")
a.update_values({self.strfield: "bla"})
self.assertEqual(_valuestr(a), "text:'bla'")
a.update_values({
self.strfield: None,
self.intfield: "999",
self.codefield: self.c
})
self.assertEqual(_valuestr(a), "code:<Code: CODED>;number:999")
newfield = CodingSchemaField.objects.create(
codingschema=amcattest.create_test_schema(),
label="text",
fieldtype=self.strfield.fieldtype)
self.assertRaises(ValueError, a.update_values, {newfield: "3"})
def test_unicode(self):
"""Test whether the export can handle unicode in column names and cell values"""
schema = amcattest.create_test_schema(isarticleschema=True)
s1 = u'S1 \xc4\u0193 \u02a2 \u038e\u040e'
s2 = u'S2 \u053e\u06a8 \u090c \u0b8f\u0c8a'
f = CodingSchemaField.objects.create(codingschema=schema, fieldnr=1, label=s1,
fieldtype_id=1, codebook=None)
job = amcattest.create_test_job(unitschema=schema, articleschema=schema, narticles=5)
articles = list(job.articleset.articles.all())
amcattest.create_test_coding(codingjob=job, article=articles[0]).update_values({f:s2})
# test csv
s = self._get_results_script([job], {f : {}}, export_format='csv')
table = [[cell.decode('utf-8') for cell in row] for row in csv.reader(StringIO(s.run()))]
self.assertEqual(table, [[s1], [s2]])
# test json
s = self._get_results_script([job], {f : {}}, export_format='json')
self.assertEqual(json.loads(s.run()), [[s2]]) # json export has no header (?)
def test_create(self):
"""Test whether coding schema objects can be created"""
s = amcattest.create_test_schema(name='test')
self.assertEqual(s.name, 'test')
def test_create(self):
"""Test whether coding schema objects can be created"""
s = amcattest.create_test_schema(name='test')
self.assertEqual(s.name, 'test')
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_create_field(self):
"""Can we create a schema field object on a schema"""
fieldtype = CodingSchemaFieldType.objects.get(pk=1)
a = amcattest.create_test_schema()
f = CodingSchemaField.objects.create(codingschema=a, fieldnr=1, fieldtype=fieldtype)
self.assertIsNotNone(f)
