From 920b87fc1ca01f37881057539a19bdf96a30a492 Mon Sep 17 00:00:00 2001
From: Natasha Singh <dukedesi22@gmail.com>
Date: Thu, 15 Feb 2018 15:06:37 -0500
Subject: [PATCH] :white_check_mark: Update all unit tests to support Study
 entity

---
 tests/aliquot/test_aliquot_models.py          |  12 +-
 tests/demographic/test_demographic_models.py  |  33 ++-
 .../demographic/test_demographic_resources.py |  15 +-
 tests/diagnosis/test_diagnosis_models.py      | 194 +++++++-----------
 tests/diagnosis/test_diagnosis_resources.py   |  12 +-
 .../genomic_file/test_genomic_file_models.py  |   8 +-
 tests/participant/test_models.py              |   6 +-
 tests/participant/test_resources.py           |  23 ++-
 tests/sample/test_sample_models.py            |  13 +-
 tests/sample/test_sample_resources.py         |  19 +-
 .../test_sequencingexperiment_models.py       |  12 +-
 tests/test_api.py                             |  21 +-
 tests/test_errors.py                          |  11 +-
 13 files changed, 200 insertions(+), 179 deletions(-)

diff --git a/tests/aliquot/test_aliquot_models.py b/tests/aliquot/test_aliquot_models.py
index 78e2e3148..c96c858b0 100644
--- a/tests/aliquot/test_aliquot_models.py
+++ b/tests/aliquot/test_aliquot_models.py
@@ -2,6 +2,7 @@
 import uuid
 
 from dataservice.extensions import db
+from dataservice.api.study.models import Study
 from dataservice.api.participant.models import Participant
 from dataservice.api.sample.models import Sample
 from dataservice.api.aliquot.models import Aliquot
@@ -20,6 +21,9 @@ def create_participant_sample_aliquot(self):
         create a participant, sample, and aliquot save to db
         returns participant_id, sample_id, and aliquot_id
         """
+        # Create study
+        study = Study(external_id='phs001')
+
         dt = datetime.now()
         participant_id = "Test_Subject_0"
         sample_id = "Test_Sample_0"
@@ -45,7 +49,8 @@ def create_participant_sample_aliquot(self):
         sample_0 = Sample(**sample_data, aliquots=[aliquot_0])
         participant_0 = Participant(
             external_id=participant_id,
-            samples=[sample_0])
+            samples=[sample_0],
+            study=study)
         db.session.add(participant_0)
         db.session.commit()
         return participant_id, sample_id, aliquot_id
@@ -67,10 +72,13 @@ def test_create_aliquot(self):
         """
         Test creation of aliquot
         """
+        # Create study
+        study = Study(external_id='phs001')
+
         dt = datetime.now()
         participant_id = "Test_Subject_0"
         # creating participant
-        p = Participant(external_id=participant_id)
+        p = Participant(external_id=participant_id, study=study)
         db.session.add(p)
         db.session.commit()
 
diff --git a/tests/demographic/test_demographic_models.py b/tests/demographic/test_demographic_models.py
index 53cebc75b..ee54ba770 100644
--- a/tests/demographic/test_demographic_models.py
+++ b/tests/demographic/test_demographic_models.py
@@ -3,6 +3,7 @@
 
 from sqlalchemy.exc import IntegrityError
 
+from dataservice.api.study.models import Study
 from dataservice.api.participant.models import Participant
 from dataservice.api.demographic.models import Demographic
 from dataservice.extensions import db
@@ -18,10 +19,13 @@ def test_create(self):
         """
         Test create demographic
         """
+        study = Study(external_id='phs001')
+        db.session.add(study)
+        db.session.commit()
 
         # Create and save participant
         participant_id = 'Test subject 0'
-        p = Participant(external_id=participant_id)
+        p = Participant(external_id=participant_id, study_id=study.kf_id)
         db.session.add(p)
         db.session.commit()
 
@@ -200,26 +204,13 @@ def test_get_participant_demographic(self):
         """
         Test get demographic via the participant
         """
-        # Create demographic
-        data = {
-            'external_id': 'demo_1',
-            'race': 'asian'
-        }
-        d = Demographic(**data)
-
-        # Create and save participant
-        participant_id = 'Test subject 0'
-        p = Participant(external_id=participant_id, demographic=d)
-        db.session.add(p)
-        db.session.commit()
+        # Create and save demographic
+        participant_id, demo_id = self._create_save_demographic()
 
         p = Participant.query.filter_by(external_id=participant_id).\
             one_or_none()
 
-        p_demo = p.demographic
-
-        self.assertEqual(p_demo.external_id, d.external_id)
-        self.assertEqual(p_demo.race, d.race)
+        self.assertEqual(p.demographic.external_id, demo_id)
 
     def _create_save_demographic(self):
         """
