def test_success(self, req, db_session, check_csrf_token): """ It should allow removal of entities from a visit. """ from datetime import date, timedelta from pyramid.httpexceptions import HTTPOk from occams_datastore import models as datastore from occams_studies import models cycle = models.Cycle(name='week-1', title=u'', week=1) schema = datastore.Schema(name=u'sample', title=u'', publish_date=date.today()) study = models.Study(name=u'somestudy', title=u'Some Study', short_title=u'sstudy', code=u'000', consent_date=date.today(), cycles=[cycle], schemata=set([schema])) site = models.Site(name=u'ucsd', title=u'UCSD') default_state = (db_session.query( datastore.State).filter_by(name=u'pending-entry').one()) t_a = date.today() + timedelta(days=5) patient_a = models.Patient(site=site, pid=u'12345') visit_a = models.Visit(patient=patient_a, cycles=[cycle], visit_date=t_a) entity_a_1 = datastore.Entity(schema=schema, collect_date=t_a, state=default_state) entity_a_2 = datastore.Entity(schema=schema, collect_date=t_a, state=default_state) entity_a_3 = datastore.Entity(schema=schema, collect_date=t_a, state=default_state) list(map(visit_a.entities.add, [entity_a_1, entity_a_2, entity_a_3])) db_session.add_all([visit_a, study]) db_session.flush() req.json_body = {'forms': [entity_a_2.id, entity_a_3.id]} res = self._call_fut(visit_a['forms'], req) # refresh the session so we can get a correct listing db_session.expunge_all() visit_a = db_session.query(models.Visit).get(visit_a.id) assert isinstance(res, HTTPOk) assert sorted([e.id for e in [entity_a_1]]) == \ sorted([e.id for e in visit_a.entities])
def test_validator_max_constraint(db_session): """ It should validate string/number value min/max """ from datetime import date from occams_datastore import models from occams_datastore.exc import ConstraintError schema = models.Schema(name=u'Foo', title=u'', publish_date=date(2000, 1, 1)) s1 = models.Attribute( schema=schema, name='s1', title=u'Section 1', type='section', order=0) models.Attribute( schema=schema, parent_attribute=s1, name=u'test', title=u'', type=u'string', is_required=False, value_max=3, order=0) db_session.add(schema) db_session.flush() entity = models.Entity(schema=schema) db_session.add(entity) entity['test'] = None with pytest.raises(ConstraintError): entity['test'] = u'foobar' entity['test'] = u'foo' db_session.flush() assert 'foo' == entity['test']
def check_value_max_constraint(db_session, type_, limit, below, equal, over): """ It should validate against maximum constraints """ from datetime import date from occams_datastore import models from occams_datastore.exc import ConstraintError schema = models.Schema(name=u'Foo', title=u'', publish_date=date(2000, 1, 1)) s1 = models.Attribute( schema=schema, name='s1', title=u'Section 1', type='section', order=0) entity = models.Entity(schema=schema) db_session.add(entity) db_session.flush() models.Attribute( schema=schema, parent_attribute=s1, name=type_, title=u'', type=type_, is_required=False, value_max=limit, order=0) entity[type_] = None entity[type_] = below entity[type_] = equal with pytest.raises(ConstraintError): entity[type_] = over models.Attribute( schema=schema, parent_attribute=s1, name=u'boolean', title=u'', type=u'boolean', value_max=10, order=1) with pytest.raises(NotImplementedError): entity['boolean'] = True
def preview(context, request): """ Preview form for test-drivining. """ db_session = request.db_session form_class = make_form(db_session, context, show_metadata=False) form = form_class(request.POST) form_id = 'form-preview' entity = None if request.method == 'POST' and form.validate(): upload_path = tempfile.mkdtemp() entity = datastore.Entity(schema=context) try: apply_data(db_session, entity, form.patch_data, upload_path) finally: shutil.rmtree(upload_path) # Remove from session so entity or attributes don't persist in db db_session.expunge(entity) return { 'entity': entity, 'form_id': form_id, 'form_content': render_form( form, cancel_url=request.current_route_path(), attr={ 'id': form_id, 'method': 'POST', 'action': request.current_route_path(_query={}), 'role': 'form' }) }
def test_entity_force_date(db_session): """ It should maintain a date object for date types. (Sometimes applications will blindly assign datetimes...) """ from datetime import date, datetime from occams_datastore import models schema = models.Schema(name=u'Foo', title=u'', publish_date=date(2000, 1, 1)) s1 = models.Attribute( schema=schema, name='s1', title=u'Section 1', type='section', order=0) entity = models.Entity(schema=schema) # Do simple values simpleName = 'choicesimple' schema.attributes[simpleName] = models.Attribute( schema=schema, parent_attribute=s1, title=u'', type='date', is_required=False, order=1) now = datetime.now() today = now.date() entity[simpleName] = now db_session.flush() assert isinstance(entity[simpleName], date) assert today == entity[simpleName]
def test_file_is_deleted(self, db_session): """ Test file is deleted on the system after a non-FieldStorage object is passed to apply_data """ import os from datetime import date from occams_datastore import models as datastore from mock import Mock schema = datastore.Schema( name=u'test', title=u'', publish_date=date.today(), attributes={ 'q1': datastore.Attribute( name=u'q1', title=u'', type='blob', order=0 ) }) entity = datastore.Entity(schema=schema) formdata = {'q1': u''} with open(os.path.join(self.tmpdir, 'test.txt'), 'w'): fullpath = os.path.join(self.tmpdir, 'test.txt') entity['q1'] = Mock(path=fullpath) self._call_fut(db_session, entity, formdata, self.tmpdir) assert not os.path.exists(fullpath)
def test_one_record_exists_db_after_update(self, db_session): """ Test if one updated record exists in value_blob tbl after FieldStorage object passed to apply_data """ import os import cgi from datetime import date from occams_datastore import models as datastore from mock import Mock schema = datastore.Schema( name=u'test', title=u'', publish_date=date.today(), attributes={ 'q1': datastore.Attribute( name=u'q1', title=u'', type='blob', order=0 ) }) entity = datastore.Entity(schema=schema) form = cgi.FieldStorage() form.filename = u'test.txt' form.file = form.make_file() form.file.write(u'test_content') form.file.seek(0) formdata = {'q1': form} with open(os.path.join(self.tmpdir, 'test.txt'), 'w'): fullpath = os.path.join(self.tmpdir, 'test.txt') entity['q1'] = Mock(path=fullpath) self._call_fut(db_session, entity, formdata, self.tmpdir) blob = db_session.query(datastore.ValueBlob).one() entity_id = blob.entity.id form_update = cgi.FieldStorage() form_update.filename = u'test2.txt' form_update.file = form.make_file() form_update.file.write(u'test_content') form_update.file.seek(0) formdata2 = {'q1': form_update} self._call_fut(db_session, entity, formdata2, self.tmpdir) blob = db_session.query(datastore.ValueBlob).filter_by( file_name=u'test2.txt').first() entity_id_after_update = blob.entity_id assert entity_id == entity_id_after_update
def test_entity_choices(db_session): """ It should properly handle choices """ from datetime import date from occams_datastore import models schema = models.Schema(name=u'Foo', title=u'', publish_date=date(2000, 1, 1)) s1 = models.Attribute( schema=schema, name='s1', title=u'Section 1', type='section', order=0) entity = models.Entity(schema=schema) db_session.add(entity) db_session.flush() # Do simple values simpleName = 'choicesimple' schema.attributes[simpleName] = models.Attribute( schema=schema, parent_attribute=s1, name=simpleName, title=u'', type='choice', is_required=False, order=1, choices={ '001': models.Choice(name=u'001', title=u'Foo', order=1), '002': models.Choice(name=u'002', title=u'Bar', order=2), '003': models.Choice(name=u'003', title=u'Baz', order=3), '004': models.Choice(name=u'004', title=u'Caz', order=4), '005': models.Choice(name=u'005', title=u'Jaz', order=5), }) entity[simpleName] = None db_session.flush() assert entity[simpleName] is None entity[simpleName] = u'002' db_session.flush() assert u'002' == entity[simpleName] # Now try collections collectionName = 'choicecollection' schema.attributes[collectionName] = models.Attribute( schema=schema, parent_attribute=s1, name=collectionName, title=u'', type='choice', is_collection=True, order=2, choices={ '001': models.Choice(name=u'001', title=u'Foo', order=1), '002': models.Choice(name=u'002', title=u'Bar', order=2), '003': models.Choice(name=u'003', title=u'Baz', order=3), '004': models.Choice(name=u'004', title=u'Caz', order=4), '005': models.Choice(name=u'005', title=u'Jaz', order=5)}) entity[collectionName] = [u'001', u'002', u'005'] db_session.flush() assert sorted([u'001', u'002', u'005']) == \ sorted(entity['choicecollection'])
def edit_json(context, request): check_csrf_token(request) db_session = request.db_session is_new = isinstance(context, models.PatientFactory) form = PatientSchema(context, request).from_json(request.json_body) if not form.validate(): raise HTTPBadRequest(json={'errors': wtferrors(form)}) if is_new: # if any errors occurr after this, this PID is essentially wasted patient = models.Patient( pid=six.text_type(generate(db_session, form.site.data.name))) db_session.add(patient) else: patient = context patient.site = form.site.data if form.references.data: inputs = dict(((r['reference_type'].id, r['reference_number']), r) for r in form.references.data) for r in patient.references: try: # Remove already-existing values from the inputs del inputs[(r.reference_type.id, r.reference_number)] except KeyError: # References not in the inputs indicate they have been removed db_session.delete(r) for r in six.itervalues(inputs): db_session.add( models.PatientReference( patient=patient, reference_type=r['reference_type'], reference_number=r['reference_number'])) # Add the patient forms if is_new: schemata_query = (db_session.query(datastore.Schema).join( models.patient_schema_table)) pending_entry = (db_session.query( datastore.State).filter_by(name=u'pending-entry').one()) for schema in schemata_query: patient.entities.add( datastore.Entity(schema=schema, state=pending_entry)) db_session.flush() db_session.refresh(patient) return view_json(patient, request)
def test_entity_add_unpublished_schema(db_session): """ It should not allow adding entities related to unpublished schemata """ from occams_datastore import models from occams_datastore.exc import InvalidEntitySchemaError schema = models.Schema(name=u'Foo', title=u'') entity = models.Entity(schema=schema) db_session.add(entity) with pytest.raises(InvalidEntitySchemaError): db_session.flush()
def populate(self, app, db_session): import transaction from occams_studies import models as studies from occams_datastore import models as datastore from datetime import date # Any view-dependent data goes here # Webtests will use a different scope for its transaction with transaction.manager: user = datastore.User(key=USERID) db_session.info['blame'] = user db_session.add(user) db_session.flush() site = studies.Site(name=u'UCSD', title=u'UCSD', description=u'UCSD Campus', create_date=date.today()) patient = studies.Patient(initials=u'ian', nurse=u'*****@*****.**', site=site, pid=u'123') form = datastore.Schema(name=u'test_schema', title=u'test_title', publish_date=date(2015, 1, 1)) study = studies.Study(name=u'test_study', code=u'test_code', consent_date=date(2014, 12, 23), is_randomized=False, title=u'test_title', short_title=u'test_short', schemata=set([form])) cycle = studies.Cycle(name=u'TestCycle', title=u'TestCycle', week=39, study=study) visit = studies.Visit(patient=patient, cycles=[cycle], visit_date='2015-01-01') entity = datastore.Entity(schema=form, collect_date=date(2015, 1, 1)) db_session.add(study) db_session.add(patient) db_session.add(visit) db_session.add(entity) patient.entities.add(entity)
def test_old_file_is_deleted_after_update(self, db_session): """ Test if previous file is deleted from the system after a new FieldStoarage object is passed to apply_data """ import os import cgi from datetime import date from occams_datastore import models as datastore from mock import Mock schema = datastore.Schema( name=u'test', title=u'', publish_date=date.today(), attributes={ 'q1': datastore.Attribute( name=u'q1', title=u'', type='blob', order=0 ) }) entity = datastore.Entity(schema=schema) form = cgi.FieldStorage() form.filename = u'test.txt' form.file = form.make_file() form.file.write(u'test_content') form.file.seek(0) formdata = {'q1': form} with open(os.path.join(self.tmpdir, 'test.txt'), 'w'): fullpath = os.path.join(self.tmpdir, 'test.txt') entity['q1'] = Mock(path=fullpath) self._call_fut(db_session, entity, formdata, self.tmpdir) form_update = cgi.FieldStorage() form_update.filename = u'test2.txt' form_update.file = form.make_file() form_update.file.write(u'test_content') form_update.file.seek(0) formdata2 = {'q1': form_update} self._call_fut(db_session, entity, formdata2, self.tmpdir) assert not os.path.exists(fullpath)
def test_enrollment(self, db_session): """ It should add enrollment-specific metadata to the report """ from datetime import date, timedelta from occams_datastore import models as datastore from occams_studies import models from occams_studies.exports.schema import SchemaPlan schema = datastore.Schema(name=u'termination', title=u'Termination', publish_date=date.today(), attributes={ 'foo': datastore.Attribute( name='foo', title=u'', type='string', order=0, ) }) entity = datastore.Entity(schema=schema, collect_date=date.today()) patient = models.Patient(site=models.Site(name='ucsd', title=u'UCSD'), pid=u'12345', entities=[entity]) study = models.Study(name=u'cooties', short_title=u'CTY', code=u'999', consent_date=date.today() - timedelta(365), title=u'Cooties') enrollment = models.Enrollment( patient=patient, study=study, consent_date=date.today() - timedelta(5), latest_consent_date=date.today() - timedelta(3), termination_date=date.today(), entities=[entity]) db_session.add_all([schema, entity, patient, study, enrollment]) plan = SchemaPlan.from_schema(db_session, schema.name) codebook = list(plan.codebook()) query = plan.data() codebook_columns = [c['field'] for c in codebook] data_columns = [c['name'] for c in query.column_descriptions] record = query.one() assert sorted(codebook_columns) == sorted(data_columns) assert record.site == patient.site.name assert record.pid == patient.pid assert record.enrollment == enrollment.study.name assert record.enrollment_ids == str(enrollment.id) assert record.visit_cycles is None assert record.collect_date == entity.collect_date
def test_old_file_is_deleted_db_after_empty_string_applied( self, db_session): """ Test if previous file is deleted from db after a non-FieldStoarage is passed to apply_data """ import os import cgi from datetime import date from occams_datastore import models as datastore from mock import Mock schema = datastore.Schema( name=u'test', title=u'', publish_date=date.today(), attributes={ 'q1': datastore.Attribute( name=u'q1', title=u'', type='blob', order=0 ) }) entity = datastore.Entity(schema=schema) form = cgi.FieldStorage() form.filename = u'test.txt' form.file = form.make_file() form.file.write(u'test_content') form.file.seek(0) formdata = {'q1': form} with open(os.path.join(self.tmpdir, 'test.txt'), 'w'): fullpath = os.path.join(self.tmpdir, 'test.txt') entity['q1'] = Mock(path=fullpath) self._call_fut(db_session, entity, formdata, self.tmpdir) formdata = {'q1': u''} self._call_fut(db_session, entity, formdata, self.tmpdir) blob = db_session.query(datastore.ValueBlob).filter_by( file_name=u'test.txt').first() assert blob is None
def test_entity_default_collect_date(db_session): """ It should default to today's date as the collect_date if not is provided """ from datetime import date from occams_datastore import models # Make sure the system can auto-assign a collect date for the entry schema = models.Schema(name=u'Foo', title=u'', publish_date=date(2000, 1, 1)) entity = models.Entity(schema=schema) db_session.add(entity) db_session.flush() assert date.today() == entity.collect_date # If one is supplied by the user, don't do anything collect_date = date(2010, 9, 1) entity = models.Entity( schema=schema, collect_date=collect_date) db_session.add(entity) db_session.flush() assert entity.collect_date == collect_date
def _make_entity(self): from datetime import date from occams_datastore import models as datastore schema = datastore.Schema( name=u'test', title=u'', publish_date=date.today(), attributes={ 'q1': datastore.Attribute( name=u'q1', title=u'', type='string', is_required=True, order=0, ) }) entity = datastore.Entity(schema=schema) return entity
def populate(self, app, db_session): import transaction from occams_studies import models as studies from occams_datastore import models as datastore from datetime import date # Any view-dependent data goes here # Webtests will use a different scope for its transaction with transaction.manager: user = datastore.User(key=USERID) db_session.info['blame'] = user db_session.add(user) db_session.flush() site = studies.Site(name=u'UCSD', title=u'UCSD', description=u'UCSD Campus', create_date=date.today()) patient = studies.Patient(initials=u'ian', nurse=u'*****@*****.**', site=site, pid=u'123') form = datastore.Schema(name=u'test_schema', title=u'test_title', publish_date=date(2015, 1, 1)) study = studies.Study(name=u'test_study', code=u'test_code', consent_date=date(2014, 12, 23), is_randomized=False, title=u'test_title', short_title=u'test_short', schemata=set([form])) state = (db_session.query( datastore.State).filter_by(name=u'pending-entry').one()) db_session.add( datastore.Entity(state=state, schema=form, collect_date=date(2015, 2, 1))) db_session.add( studies.Enrollment(patient=patient, study=study, consent_date=date(2014, 12, 22)))
def test_cascade_forms(self, req, db_session, check_csrf_token): """ It should remove all visit-associated forms. """ from datetime import date from occams_datastore import models as datastore from occams_studies import models schema = datastore.Schema(name=u'sample', title=u'Some Sample', publish_date=date.today()) study = models.Study(name=u'somestudy', title=u'Some Study', short_title=u'sstudy', code=u'000', consent_date=date.today()) cycle = models.Cycle(name=u'week-10', title=u'Week 10', week=10) study.cycles.append(cycle) patient = models.Patient(site=models.Site(name=u'ucsd', title=u'UCSD'), pid=u'12345') enrollment = models.Enrollment(study=study, patient=patient, consent_date=date.today()) visit = models.Visit(patient=patient, cycles=[cycle], visit_date=date.today()) visit.entities.add( datastore.Entity(schema=schema, collect_date=date.today())) db_session.add_all([patient, enrollment, study, visit]) db_session.flush() visit_id = visit.id self._call_fut(visit, req) assert db_session.query(models.Visit).get(visit_id) is None assert 0 == db_session.query(datastore.Entity).count()
def test_file_is_inserted_to_db(self, db_session): """ Test if a new record is inserted to value_blob table after a FieldStorage object is passed to apply_data """ import os import cgi from datetime import date from occams_datastore import models as datastore from mock import Mock schema = datastore.Schema( name=u'test', title=u'', publish_date=date.today(), attributes={ 'q1': datastore.Attribute( name=u'q1', title=u'', type='blob', order=0 ) }) entity = datastore.Entity(schema=schema) form = cgi.FieldStorage() form.filename = u'test.txt' form.file = form.make_file() form.file.write(u'test_content') form.file.seek(0) formdata = {'q1': form} with open(os.path.join(self.tmpdir, 'test.txt'), 'w'): fullpath = os.path.join(self.tmpdir, 'test.txt') entity['q1'] = Mock(path=fullpath) self._call_fut(db_session, entity, formdata, self.tmpdir) blob = db_session.query(datastore.ValueBlob).filter_by( file_name=u'test.txt').one() assert blob.file_name == u'test.txt'
def test_add_drsc_entity_already_has_entity(self, db_session): """Should not add entity becuase it exists already.""" from datetime import date from occams_studies import models as studies from occams_datastore import models as datastore patient_site = studies.Site(name=u'test_site', title=u'test_clinic') patient = studies.Patient(pid=u'1234', site=patient_site) default_state = (db_session.query( datastore.State).filter_by(name='complete').one()) target_schema = datastore.Schema(name=u'Demographics', title=u'Demographics', publish_date=date.today(), attributes={ 'yob': datastore.Attribute( name=u'yob', title=u'yob', type=u'number', order=0) }) collect_date = date.today() entity = datastore.Entity(schema=target_schema, collect_date=collect_date, state=default_state) patient.entities.add(entity) db_session.flush() target_schema_name = u'Demographics' self._call_fut(db_session, patient, target_schema_name, target_schema, collect_date) patient = (db_session.query( studies.Patient).filter_by(pid=u'1234').one()) assert len(patient.entities) == 1
def test_skip_validation_if_from_complete(self, db_session): from webob.multidict import MultiDict from occams_datastore import models as datastore from occams_forms.renderers import \ make_form, states, modes, entity_data schema = self._make_schema(db_session) entity = datastore.Entity( schema=schema, state=( db_session.query(datastore.State) .filter_by(name=states.COMPLETE) .one())) Form = make_form( db_session, schema, entity=entity, transition=modes.ALL) formdata = MultiDict({ 'ofworkflow_-state': states.PENDING_CORRECTION, }) form = Form(formdata, data=entity_data(entity)) assert form.validate(), form.errors
def test_patient(self, db_session): """ It should add patient-specific metadata to the report """ from datetime import date from occams_datastore import models as datastore from occams_studies import models from occams_studies.exports.schema import SchemaPlan schema = datastore.Schema(name=u'contact', title=u'Contact Details', publish_date=date.today(), attributes={ 'foo': datastore.Attribute( name='foo', title=u'', type='string', order=0, ) }) entity = datastore.Entity(schema=schema, collect_date=date.today()) patient = models.Patient(site=models.Site(name='ucsd', title=u'UCSD'), pid=u'12345', entities=[entity]) db_session.add_all([schema, entity, patient]) db_session.flush() plan = SchemaPlan.from_schema(db_session, schema.name) codebook = list(plan.codebook()) query = plan.data() codebook_columns = [c['field'] for c in codebook] data_columns = [c['name'] for c in query.column_descriptions] record = query.one() assert sorted(codebook_columns) == sorted(data_columns) assert record.site == patient.site.name assert record.pid == patient.pid assert record.enrollment is None assert record.visit_cycles is None assert record.visit_date is None assert record.collect_date == entity.collect_date
def test_list_not_include_rand(self, db_session): """ It should not include randomization data if specified. """ from datetime import date, timedelta from occams_datastore import models as datastore from occams_studies import models from occams_studies.exports.schema import SchemaPlan schema = datastore.Schema(name=u'vitals', title=u'Vitals', publish_date=date.today(), attributes={ 'foo': datastore.Attribute( name='foo', title=u'', type='string', order=0, ) }) entity = datastore.Entity(collect_date=date.today(), schema=schema) study = models.Study(name=u'study1', short_title=u'S1', code=u'001', consent_date=date.today() - timedelta(365), title=u'Study 1') armga = models.Arm(name=u'groupa', title=u'GROUP A', study=study) stratum = models.Stratum(study=study, arm=armga, block_number=12384, randid=u'8484', entities=[entity]) db_session.add_all([schema, entity, stratum]) db_session.flush() plans = SchemaPlan.list_all(db_session, include_private=True) assert len(plans) == 1 plans = SchemaPlan.list_all(db_session, include_rand=False) assert len(plans) == 0
def _make_form(self, db_session): from datetime import date from occams_datastore import models as datastore from occams_forms.renderers import make_form schema = datastore.Schema(name=u'dymmy_schema', title=u'Dummy Schema', publish_date=date.today(), attributes={ 'dummy_field': datastore.Attribute(name=u'dummy_field', title=u'Dummy Field', type='string', order=0) }) entity = datastore.Entity(schema=schema) db_session.add(entity) db_session.flush() return make_form(db_session, schema, entity=entity)
def test_without_state(self, req, db_session): """ It should generate none if no state data is available """ import mock from occams_datastore import models as datastore from datetime import date myfirst = datastore.Schema(name=u'myfirst', title=u'My First Schema', publish_date=date.today()) mydata = datastore.Entity(schema=myfirst) db_session.add(mydata) db_session.flush() mydata.__parent__ = mock.MagicMock() mydata.__parent__.__parent__ = mock.MagicMock() req.session.changed = mock.Mock() res = self._call_fut(mydata, req) assert res['state'] is None
def test_choice_constraint(db_session): """ It should validate against choice constraints """ from datetime import date from occams_datastore import models from occams_datastore.exc import ConstraintError schema = models.Schema(name=u'Foo', title=u'', publish_date=date(2000, 1, 1)) s1 = models.Attribute( schema=schema, name='s1', title=u'Section 1', type='section', order=0) models.Attribute( schema=schema, parent_attribute=s1, name=u'test', title=u'', type=u'choice', is_required=False, order=0, choices={ '001': models.Choice(name=u'001', title=u'Foo', order=0), '002': models.Choice(name=u'002', title=u'Bar', order=1), '003': models.Choice(name=u'003', title=u'Baz', order=2)}) db_session.add(schema) db_session.flush() entity = models.Entity(schema=schema) db_session.add(entity) entity['test'] = None entity['test'] = u'002' db_session.flush() entry = ( db_session.query(models.ValueChoice) .filter(models.ValueChoice.value.has(name=u'002')) .one()) assert entry.value.name == '002' # Should not be able to set it to something outside of the specified # choice constraints with pytest.raises(ConstraintError): entity['test'] = u'999'
def test_state_entity_relationship(db_session): """ It should implement state/entity relationship """ from datetime import date from occams_datastore import models schema = models.Schema(name=u'Foo', title=u'Foo', publish_date=date(2000, 1, 1)) pending_entry = models.State(name=u'pending-entry', title=u'Pending Entry') entity = models.Entity(schema=schema) db_session.add_all([pending_entry, entity]) db_session.flush() assert entity.state is None assert pending_entry.entities.count() == 0 entity.state = pending_entry db_session.flush() assert entity.state is not None assert pending_entry.entities.count() == 1
def test_with_state(self, req, db_session): """ It should generate state data is available """ from datetime import date import mock from occams_datastore import models as datastore myfirst = datastore.Schema(name=u'myfirst', title=u'My First Schema', publish_date=date.today()) mydata = datastore.Entity( schema=myfirst, state=(db_session.query( datastore.State).filter_by(name=u'pending-entry').one())) db_session.add(mydata) db_session.flush() mydata.__parent__ = mock.MagicMock() mydata.__parent__.__parent__ = mock.MagicMock() req.session.changed = mock.Mock() res = self._call_fut(mydata, req) assert res['state'] is not None
def test_entity_blob_type(db_session): """ It should be able to keep track of file uploads (will not be storing in DB) """ from occams_datastore import models from datetime import date schema = models.Schema(name='HasBlob', title=u'', publish_date=date(2000, 1, 1)) s1 = models.Attribute( schema=schema, name='s1', title=u'Section 1', type='section', order=0) schema.attributes['theblob'] = models.Attribute( parent_attribute=s1, name=u'theblob', title=u'', type='blob', order=0) entity = models.Entity(schema=schema) db_session.add(entity) db_session.flush() entity_id = entity.id # Add value entity['theblob'] = models.BlobInfo(file_name=u'foo', path='bar/baz.gif') db_session.add(entity) db_session.flush() entity = db_session.query(models.Entity).get(entity_id) blob = entity['theblob'] assert u'foo' == blob.file_name assert 'bar/baz.gif' == blob.path # Clear value entity['theblob'] = None db_session.flush() entity = db_session.query(models.Entity).get(entity_id) blob = entity['theblob'] assert blob is None
def test_validator_pattern_constraint(db_session): """ It should validate against string pattern constraints """ from datetime import date from occams_datastore import models from occams_datastore.exc import ConstraintError schema = models.Schema(name=u'Foo', title=u'', publish_date=date(2000, 1, 1)) s1 = models.Attribute( schema=schema, name='s1', title=u'Section 1', type='section', order=0) models.Attribute( schema=schema, parent_attribute=s1, name=u'test', title=u'', type=u'string', is_required=False, # Valid US phone number pattern=r'\d{3}-\d{3}-\d{4}', order=0) db_session.add(schema) db_session.flush() entity = models.Entity(schema=schema) db_session.add(entity) entity['test'] = None with pytest.raises(ConstraintError): entity['test'] = u'trollol' entity['test'] = u'123-456-7890' db_session.flush() assert '123-456-7890' == entity['test']