def test_to_json(self):
import functools
o1, o2 = amcattest.create_test_code(), amcattest.create_test_code()
schema_with_fields = amcattest.create_test_schema_with_fields()
code_field = schema_with_fields[4]
c = functools.partial(self.condition, schema_with_fields[0])
tree = to_json(parse(c("{}=={}".format(code_field.id, o1.id))))
self.assertEquals(
json.loads(tree), {
"type":
EQUALS,
"values": [{
"type": "codingschemafield",
"id": code_field.id
}, {
"type": "code",
"id": o1.id
}]
})
tree = parse(c("{}=={}".format(code_field.id, o1.id)))
self.assertEquals(json.dumps(to_json(tree, serialise=False)),
to_json(tree))
def test_to_json(self):
import functools
o1, o2 = amcattest.create_test_code(), amcattest.create_test_code()
schema_with_fields = amcattest.create_test_schema_with_fields()
code_field = schema_with_fields[4]
c = functools.partial(self.condition, schema_with_fields[0])
tree = to_json(parse(c("{}=={}".format(code_field.id, o1.id))))
self.assertEquals(json.loads(tree), {"type": EQUALS, "values": [
{"type": "codingschemafield", "id": code_field.id},
{"type": "code", "id": o1.id}
]})
tree = parse(c("{}=={}".format(code_field.id, o1.id)))
self.assertEquals(json.dumps(to_json(tree, serialise=False)), to_json(tree))
def rule(context, coding):
condition = evaluate_condition(codingruletoolkit.parse(codingrule), context)
if not condition:
return
success = apply_action(codingrule.action, codingrule.field, context)
if not success:
raise CodingValidationError("Validation failed for rule {}: {}".format(codingrule.id, codingrule.label),
fields=[(coding.id, codingrule.field.id, codingrule.label)])
def test_clean_tree(self):
import functools
o1, o2 = amcattest.create_test_code(), amcattest.create_test_code()
codebook, codebook_codes = amcattest.create_test_codebook_with_codes()
schema_with_fields = amcattest.create_test_schema_with_fields(codebook=codebook)
schema = schema_with_fields[0]
code_field = schema_with_fields[4]
c = functools.partial(self.condition, schema)
tree = parse(c("{code_field.id}=={o1.id}".format(**locals())))
self.assertRaises(ValidationError, clean_tree, schema, tree)
tree = parse(c("{code_field.id}=={code.id}".format(code_field=code_field, code=codebook.codes[0])))
self.assertEquals(clean_tree(schema, tree), None)
self.assertRaises(ValidationError, clean_tree, amcattest.create_test_schema_with_fields()[0], tree)
def test_clean_tree(self):
import functools
o1, o2 = amcattest.create_test_code(), amcattest.create_test_code()
codebook, codebook_codes = amcattest.create_test_codebook_with_codes()
schema_with_fields = amcattest.create_test_schema_with_fields(
codebook=codebook)
schema = schema_with_fields[0]
code_field = schema_with_fields[4]
c = functools.partial(self.condition, schema)
tree = parse(c("{code_field.id}=={o1.id}".format(**locals())))
self.assertRaises(ValidationError, clean_tree, schema, tree)
tree = parse(
c("{code_field.id}=={code.id}".format(code_field=code_field,
code=codebook.codes[0])))
self.assertEquals(clean_tree(schema, tree), None)
self.assertRaises(ValidationError, clean_tree,
amcattest.create_test_schema_with_fields()[0], tree)
def clean_condition(self):
condition = self.cleaned_data["condition"]
try:
tree = codingruletoolkit.parse(CodingRule(condition=condition))
except (Code.DoesNotExist, CodingSchemaField.DoesNotExist, CodingRule.DoesNotExist) as e:
raise ValidationError(e)
except SyntaxError as e:
raise ValidationError(e)
if tree is not None:
codingruletoolkit.clean_tree(self.codingschema, tree)
return condition
def clean_condition(self):
condition = self.cleaned_data["condition"]
try:
tree = codingruletoolkit.parse(CodingRule(condition=condition))
except (Code.DoesNotExist, CodingSchemaField.DoesNotExist, CodingRule.DoesNotExist) as e:
raise ValidationError(e)
except SyntaxError as e:
raise ValidationError(e)
if tree is not None:
codingruletoolkit.clean_tree(self.codingschema, tree)
return condition
def get_parsed_condition(self, obj):
try:
return codingruletoolkit.to_json(codingruletoolkit.parse(obj), serialise=False)
except (ValidationError, SyntaxError) as e:
return json.dumps(str(e))
def get_parsed_condition(self, obj):
try:
return codingruletoolkit.to_json(codingruletoolkit.parse(obj),
serialise=False)
except (ValidationError, SyntaxError):
return None
def test_parse(self):
import functools
o1, o2 = amcattest.create_test_code(), amcattest.create_test_code()
schema_with_fields = amcattest.create_test_schema_with_fields()
schema = schema_with_fields[0]
codebook = schema_with_fields[1]
text_field = schema_with_fields[2]
number_field = schema_with_fields[3]
code_field = schema_with_fields[4]
c = functools.partial(self.condition, schema)
# Empty conditions should return None
self.assertEquals(parse(c("")), None)
self.assertEquals(parse(c("()")), None)
# Recursion should be checked for
cr = CodingRule.objects.create(codingschema=schema,
label="foo",
condition="()")
cr.condition = str(cr.id)
self.assertRaises(SyntaxError, parse, cr)
# Nonexisting fields should raise an error
cr.condition = "0==2"
self.assertRaises(CodingSchemaField.DoesNotExist, parse, cr)
cr.condition = "{}==0".format(code_field.id)
self.assertRaises(Code.DoesNotExist, parse, cr)
cr.condition = "0"
self.assertRaises(CodingRule.DoesNotExist, parse, cr)
cr.condition = "{}=={}".format(code_field.id, o1.id)
self.assertTrue(parse(cr) is not None)
# Wrong inputs for fields should raise an error
for inp in ("'a'", "0.2", "u'a'"):
cr.condition = "{}=={}".format(number_field.id, inp)
self.assertRaises(SyntaxError, parse, cr)
for inp in ("'a'", "0.2", "u'a'", repr(str(o1.id))):
cr.condition = "{}=={}".format(code_field.id, inp)
self.assertRaises(SyntaxError, parse, cr)
for inp in ("'a'", "0.2", "2"):
cr.condition = "{}=={}".format(text_field.id, inp)
self.assertRaises(SyntaxError, parse, cr)
# "Good" inputs shoudl not yield an error
for field, inp in ((number_field, 1), (text_field, "u'a'"),
(code_field, o1.id)):
cr.condition = "{}=={}".format(field.id, inp)
self.assertTrue(parse(cr) is not None)
# Should accept Python-syntax (comments, etc)
cr.condition = """{}==(
# This should be a comment)
{})""".format(text_field.id, "u'a'")
self.assertTrue(parse(cr) is not None)
## Testing output
tree = parse(c("not {}".format(cr.id)))
self.assertEquals(tree["type"], NOT)
self.assertTrue(not isinstance(tree["value"], CodingRule))
tree = parse(c("{}=={}".format(text_field.id, "u'a'")))
self.assertEquals(tree, {"type": EQUALS, "values": (text_field, u'a')})
cr.save()
tree = parse(c("{cr.id} or {cr.id}".format(cr=cr)))
self.assertEquals(tree, {"type": OR, "values": (parse(cr), parse(cr))})
# Should accept greater than / greater or equal to / ...
parse(c("{number_field.id} > 5".format(**locals())))
parse(c("{number_field.id} < 5".format(**locals())))
parse(c("{number_field.id} >= 5".format(**locals())))
parse(c("{number_field.id} <= 5".format(**locals())))
# ..but not if schemafieldtype is text or code
self.assertRaises(SyntaxError, parse,
c("{text_field.id} > 5".format(**locals())))
self.assertRaises(SyntaxError, parse,
c("{code_field.id} > 5".format(**locals())))
def test_parse(self):
import functools
o1, o2 = amcattest.create_test_code(), amcattest.create_test_code()
schema_with_fields = amcattest.create_test_schema_with_fields()
schema = schema_with_fields[0]
codebook = schema_with_fields[1]
text_field = schema_with_fields[2]
number_field = schema_with_fields[3]
code_field = schema_with_fields[4]
c = functools.partial(self.condition, schema)
# Empty conditions should return None
self.assertEquals(parse(c("")), None)
self.assertEquals(parse(c("()")), None)
# Recursion should be checked for
cr = CodingRule.objects.create(codingschema=schema, label="foo", condition="()")
cr.condition = str(cr.id)
self.assertRaises(SyntaxError, parse, cr)
# Nonexisting fields should raise an error
cr.condition = "0==2"
self.assertRaises(CodingSchemaField.DoesNotExist, parse, cr)
cr.condition = "{}==0".format(code_field.id)
self.assertRaises(Code.DoesNotExist, parse, cr)
cr.condition = "0"
self.assertRaises(CodingRule.DoesNotExist, parse, cr)
cr.condition = "{}=={}".format(code_field.id, o1.id)
self.assertTrue(parse(cr) is not None)
# Wrong inputs for fields should raise an error
for inp in ("'a'", "0.2", "u'a'"):
cr.condition = "{}=={}".format(number_field.id, inp)
self.assertRaises(SyntaxError, parse, cr)
for inp in ("'a'", "0.2", "u'a'", repr(str(o1.id))):
cr.condition = "{}=={}".format(code_field.id, inp)
self.assertRaises(SyntaxError, parse, cr)
for inp in ("'a'", "0.2", "2"):
cr.condition = "{}=={}".format(text_field.id, inp)
self.assertRaises(SyntaxError, parse, cr)
# "Good" inputs shoudl not yield an error
for field, inp in ((number_field, 1), (text_field, "u'a'"), (code_field, o1.id)):
cr.condition = "{}=={}".format(field.id, inp)
self.assertTrue(parse(cr) is not None)
# Should accept Python-syntax (comments, etc)
cr.condition = """{}==(
# This should be a comment)
{})""".format(text_field.id, "u'a'")
self.assertTrue(parse(cr) is not None)
## Testing output
tree = parse(c("not {}".format(cr.id)))
self.assertEquals(tree["type"], NOT)
self.assertTrue(not isinstance(tree["value"], CodingRule))
tree = parse(c("{}=={}".format(text_field.id, "u'a'")))
self.assertEquals(tree, {"type": EQUALS, "values": (text_field, u'a')})
cr.save()
tree = parse(c("{cr.id} or {cr.id}".format(cr=cr)))
self.assertEquals(tree, {"type": OR, "values": (parse(cr), parse(cr))})
# Should accept greater than / greater or equal to / ...
parse(c("{number_field.id} > 5".format(**locals())))
parse(c("{number_field.id} < 5".format(**locals())))
parse(c("{number_field.id} >= 5".format(**locals())))
parse(c("{number_field.id} <= 5".format(**locals())))
# ..but not if schemafieldtype is text or code
self.assertRaises(SyntaxError, parse, c("{text_field.id} > 5".format(**locals())))
self.assertRaises(SyntaxError, parse, c("{code_field.id} > 5".format(**locals())))