@@ -229,6 +220,11 @@ def _create_save_demographic(self):
         Create a demographic and add it to participant as kwarg
         Save participant
         """
+        # Create study
+        study = Study(external_id='phs001')
+        db.session.add(study)
+        db.session.commit()
+
         # Create demographic
         demo_id = 'demo_1'
         data = {
@@ -241,7 +237,8 @@ def _create_save_demographic(self):
 
         # Create and save participant
         participant_id = 'Test subject 0'
-        p = Participant(external_id=participant_id, demographic=d)
+        p = Participant(external_id=participant_id, demographic=d,
+                        study_id=study.kf_id)
         db.session.add(p)
         db.session.commit()
 
diff --git a/tests/demographic/test_demographic_resources.py b/tests/demographic/test_demographic_resources.py
index 5dd5fe0ba..087f140f6 100644
--- a/tests/demographic/test_demographic_resources.py
+++ b/tests/demographic/test_demographic_resources.py
@@ -1,12 +1,12 @@
 import json
 from flask import url_for
 from urllib.parse import urlparse
-from pprint import pprint
 
 from dataservice.extensions import db
 from dataservice.api.common import id_service
 from dataservice.api.demographic.models import Demographic
 from dataservice.api.participant.models import Participant
+from dataservice.api.study.models import Study
 from tests.utils import FlaskTestCase
 
 DEMOGRAPHICS_URL = 'api.demographics'
@@ -21,8 +21,12 @@ def test_post(self):
         """
         Test create a new demographic
         """
+        study = Study(external_id='phs001')
+        db.session.add(study)
+        db.session.commit()
+
         # Create a participant
-        p = Participant(external_id='Test subject 0')
+        p = Participant(external_id='Test subject 0', study_id=study.kf_id)
         db.session.add(p)
         db.session.commit()
 
@@ -339,6 +343,10 @@ def _create_save_to_db(self):
         Create a demographic and add it to participant as kwarg
         Save participant
         """
