class User(models.Model):
name = fields.Field()
email = fields.Field()
@classmethod
def decode(self, value):
return {'foo': 'bar'}
class Person(Model):
# required fields
patient_id = fields.Integer(required=True)
relation = fields.Field(choices=filter(
lambda x: x not in [Relation.father.value, Relation.mother.value],
[x.value for x in Relation.__members__.values()]),
required=True)
# optional fields
relation_status = fields.Field(
choices=[x.value for x in AffectionStatus.__members__.values()],
default=AffectionStatus.unknown.value)
class Patient(Model):
# required fields
sex = fields.Field(choices=[
'46XY', '46XX', '45X', '47XX', '47XXY', '47XYY', 'other', 'unknown'
],
required=True)
reference = fields.String(required=True)
project_id = fields.Integer(required=True)
# optional fields
age = fields.Field(choices=['unknown', 'Prenatal'] +
[str(x) for x in range(0, 101)],
default="unknown")
prenatal = fields.Field(choices=[x for x in range(10, 43)].append(None))
aneuploidy = fields.Boolean(default=False)
user_id = fields.Integer()
note = fields.String()
consent = fields.Field(choices=['No', 'Yes'], default="No")
class Phenotype(Model):
# required fields
person_id = fields.Integer(required=True)
phenotype_id = fields.Integer(required=True)
# optional fields
observation = fields.Field(
choices=[x.value for x in TermPresence.__members__.values()],
default=TermPresence.present.value)
def test_should_return_value_returned_by_decoder(self):
def decoder(value):
return value.swapcase()
field = fields.Field(decoders=[decoder])
expect(field.decode(IRRELEVANT_VALUE)).to(
equal(IRRELEVANT_VALUE.swapcase()))
def test_when_second_validator_raises_validation_error_then_raises_exception(self):
def validator2(value):
if value == 'foo':
raise errors.ValidationError()
field = fields.Field(stub_validator, validator2)
expect(lambda: field.validate('foo')).to.raise_error(
errors.ValidationError)
def test_when_first_validator_raises_validation_error_then_raises_exception(
self):
def validator1(value):
if value == 'foo':
raise errors.ValidationError()
field = fields.Field(validator1, stub_validator)
expect(lambda: field.validate('foo')).to(
raise_error(errors.ValidationError))
def test_should_return_value_returned_by_decoders_in_order(self):
def decoder1(value):
return int(value)
def decoder2(value):
return str(value)
field = fields.Field(decoders=[decoder1, decoder2])
expect(field.decode(NUMERIC_STRING_VALUE)).to(
equal(NUMERIC_STRING_VALUE))
class ArticleCreate(Model):
title = fields.String(required=True)
description = fields.String()
tags = fields.Collection(fields.String)
references = fields.Collection(fields.String)
categories = fields.Collection(fields.Integer)
authors = fields.Collection(AuthorCreate)
custom_fields = fields.Field()
defined_type = DefinedType()
funding = fields.String()
license = fields.Integer()
class Snv(Model):
# required fields
patient_id = fields.Integer(required=True)
assembly = fields.Field(
choices=[x.value for x in Assembly.__members__.values()],
required=True)
chr = fields.Field(choices=["X", "Y", "MT"] +
[str(x) for x in range(1, 23)],
required=True)
start = fields.Integer(required=True)
ref_allele = fields.String(required=True)
alt_allele = fields.String(required=True)
genotype = fields.Field(
choices=[x.value for x in Genotype.__members__.values()],
required=True)
# optional fields
user_transcript = fields.String()
user_gene = fields.String()
intergenic = fields.Boolean(default=False)
inheritance = fields.Field(
choices=[x.value for x in Inheritance.__members__.values()],
default=Inheritance.unknown.value)
pathogenicity = fields.Field(
choices=[x.value for x in ClinicalSignificance.__members__.values()
].append(None))
contribution = fields.Field(
choices=[x.value
for x in Penetrance.__members__.values()].append(None))
shared = fields.String()
class FileL1(Model):
id = fields.Integer(required=True)
name = fields.String(required=True)
size = fields.Integer()
status = fields.String()
viewer_type = fields.String()
preview_state = fields.String()
preview_meta = fields.Field()
is_link_only = fields.Boolean()
upload_url = fields.String()
upload_token = fields.String()
supplied_md5 = fields.String()
computed_md5 = fields.String()
class CollectionCreate(Model):
title = fields.String(required=True)
description = fields.String()
# doi = fields.String()
articles = fields.Collection(fields.Integer)
authors = fields.Collection(AuthorCreate)
categories = fields.Collection(fields.Integer)
tags = fields.Collection(fields.String)
references = fields.Collection(fields.String)
# resource_id = fields.String()
# resource_doi = fields.String()
# resource_link = fields.String()
# resource_title = fields.String()
# resource_versions = fields.Integer()
custom_fields = fields.Field()
def test_when_required_is_true_then_value_shouldnt_be_none(self):
field = fields.Field(required=True)
expect(lambda: field.validate(None)).to(
raise_error(errors.ValidationError, end_with('required')))
def test_when_validate_without_validation_errors_then_does_not_raise(self):
field = fields.Field(stub_validator, stub_validator)
field.validate('foo')
def test_when_no_kwargs_then_field_options_is_an_empty_dict(self):
field = fields.Field()
expect(field.options).to.equal({})
class User(models.Model):
name = fields.Field(name='username')
email = fields.Field(name='emailAddress')
def test_should_be_empty_dict_if_no_kwargs_passed(self):
field = fields.Field()
expect(field.options).to(equal({}))
def test_should_return_value_if_there_are_not_decoders(self):
field = fields.Field()
expect(field.decode(IRRELEVANT_VALUE)).to(equal(IRRELEVANT_VALUE))
class User(models.Model):
name = fields.Field()
last_update = fields.Field(read_only=True)
def test_should_be_passed_kwargs_dict(self):
kwargs = dict(required=True, primary=True, foo='bar')
field = fields.Field(**kwargs)
expect(field.options).to(equal(kwargs))
def test_when_not_choices_then_value_can_be_whatever_value(self):
field = fields.Field()
field.validate('foo')
def test_when_choices_then_value_should_be_in_choices(self):
field = fields.Field(choices=['foo', 'bar'])
expect(lambda: field.validate('baz')).to(
raise_error(errors.ValidationError, contain(' in ')))
def test_when_not_required_then_value_can_be_none(self):
field = fields.Field()
field.validate(None)
def test_when_kwargs_then_field_options_is_a_dict_with_these_args(self):
kwargs = dict(required=True, primary=True, foo='bar')
field = fields.Field(**kwargs)
expect(field.options).to.equal(kwargs)
class User(models.Model):
name = fields.Field()
email = fields.Field()
class UserWithToken(User):
token = fields.Field()
def test_when_required_is_false_then_value_can_be_none(self):
field = fields.Field(required=False)
field.validate(None)
class User(Model):
name = fields.Field(name='username')