+        study = Study(external_id='phs001')
+        db.session.add(study)
+        db.session.commit()
+
         # Create demographic
         kwargs = {
             'external_id': 'd1',
@@ -350,7 +358,8 @@ def _create_save_to_db(self):
 
         # Create and save participant with demographic
         participant_id = 'Test subject 0'
-        p = Participant(external_id=participant_id, demographic=d)
+        p = Participant(external_id=participant_id, demographic=d,
+                        study_id=study.kf_id)
         db.session.add(p)
         db.session.commit()
 
diff --git a/tests/diagnosis/test_diagnosis_models.py b/tests/diagnosis/test_diagnosis_models.py
index cbd44aaf3..942ee639f 100644
--- a/tests/diagnosis/test_diagnosis_models.py
+++ b/tests/diagnosis/test_diagnosis_models.py
@@ -3,6 +3,7 @@
 
 from sqlalchemy.exc import IntegrityError
 
+from dataservice.api.study.models import Study
 from dataservice.api.participant.models import Participant
 from dataservice.api.diagnosis.models import Diagnosis
 from dataservice.extensions import db
@@ -14,135 +15,48 @@ class ModelTest(FlaskTestCase):
     Test Diagnosis database model
     """
 
-    def test_create(self):
+    def test_create_and_find(self):
         """
         Test create diagnosis
         """
-        # Create and save participant
-        participant_id = 'Test subject 0'
-        p = Participant(external_id=participant_id)
-        db.session.add(p)
-        db.session.commit()
-
-        # Create diagnoses
-        data = {
-            'external_id': 'diag_1',
-            'diagnosis': 'cold',
-            'age_at_event_days': 120,
-            'participant_id': p.kf_id
-        }
+        diagnoses, kwarg_dict = self._create_diagnoses()
         dt = datetime.now()
-        d1 = Diagnosis(**data)
-        db.session.add(d1)
-        data['external_id'] = 'diag_2'
-        data['diagnosis'] = 'flu'
-        d2 = Diagnosis(**data)
-        db.session.add(d2)
-        db.session.commit()
-
-        self.assertEqual(Diagnosis.query.count(), 2)
-        new_diagnosis = Diagnosis.query.all()[1]
-        self.assertGreater(new_diagnosis.created_at, dt)
-        self.assertGreater(new_diagnosis.modified_at, dt)
-        self.assertIs(type(uuid.UUID(new_diagnosis.uuid)), uuid.UUID)
 
-        self.assertEqual(new_diagnosis.external_id, data['external_id'])
-        self.assertEqual(new_diagnosis.diagnosis,
-                         data['diagnosis'])
+        self.assertEqual(Diagnosis.query.count(), len(diagnoses))
 
-    def test_create_via_participant(self):
-        """
-        Test create diagnoses via creation of participant
-        """
-        # Create two diagnoses
-        pd = ['cold', 'flu']
-        d1 = Diagnosis(diagnosis=pd[0])
-        d2 = Diagnosis(diagnosis=pd[1])
-        p = Participant(external_id='p1')
-
-        # Add to participant and save
-        p.diagnoses.extend([d1, d2])
-        db.session.add(p)
-        db.session.commit()
-
-        # Check diagnoses were created
-        self.assertEqual(Diagnosis.query.count(), 2)
-
-        # Check Particpant has the diagnoses
-        for d in Participant.query.first().diagnoses:
-            self.assertIn(d.diagnosis, pd)
-
-        # Diagnoses have the participant
-        p = Participant.query.first()
-        for d in Diagnosis.query.all():
-            self.assertEqual(d.participant_id, p.kf_id)
-
-    def test_find_diagnosis(self):
-        """
-        Test find one diagnosis
-        """
-        # Create two diagnoses
-        pd = ['cold', 'flu']
-        d1 = Diagnosis(diagnosis=pd[0])
-        d2 = Diagnosis(diagnosis=pd[1])
-        p = Participant(external_id='p1')
-
-        # Add to participant and save
-        p.diagnoses.extend([d1, d2])
-        db.session.add(p)
-        db.session.commit()
-
-        # Find diagnosis
-        d = Diagnosis.query.\
-            filter_by(diagnosis=pd[0]).one_or_none()
-        self.assertEqual(d.diagnosis, pd[0])
+        for k, kwargs in kwarg_dict.items():
+            d = Diagnosis.query.filter_by(external_id=k).one()
+            for key, value in kwargs.items():
+                self.assertEqual(value, getattr(d, key))
+            self.assertGreater(dt, d.created_at)
+            self.assertGreater(dt, d.modified_at)
+            self.assertIs(type(uuid.UUID(d.uuid)), uuid.UUID)
 
     def test_update_diagnosis(self):
         """
         Test update diagnosis
         """
-        # Create two diagnoses
-        pd = ['cold', 'flu']
-        d1 = Diagnosis(diagnosis=pd[0])
-        d2 = Diagnosis(diagnosis=pd[1])
-        p = Participant(external_id='p1')
-
-        # Add to participant and save
-        p.diagnoses.extend([d1, d2])
-        db.session.add(p)
-        db.session.commit()
+        diagnoses, kwarg_dict = self._create_diagnoses()
 
-        # Update and save
-        d = Diagnosis.query.filter_by(diagnosis=pd[0]).one_or_none()
-        diag = 'west nile'
-        d.diagnosis = diag
+        d = diagnoses[0]
+        d.diagnosis = 'flu'
         db.session.commit()
-
         # Check updated values
-        d = Diagnosis.query.filter_by(diagnosis=diag).one_or_none()
-        self.assertIsNot(d, None)
+        d = Diagnosis.query.get(d.kf_id)
+        self.assertIsNot(d.diagnosis, 'flu')
 
     def test_delete_diagnosis(self):
         """
         Test delete diagnosis
         """
-        # Create two diagnoses
-        pd = ['cold', 'flu']
-        d1 = Diagnosis(diagnosis=pd[0])
-        d2 = Diagnosis(diagnosis=pd[1])
-        p = Participant(external_id='p1')
+        diagnoses, kwarg_dict = self._create_diagnoses()
 
-        # Add to participant and save
-        p.diagnoses.extend([d1, d2])
-        db.session.add(p)
-        db.session.commit()
-
-        # Choose one and delete it
-        d = Diagnosis.query.filter_by(diagnosis=pd[0]).one_or_none()
-        db.session.delete(d)
+        p = Participant.query.first()
+        kf_id = diagnoses[0].kf_id
+        del p.diagnoses[0]
         db.session.commit()
 
-        d = Diagnosis.query.filter_by(diagnosis=pd[0]).one_or_none()
+        d = Diagnosis.query.get(kf_id)
         self.assertIs(d, None)
         diagnoses = [_d for _d in p.diagnoses]
         self.assertNotIn(d, diagnoses)
@@ -151,26 +65,14 @@ def test_delete_diagnosis_via_participant(self):
         """
         Test delete related diagnoses via deletion of participant
         """
-        # Create two diagnoses
-        pd = ['cold', 'flu']
-        d1 = Diagnosis(diagnosis=pd[0])
-        d2 = Diagnosis(diagnosis=pd[1])
-        p = Participant(external_id='p1')
-
-        # Add to participant and save
-        p.diagnoses.extend([d1, d2])
-        db.session.add(p)
-        db.session.commit()
+        diagnoses, kwarg_dict = self._create_diagnoses()
 
-        # Delete participant
+        p = Participant.query.first()
         db.session.delete(p)
         db.session.commit()
 
         # Check that diagnoses have been deleted
-        d1 = Diagnosis.query.filter_by(diagnosis=pd[0]).one_or_none()
-        d2 = Diagnosis.query.filter_by(diagnosis=pd[1]).one_or_none()
-        self.assertIs(d1, None)
-        self.assertIs(d2, None)
+        self.assertEqual(0, Diagnosis.query.count())
 
     def test_not_null_constraint(self):
         """
@@ -185,7 +87,9 @@ def test_not_null_constraint(self):
         d = Diagnosis(**data)
 
         # Add to db
-        self.assertRaises(IntegrityError, db.session.add(d))
+        db.session.add(d)
+        with self.assertRaises(IntegrityError):
+            db.session.commit()
 
     def test_foreign_key_constraint(self):
         """
@@ -200,4 +104,46 @@ def test_foreign_key_constraint(self):
         d = Diagnosis(**data)
 
         # Add to db
-        self.assertRaises(IntegrityError, db.session.add(d))
+        db.session.add(d)
+        with self.assertRaises(IntegrityError):
+            db.session.commit()
+
+    def _create_diagnosis(self, _id, participant_id=None):
+        """
+        Create diagnosis
+        """
+        kwargs = {
+            'external_id': 'id_{}'.format(_id),
+            'diagnosis': 'diagnosis {}'.format(_id),
+            'age_at_event_days': 365
+        }
+        if participant_id:
+            kwargs['participant_id'] = participant_id
+        return Diagnosis(**kwargs), kwargs
+
+    def _create_diagnoses(self, total=2):
+        """
+        Create diagnoses and other requred entities
+        """
+        # Create study
+        study = Study(external_id='phs001')
+
+        # Create participant
+        participant_id = 'Test subject 0'
+        p = Participant(external_id=participant_id, study=study)
+        db.session.add(p)
+        db.session.commit()
+
+        # Create diagnoses
+        diagnoses = []
+        kwarg_dict = {}
+        for i in range(total):
+            d, kwargs = self._create_diagnosis(i)
+            kwarg_dict[d.external_id] = kwargs
+            diagnoses.append(d)
+
+        p.diagnoses.extend(diagnoses)
+
+        db.session.commit()
+
+        return diagnoses, kwarg_dict
diff --git a/tests/diagnosis/test_diagnosis_resources.py b/tests/diagnosis/test_diagnosis_resources.py
index 69a01e481..4ad62e980 100644
--- a/tests/diagnosis/test_diagnosis_resources.py
+++ b/tests/diagnosis/test_diagnosis_resources.py
@@ -6,6 +6,7 @@
 from dataservice.api.common import id_service
 from dataservice.api.diagnosis.models import Diagnosis
 from dataservice.api.participant.models import Participant
+from dataservice.api.study.models import Study
 from tests.utils import FlaskTestCase
 
 DIAGNOSES_URL = 'api.diagnoses'
@@ -20,8 +21,11 @@ def test_post(self):
         """
         Test create a new diagnosis
         """
+        # Create study
+        study = Study(external_id='phs001')
+
         # Create a participant
-        p = Participant(external_id='Test subject 0')
+        p = Participant(external_id='Test subject 0', study=study)
         db.session.add(p)
         db.session.commit()
 
@@ -352,6 +356,9 @@ def _create_save_to_db(self):
         Create a diagnosis and add it to participant as kwarg
         Save participant
         """
+        # Create study
+        study = Study(external_id='phs001')
+
         # Create diagnosis
         kwargs = {
             'external_id': 'd1',
@@ -362,7 +369,8 @@ def _create_save_to_db(self):
 
         # Create and save participant with diagnosis
         participant_id = 'Test subject 0'
-        p = Participant(external_id=participant_id, diagnoses=[d])
+        p = Participant(external_id=participant_id, diagnoses=[d],
+                        study=study)
         db.session.add(p)
         db.session.commit()
 
diff --git a/tests/genomic_file/test_genomic_file_models.py b/tests/genomic_file/test_genomic_file_models.py
index abf669d9f..2b4f6cded 100644
--- a/tests/genomic_file/test_genomic_file_models.py
+++ b/tests/genomic_file/test_genomic_file_models.py
@@ -3,6 +3,7 @@
 from sqlalchemy.exc import IntegrityError
 
 from dataservice.extensions import db
+from dataservice.api.study.models import Study
 from dataservice.api.participant.models import Participant
 from dataservice.api.sample.models import Sample
 from dataservice.api.aliquot.models import Aliquot
@@ -193,7 +194,12 @@ def _create_save_dependents(self):
         Dependent entities: participant, samples, aliquots,
         sequencing_experiments
         """
-        p = Participant(external_id='p1', samples=self._create_samples())
+        # Create study
+        study = Study(external_id='phs001')
+
+        # Create participant
+        p = Participant(external_id='p1', samples=self._create_samples(),
+                        study=study)
         db.session.add(p)
         db.session.commit()
 
diff --git a/tests/participant/test_models.py b/tests/participant/test_models.py
index 63d5dd846..97a7bfe5f 100644
--- a/tests/participant/test_models.py
+++ b/tests/participant/test_models.py
@@ -3,6 +3,7 @@
 
 from dataservice.extensions import db
 from dataservice.api.participant.models import Participant
+from dataservice.api.study.models import Study
 from tests.utils import FlaskTestCase
 
 
@@ -10,12 +11,15 @@ class ModelTest(FlaskTestCase):
     """
     Test database model
     """
+
     def _create_participant(self, external_id="Test_Participant_0"):
         """
         Create participant with external id
         """
+        s = Study(external_id='phs001')
         p = Participant(external_id=external_id)
-        db.session.add(p)
+        s.participants.append(p)
+        db.session.add(s)
         db.session.commit()
 
         return p
diff --git a/tests/participant/test_resources.py b/tests/participant/test_resources.py
index d1e742ffe..ded5b4ef6 100644
--- a/tests/participant/test_resources.py
+++ b/tests/participant/test_resources.py
@@ -1,7 +1,10 @@
 import json
+
 from flask import url_for
 
+from dataservice.extensions import db
 from dataservice.api.participant.models import Participant
+from dataservice.api.study.models import Study
 from tests.utils import FlaskTestCase
 
 PARTICIPANT_URL = 'api.participants'
@@ -17,9 +20,9 @@ def test_post_participant(self):
         Test creating a new participant
         """
         response = self._make_participant(external_id="TEST")
-        self.assertEqual(response.status_code, 201)
-
         resp = json.loads(response.data.decode("utf-8"))
+
+        self.assertEqual(response.status_code, 201)
         self._test_response_content(resp, 201)
 
         self.assertIn('participant', resp['_status']['message'])
@@ -87,8 +90,14 @@ def test_put_participant(self):
         kf_id = participant.get('kf_id')
         external_id = participant.get('external_id')
 
+        # Create new study, add participant to it
+        s = Study(external_id='phs002')
+        db.session.add(s)
+        db.session.commit()
+
         body = {
-            'external_id': 'Updated-{}'.format(external_id)
+            'external_id': 'Updated-{}'.format(external_id),
+            'study_id': s.kf_id
         }
         response = self.client.put(url_for(PARTICIPANT_URL,
                                            kf_id=kf_id),
@@ -132,8 +141,14 @@ def _make_participant(self, external_id="TEST-0001"):
         """
         Convenience method to create a participant with a given source name
         """
+        # Make required entities first
+        s = Study(external_id='phs001')
+        db.session.add(s)
+        db.session.commit()
+
         body = {
-            'external_id': external_id
+            'external_id': external_id,
+            'study_id': s.kf_id
         }
         response = self.client.post(url_for(PARTICIPANT_URL),
                                     headers=self._api_headers(),
diff --git a/tests/sample/test_sample_models.py b/tests/sample/test_sample_models.py
index 568a31d67..3783d268e 100644
--- a/tests/sample/test_sample_models.py
+++ b/tests/sample/test_sample_models.py
@@ -2,6 +2,7 @@
 import uuid
 
 from dataservice.extensions import db
+from dataservice.api.study.models import Study
 from dataservice.api.participant.models import Participant
 from dataservice.api.sample.models import Sample
 from tests.utils import FlaskTestCase
@@ -33,7 +34,11 @@ def create_participant_sample(self):
         participant_0 = Participant(
             external_id=participant_id,
             samples=[sample_0])
-        db.session.add(participant_0)
+
+        study = Study(external_id='phs001')
+        study.participants.append(participant_0)
+
+        db.session.add(study)
         db.session.commit()
         return participant_id, sample_id
 
@@ -41,10 +46,14 @@ def test_create_sample(self):
         """
         Test creation of sample
         """
+        study = Study(external_id='phs001')
+        db.session.add(study)
+        db.session.commit()
+
         dt = datetime.now()
         participant_id = "Test_Subject_0"
         # creating participant
-        p = Participant(external_id=participant_id)
+        p = Participant(external_id=participant_id, study_id=study.kf_id)
         db.session.add(p)
         db.session.commit()
 
diff --git a/tests/sample/test_sample_resources.py b/tests/sample/test_sample_resources.py
index a2fc424fb..5d2facea0 100644
--- a/tests/sample/test_sample_resources.py
+++ b/tests/sample/test_sample_resources.py
@@ -1,11 +1,13 @@
 import json
-from flask import url_for
 from urllib.parse import urlparse
 
+from flask import url_for
+
 from dataservice.extensions import db
 from dataservice.api.common import id_service
 from dataservice.api.sample.models import Sample
 from dataservice.api.participant.models import Participant
+from dataservice.api.study.models import Study
 from tests.utils import FlaskTestCase
 
 SAMPLES_URL = 'api.samples'
@@ -20,8 +22,13 @@ def test_post(self):
         """
         Test create a new sample
         """
+        study = Study(external_id='phs001')
+        db.session.add(study)
+        db.session.commit()
+
         # Create a participant
-        p = Participant(external_id='Test subject 0')
+        p = Participant(external_id='Test subject 0',
+                        study_id=study.kf_id)
         db.session.add(p)
         db.session.commit()
 
@@ -356,6 +363,10 @@ def _create_save_to_db(self):
         Create a sample and add it to participant as kwarg
         Save participant
         """
+        study = Study(external_id='phs001')
+        db.session.add(study)
+        db.session.commit()
+
         # Create sample
         kwargs = {
             'external_id': 's1',
@@ -368,8 +379,8 @@ def _create_save_to_db(self):
         d = Sample(**kwargs)
 
         # Create and save participant with sample
-        participant_id = 'Test subject 0'
-        p = Participant(external_id=participant_id, samples=[d])
+        p = Participant(external_id='Test subject 0', samples=[d],
+                        study_id=study.kf_id)
         db.session.add(p)
         db.session.commit()
 
diff --git a/tests/sequencing_experiment/test_sequencingexperiment_models.py b/tests/sequencing_experiment/test_sequencingexperiment_models.py
index 99dc6e63e..38df6e9e3 100644
--- a/tests/sequencing_experiment/test_sequencingexperiment_models.py
+++ b/tests/sequencing_experiment/test_sequencingexperiment_models.py
@@ -2,6 +2,7 @@
 import uuid
 
 from dataservice.extensions import db
+from dataservice.api.study.models import Study
 from dataservice.api.participant.models import Participant
 from dataservice.api.sample.models import Sample
 from dataservice.api.aliquot.models import Aliquot
@@ -23,6 +24,9 @@ def create_participant_sample_aliquot_seqexp(self):
         returns participant_id, sample_id, aliquot_id and
         sequencing_experiment_id
         """
+        # Create study
+        study = Study(external_id='phs001')
+
         dt = datetime.now()
         participant_id = "Test_Subject_0"
         sample_id = "Test_Sample_0"
@@ -69,7 +73,8 @@ def create_participant_sample_aliquot_seqexp(self):
         sample_0 = Sample(**sample_data, aliquots=[aliquot_0])
         participant_0 = Participant(
             external_id=participant_id,
-            samples=[sample_0])
+            samples=[sample_0],
+            study=study)
         db.session.add(participant_0)
         db.session.commit()
         ids = {'participant_id': participant_id,
@@ -100,10 +105,13 @@ def test_create_sequencing_experiment(self):
         """
         Test creation of sequencing_exeriment
         """
+        # Create study
+        study = Study(external_id='phs001')
+
         dt = datetime.now()
         participant_id = "Test_Subject_0"
         # creating participant
-        p = Participant(external_id=participant_id)
+        p = Participant(external_id=participant_id, study=study)
         db.session.add(p)
         db.session.commit()
 
diff --git a/tests/test_api.py b/tests/test_api.py
index 4a6a463ca..d87276f26 100644
--- a/tests/test_api.py
+++ b/tests/test_api.py
@@ -2,8 +2,6 @@
 import pkg_resources
 import pytest
 
-import dataservice
-
 
 class TestAPI:
     """
@@ -78,12 +76,13 @@ def test_status_format(self, client, endpoint, method):
         ('/participants', 'created_at'),
         ('/participants', 'modified_at')
     ])
-    def test_read_only(self, client, endpoint, field):
+    def test_read_only(self, client, entities, endpoint, field):
         """ Test that given fields can not be written or modified """
-        req = {field: 'test'}
+        inputs = entities[endpoint]
+        inputs.update({field: 'test'})
         resp = client.post(endpoint,
-                data=json.dumps(req),
-                headers={'Content-Type': 'application/json'})
+                           data=json.dumps(inputs),
+                           headers={'Content-Type': 'application/json'})
         body = json.loads(resp.data.decode('utf-8'))
         assert (field not in body['results']
                 or body['results'][field] != 'test')
@@ -92,18 +91,18 @@ def test_read_only(self, client, endpoint, field):
         ('/participants', 'blah'),
         ('/samples', 'blah')
     ])
-    def test_unknown_field(self, client, endpoint, field):
+    def test_unknown_field(self, client, entities, endpoint, field):
         """ Test that unknown fields are rejected when trying to create  """
-        req = {field: 'test'}
+        inputs = entities[endpoint]
+        inputs.update({field: 'test'})
         resp = client.post(endpoint,
-                data=json.dumps(req),
-                headers={'Content-Type': 'application/json'})
+                           data=json.dumps(inputs),
+                           headers={'Content-Type': 'application/json'})
         body = json.loads(resp.data.decode('utf-8'))
         assert body['_status']['code'] == 400
         assert 'could not create ' in body['_status']['message']
         assert 'Unknown field' in body['_status']['message']
 
-    
     @pytest.mark.parametrize('resource,field', [
         ('/participants', 'demographic'),
         ('/participants', 'diagnoses')
diff --git a/tests/test_errors.py b/tests/test_errors.py
index 94768c8dc..3fa993ba7 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -33,19 +33,20 @@ def test_fk_not_exists(self, client, endpoint, kf_id):
             message = 'Longer than maximum length 8'
             assert message in response['_status']['message']
 
-
-    def test_unique_demographic(self, client):
+    def test_unique_demographic(self, client, entities):
         """ Test integrity errors trying to break one-one with many-many """
-        kwargs = { 'external_id': 'test' }
+        inputs = entities['/participants']
+        inputs.update({'external_id': 'test'})
+
         # Create participant
         response = client.post('/participants',
-                               data=json.dumps(kwargs),
+                               data=json.dumps(inputs),
                                headers={'Content-Type': 'application/json'})
 
         response = json.loads(response.data.decode("utf-8"))
         kf_id = response['results']['kf_id']
 
-        kwargs = { 'participant_id': kf_id }
+        kwargs = {'participant_id': kf_id}
         # Send post request
         response = client.post('/demographics',
                                data=json.dumps(kwargs),