meta-edc 1.1.8__py3-none-any.whl → 1.1.12__py3-none-any.whl

meta_subject/tests/tests/test_physical_exam.py

@@ -1,84 +0,0 @@
-from copy import deepcopy
-
-from django.conf import settings
-from django.contrib.sites.models import Site
-from django.test import TestCase
-from edc_constants.constants import COMPLETE, NO, YES
-
-from meta_screening.tests.meta_test_case_mixin import MetaTestCaseMixin
-from meta_screening.tests.options import now
-from meta_subject.forms import PhysicalExamForm
-
-
-class TestPhysicalExam(MetaTestCaseMixin, TestCase):
-    def setUp(self):
-        super().setUp()
-        self.data = {
-            "abdominal_tenderness": NO,
-            "dia_blood_pressure": 100,
-            "abdominal_tenderness_description": None,
-            "enlarged_liver": YES,
-            "heart_rate": 40,
-            "irregular_heartbeat": NO,
-            "irregular_heartbeat_description": None,
-            "jaundice": YES,
-            "oxygen_saturation": 10,
-            "peripheral_oedema": NO,
-            "report_datetime": now,
-            "respiratory_rate": 30,
-            "sys_blood_pressure": 80,
-            "temperature": 37,
-            "waist_circumference": 100,
-            "weight": 65,
-            "crf_status": COMPLETE,
-            "site": Site.objects.get(id=settings.SITE_ID),
-        }
-
-        self.subject_visit = self.get_subject_visit(appt_datetime=now)
-
-        self.data.update(
-            subject_visit=self.subject_visit.pk,
-            report_datetime=self.subject_visit.report_datetime,
-        )
-
-    def test_ok(self):
-        form = PhysicalExamForm(data=self.data)
-        form.is_valid()
-        self.assertEqual(form._errors, {})
-
-    def test_irregular_heartbeat(self):
-        data = deepcopy(self.data)
-        data.update(irregular_heartbeat=YES, irregular_heartbeat_description="blah blah blah")
-        form = PhysicalExamForm(data=data)
-        form.is_valid()
-        self.assertEqual(form._errors, {})
-
-        data.update(irregular_heartbeat=NO, irregular_heartbeat_description="blah blah blah")
-        form = PhysicalExamForm(data=data)
-        form.is_valid()
-        self.assertEqual(
-            form._errors.get("irregular_heartbeat_description"),
-            ["This field is not required."],
-        )
-
-    def test_abdominal_tenderness(self):
-        data = deepcopy(self.data)
-        data.update(abdominal_tenderness=NO, abdominal_tenderness_description=None)
-        form = PhysicalExamForm(data=data)
-        form.is_valid()
-        self.assertEqual(form._errors, {})
-
-        data.update(
-            abdominal_tenderness=YES, abdominal_tenderness_description="blah blah blah"
-        )
-        form = PhysicalExamForm(data=data)
-        form.is_valid()
-        self.assertEqual(form._errors, {})
-
-        data.update(abdominal_tenderness=NO, abdominal_tenderness_description="blah blah blah")
-        form = PhysicalExamForm(data=data)
-        form.is_valid()
-        self.assertEqual(
-            form._errors.get("abdominal_tenderness_description"),
-            ["This field is not required."],
-        )

meta_subject/tests/tests/test_sf12.py

@@ -1,161 +0,0 @@
-from copy import deepcopy
-from datetime import datetime
-from zoneinfo import ZoneInfo
-
-import time_machine
-from django.conf import settings
-from django.contrib.sites.models import Site
-from django.test import TestCase
-from edc_constants.constants import COMPLETE, YES
-from edc_metadata import KEYED, NOT_REQUIRED, REQUIRED
-from edc_metadata.metadata import CrfMetadataGetter
-from edc_qol.constants import ALL_OF_THE_TIME, NONE_OF_THE_TIME, SOME_OF_THE_TIME
-from edc_visit_schedule.constants import MONTH1, MONTH3, WEEK2
-
-from meta_screening.tests.meta_test_case_mixin import MetaTestCaseMixin
-from meta_screening.tests.options import now
-from meta_subject.forms import Sf12Form
-
-
-@time_machine.travel(datetime(2019, 6, 11, 8, 00, tzinfo=ZoneInfo("UTC")))
-class TestSf12(MetaTestCaseMixin, TestCase):
-    def setUp(self):
-        super().setUp()
-        self.subject_visit = self.get_subject_visit(appt_datetime=now)
-        self.data = dict(
-            subject_visit=self.subject_visit,
-            report_datetime=self.subject_visit.report_datetime,
-            general_health="excellent",
-            moderate_activities_now_limited="limited_a_lot",
-            climbing_stairs_now_limited="limited_a_lot",
-            accomplished_less_physical_health=YES,
-            work_limited_physical_health=YES,
-            accomplished_less_emotional=YES,
-            work_less_carefully_emotional=YES,
-            pain_interfere_work="not_at_all",
-            felt_calm_peaceful=ALL_OF_THE_TIME,
-            felt_lot_energy=ALL_OF_THE_TIME,
-            felt_down=NONE_OF_THE_TIME,
-            social_activities_interfered=SOME_OF_THE_TIME,
-            crf_status=COMPLETE,
-            site=Site.objects.get(id=settings.SITE_ID),
-        )
-
-    def test_1005_required(self):
-        subject_visit = self.get_next_subject_visit(self.subject_visit)
-        self.assertEqual(subject_visit.visit_code, WEEK2)
-        crf_metadata_getter = CrfMetadataGetter(appointment=subject_visit.appointment)
-        self.assertTrue(
-            crf_metadata_getter.metadata_objects.filter(model="meta_subject.sf12").exists()
-        )
-        self.assertEqual(
-            crf_metadata_getter.metadata_objects.get(
-                model="meta_subject.sf12", visit_code=WEEK2
-            ).entry_status,
-            REQUIRED,
-        )
-        data = deepcopy(self.data)
-        data.update(subject_visit=subject_visit, report_datetime=subject_visit.report_datetime)
-        form = Sf12Form(data=data)
-        form.is_valid()
-        self.assertEqual({}, form._errors)
-        form.save()
-        self.assertTrue(
-            crf_metadata_getter.metadata_objects.filter(
-                model="meta_subject.sf12", entry_status=KEYED
-            ).exists()
-        )
-
-    def test_1010_required_if_not_submitted(self):
-        subject_visit = self.get_next_subject_visit(self.subject_visit)
-        subject_visit = self.get_next_subject_visit(subject_visit)
-        self.assertEqual(subject_visit.visit_code, MONTH1)
-        crf_metadata_getter = CrfMetadataGetter(appointment=subject_visit.appointment)
-        self.assertTrue(
-            crf_metadata_getter.metadata_objects.filter(model="meta_subject.sf12").exists()
-        )
-        self.assertEqual(
-            crf_metadata_getter.metadata_objects.get(
-                model="meta_subject.sf12", visit_code=MONTH1
-            ).entry_status,
-            REQUIRED,
-        )
-        data = deepcopy(self.data)
-        data.update(subject_visit=subject_visit, report_datetime=subject_visit.report_datetime)
-        form = Sf12Form(data=data)
-        form.is_valid()
-        self.assertEqual({}, form._errors)
-        form.save()
-        self.assertTrue(
-            crf_metadata_getter.metadata_objects.filter(
-                model="meta_subject.sf12", entry_status=KEYED
-            ).exists()
-        )
-
-    def test_1030_required_if_not_submitted(self):
-        subject_visit = self.get_next_subject_visit(self.subject_visit)
-        subject_visit = self.get_next_subject_visit(subject_visit)
-        subject_visit = self.get_next_subject_visit(subject_visit)
-        traveller = time_machine.travel(subject_visit.report_datetime)
-        traveller.start()
-        self.assertEqual(subject_visit.visit_code, MONTH3)
-        crf_metadata_getter = CrfMetadataGetter(appointment=subject_visit.appointment)
-        self.assertTrue(
-            crf_metadata_getter.metadata_objects.filter(model="meta_subject.sf12").exists()
-        )
-        self.assertEqual(
-            crf_metadata_getter.metadata_objects.get(
-                model="meta_subject.sf12", visit_code=MONTH3
-            ).entry_status,
-            REQUIRED,
-        )
-        data = deepcopy(self.data)
-        data.update(subject_visit=subject_visit, report_datetime=subject_visit.report_datetime)
-        form = Sf12Form(data=data)
-        form.is_valid()
-        self.assertEqual({}, form._errors)
-        form.save()
-        self.assertTrue(
-            crf_metadata_getter.metadata_objects.filter(
-                model="meta_subject.sf12", entry_status=KEYED
-            ).exists()
-        )
-
-    def test_1030_not_required_if_submitted(self):
-        subject_visit_1005 = self.get_next_subject_visit(self.subject_visit)
-        subject_visit_1010 = self.get_next_subject_visit(subject_visit_1005)
-        subject_visit_1030 = self.get_next_subject_visit(subject_visit_1010)
-        self.assertEqual(subject_visit_1030.visit_code, MONTH3)
-        crf_metadata_getter = CrfMetadataGetter(appointment=subject_visit_1030.appointment)
-        self.assertTrue(
-            crf_metadata_getter.metadata_objects.filter(
-                model="meta_subject.sf12", entry_status=REQUIRED
-            ).exists()
-        )
-        data = deepcopy(self.data)
-        data.update(
-            subject_visit=subject_visit_1010,
-            report_datetime=subject_visit_1010.report_datetime,
-        )
-        form = Sf12Form(data=data)
-        form.is_valid()
-        self.assertEqual({}, form._errors)
-        form.save()
-        crf_metadata_getter = CrfMetadataGetter(appointment=subject_visit_1005.appointment)
-        self.assertTrue(
-            crf_metadata_getter.metadata_objects.filter(
-                model="meta_subject.sf12", entry_status=NOT_REQUIRED
-            ).exists()
-        )
-        crf_metadata_getter = CrfMetadataGetter(appointment=subject_visit_1010.appointment)
-        self.assertTrue(
-            crf_metadata_getter.metadata_objects.filter(
-                model="meta_subject.sf12", entry_status=KEYED
-            ).exists()
-        )
-        crf_metadata_getter = CrfMetadataGetter(appointment=subject_visit_1030.appointment)
-        self.assertTrue(
-            crf_metadata_getter.metadata_objects.filter(
-                model="meta_subject.sf12", entry_status=NOT_REQUIRED
-            ).exists()
-        )

meta_subject/tests/tests/test_study_medication.py

@@ -1,229 +0,0 @@
-from dateutil.relativedelta import relativedelta
-from django.core.exceptions import ObjectDoesNotExist
-from django.test import TestCase
-from edc_constants.constants import YES
-from edc_pharmacy.exceptions import PrescriptionAlreadyExists, StudyMedicationError
-from edc_pharmacy.models import DosageGuideline, Formulation, Medication, RxRefill
-from edc_pharmacy.prescribe import create_prescription
-from edc_registration.models import RegisteredSubject
-
-from meta_pharmacy.constants import METFORMIN
-from meta_screening.tests.meta_test_case_mixin import MetaTestCaseMixin
-from meta_subject.models import StudyMedication
-
-
-class TestStudyMedication(MetaTestCaseMixin, TestCase):
-    def setUp(self):
-        super().setUp()
-        self.subject_visit = self.get_subject_visit()
-        self.registered_subject = RegisteredSubject.objects.get(
-            subject_identifier=self.subject_visit.subject_identifier
-        )
-
-    def test_rx_exists(self):
-        self.assertRaises(
-            PrescriptionAlreadyExists,
-            create_prescription,
-            subject_identifier=self.registered_subject.subject_identifier,
-            report_datetime=self.registered_subject.registration_datetime,
-            medication_names=[METFORMIN],
-            site=self.registered_subject.site,
-        )
-
-    def test_missing_formulation(self):
-        obj = StudyMedication(subject_visit=self.subject_visit)
-        with self.assertRaises(StudyMedicationError) as cm:
-            obj.save()
-        self.assertIn("Formulation", str(cm.exception))
-
-    def test_missing_dosage_guideline(self):
-        medication = Medication.objects.get(name=METFORMIN)
-        formulation = Formulation.objects.filter(medication=medication)[0]
-        obj = StudyMedication(
-            subject_visit=self.subject_visit,
-            refill_start_datetime=self.subject_visit.report_datetime,
-            refill_to_next_visit=YES,
-            formulation=formulation,
-        )
-        with self.assertRaises(StudyMedicationError) as cm:
-            obj.save()
-        self.assertIn("Dosage guideline", str(cm.exception))
-
-    def test_study_med_longitudinal_and_one_rx_refill_created(self):
-        medication = Medication.objects.get(name=METFORMIN)
-        formulation = Formulation.objects.filter(medication=medication)[0]
-        dosage_guideline = DosageGuideline.objects.filter(medication=medication)[0]
-        obj = StudyMedication(
-            subject_visit=self.subject_visit,
-            refill_start_datetime=self.subject_visit.report_datetime,
-            formulation=formulation,
-            dosage_guideline=dosage_guideline,
-            refill_to_next_visit=YES,
-        )
-        obj.save()
-        try:
-            RxRefill.objects.get(
-                rx=obj.rx,
-                rx__subject_identifier=self.subject_visit.subject_identifier,
-                refill_start_datetime=obj.refill_start_datetime,
-            )
-        except ObjectDoesNotExist:
-            self.fail("ObjectDoesNotExist unexpectedly raised")
-
-        self.assertEqual(RxRefill.objects.filter(rx=obj.rx).count(), 1)
-
-    def test_study_med_longitudinal_updated_and_same_rx_refill_updated(self):
-        """Assert study med update operates on same rx_refill when updated"""
-        medication = Medication.objects.get(name=METFORMIN)
-        formulation = Formulation.objects.filter(medication=medication)[0]
-        dosage_guideline = DosageGuideline.objects.filter(medication=medication)[0]
-        obj = StudyMedication(
-            subject_visit=self.subject_visit,
-            refill_start_datetime=self.subject_visit.report_datetime,
-            formulation=formulation,
-            dosage_guideline=dosage_guideline,
-            refill_to_next_visit=YES,
-        )
-        obj.save()
-        obj.save()
-        self.assertEqual(RxRefill.objects.filter(rx=obj.rx).count(), 1)
-        changed_dosage_guideline = DosageGuideline.objects.filter(medication=medication)[1]
-        obj.dosage_guideline = changed_dosage_guideline
-        obj.save()
-        self.assertEqual(RxRefill.objects.filter(rx=obj.rx).count(), 1)
-        rx = RxRefill.objects.get(rx=obj.rx)
-        self.assertEqual(rx.dosage_guideline, obj.dosage_guideline)
-
-    def test_study_med_longitudinal_update_start_datetime_and_same_rx_refill_updated(self):
-        """Assert study med update operates on same rx_refill when updated"""
-        medication = Medication.objects.get(name=METFORMIN)
-        formulation = Formulation.objects.filter(medication=medication)[0]
-        dosage_guideline = DosageGuideline.objects.filter(medication=medication)[0]
-        obj = StudyMedication(
-            subject_visit=self.subject_visit,
-            refill_start_datetime=self.subject_visit.report_datetime,
-            formulation=formulation,
-            dosage_guideline=dosage_guideline,
-            refill_to_next_visit=YES,
-        )
-        obj.save()
-        obj.save()
-        self.assertEqual(RxRefill.objects.filter(rx=obj.rx).count(), 1)
-        obj.refill_start_datetime = obj.refill_start_datetime + relativedelta(hours=1)
-        obj.save()
-        self.assertEqual(RxRefill.objects.filter(rx=obj.rx).count(), 1)
-        rx = RxRefill.objects.get(rx=obj.rx)
-        self.assertEqual(rx.refill_start_datetime, obj.refill_start_datetime)
-
-    def test_study_med_longitudinal_and_one_rx_refill_created2(self):
-        medication = Medication.objects.get(name=METFORMIN)
-        formulation = Formulation.objects.filter(medication=medication)[0]
-        dosage_guideline = DosageGuideline.objects.filter(medication=medication)[0]
-        obj = StudyMedication(
-            subject_visit=self.subject_visit,
-            refill_start_datetime=self.subject_visit.report_datetime,
-            formulation=formulation,
-            dosage_guideline=dosage_guideline,
-            refill_to_next_visit=YES,
-        )
-        obj.save()
-        try:
-            RxRefill.objects.get(
-                rx=obj.rx,
-                rx__subject_identifier=self.subject_visit.subject_identifier,
-                refill_start_datetime=obj.refill_start_datetime,
-            )
-        except ObjectDoesNotExist:
-            self.fail("ObjectDoesNotExist unexpectedly raised")
-
-        self.assertEqual(RxRefill.objects.filter(rx=obj.rx).count(), 1)
-
-        try:
-            RxRefill.objects.get(refill_identifier=obj.refill_identifier)
-        except ObjectDoesNotExist:
-            self.fail("ObjectDoesNotExist unexpectedly raised")
-
-    def test_study_med_longitudinal_and_two_rx_refill_created(self):
-        date_sequence = []
-        medication = Medication.objects.get(name=METFORMIN)
-        formulation = Formulation.objects.filter(medication=medication)[0]
-        dosage_guideline = DosageGuideline.objects.filter(medication=medication)[0]
-        subject_visits = [self.subject_visit, self.get_next_subject_visit(self.subject_visit)]
-        for i in [1, 2]:
-            subject_visit = subject_visits[i - 1]
-            obj = StudyMedication(
-                subject_visit=subject_visit,
-                refill_start_datetime=subject_visit.report_datetime,
-                formulation=formulation,
-                dosage_guideline=dosage_guideline,
-                refill_to_next_visit=YES,
-            )
-            obj.save()
-            date_sequence.append(obj.refill_start_datetime)
-            try:
-                RxRefill.objects.get(
-                    rx=obj.rx,
-                    rx__subject_identifier=subject_visit.subject_identifier,
-                    refill_start_datetime=obj.refill_start_datetime,
-                )
-            except ObjectDoesNotExist:
-                self.fail("ObjectDoesNotExist unexpectedly raised")
-
-            self.assertEqual(RxRefill.objects.filter(rx=obj.rx).count(), i)
-
-            try:
-                rx_refill = RxRefill.objects.get(refill_identifier=obj.refill_identifier)
-            except ObjectDoesNotExist:
-                self.fail("ObjectDoesNotExist unexpectedly raised")
-            date_sequence.append(rx_refill.refill_end_datetime)
-        dte1, dte2, dte3, dte4 = date_sequence
-        self.assertTrue(dte1 <= dte2 <= dte3 <= dte4)
-
-    def test_study_med_longitudinal(self):
-        StudyMedication(
-            subject_visit=self.subject_visit,
-            refill_start_datetime=self.subject_visit.report_datetime,
-            refill_to_next_visit=YES,
-        )
-        subject_visit = self.get_next_subject_visit(self.subject_visit)
-        StudyMedication(
-            subject_visit=subject_visit,
-            refill_start_datetime=subject_visit.report_datetime,
-            refill_to_next_visit=YES,
-        )
-        subject_visit = self.get_next_subject_visit(subject_visit)
-        StudyMedication(
-            subject_visit=subject_visit,
-            refill_start_datetime=subject_visit.report_datetime,
-            refill_to_next_visit=YES,
-        )
-        subject_visit = self.get_next_subject_visit(subject_visit)
-        StudyMedication(
-            subject_visit=subject_visit,
-            refill_start_datetime=subject_visit.report_datetime,
-            refill_to_next_visit=YES,
-        )
-        subject_visit = self.get_next_subject_visit(subject_visit)
-        StudyMedication(
-            subject_visit=subject_visit,
-            refill_start_datetime=subject_visit.report_datetime,
-            refill_to_next_visit=YES,
-        )
-        subject_visit = self.get_next_subject_visit(subject_visit)
-        StudyMedication(
-            subject_visit=subject_visit,
-            refill_start_datetime=subject_visit.report_datetime,
-            refill_to_next_visit=YES,
-        )
-        subject_visit = self.get_next_subject_visit(subject_visit)
-        StudyMedication(
-            subject_visit=subject_visit,
-            refill_start_datetime=subject_visit.report_datetime,
-            refill_to_next_visit=YES,
-        )
-        subject_visit = self.get_next_subject_visit(subject_visit)
-        StudyMedication(
-            subject_visit=subject_visit,
-            refill_start_datetime=subject_visit.report_datetime,
-            refill_to_next_visit=YES,
-        )

meta_subject/tests/urls.py

@@ -1,24 +0,0 @@
-from django.contrib.auth import admin
-from django.urls.conf import include, path
-from django.views.generic.base import RedirectView
-
-from meta_ae.admin_site import meta_ae_admin
-
-urlpatterns = [
-    path("admin/", meta_ae_admin.urls),
-    path("admin/", admin.site.urls),
-    path("accounts/", include("edc_auth.urls")),
-    path("edc_adverse_event/", include("edc_adverse_event.urls")),
-    path("edc_auth/", include("edc_auth.urls")),
-    path("edc_consent/", include("edc_consent.urls")),
-    path("edc_dashboard/", include("edc_dashboard.urls")),
-    path("edc_device/", include("edc_device.urls")),
-    path("edc_export/", include("edc_export.urls")),
-    path("edc_protocol/", include("edc_protocol.urls")),
-    path("edc_randomization/", include("edc_randomization.urls")),
-    path("edc_visit_schedule/", include("edc_visit_schedule.urls")),
-    path("ae/", include("meta_ae.urls")),
-    path("meta_consent/", include("meta_consent.urls")),
-    path("administration", RedirectView.as_view(url="admin/"), name="administration_url"),
-    path("", RedirectView.as_view(url="admin/"), name="home_url"),
-]

meta_visit_schedule/tests/tests/test_schedule.py

@@ -1,181 +0,0 @@
-from django.test import TestCase
-
-from meta_consent.consents import consent_v1
-from meta_edc.meta_version import PHASE_THREE, PHASE_TWO, get_meta_version
-from meta_visit_schedule.visit_schedules import schedule
-from meta_visit_schedule.visit_schedules.phase_three import visit_schedule
-
-
-class TestVisitSchedule(TestCase):
-    def test_visit_schedule_models(self):
-        self.assertEqual(visit_schedule.death_report_model, "meta_ae.deathreport")
-        self.assertEqual(visit_schedule.offstudy_model, "meta_prn.endofstudy")
-        self.assertEqual(visit_schedule.locator_model, "edc_locator.subjectlocator")
-
-    def test_schedule_models(self):
-        self.assertEqual(schedule.onschedule_model, "meta_prn.onschedule")
-        self.assertEqual(schedule.offschedule_model, "meta_prn.offschedule")
-        self.assertEqual(schedule.consent_definitions, [consent_v1])
-        self.assertEqual(schedule.appointment_model, "edc_appointment.appointment")
-
-    def test_visit_codes_phase_two(self):
-        if get_meta_version() == PHASE_TWO:
-            self.assertEqual(
-                [
-                    "1000",
-                    "1005",
-                    "1010",
-                    "1030",
-                    "1060",
-                    "1090",
-                    "1120",
-                ],
-                [visit for visit in schedule.visits],
-            )
-
-    def test_visit_codes_phase_three(self):
-        if get_meta_version() == PHASE_THREE:
-            self.assertEqual(
-                [
-                    "1000",
-                    "1005",
-                    "1010",
-                    "1030",
-                    "1060",
-                    "1090",
-                    "1120",
-                    "1150",
-                    "1180",
-                    "1210",
-                    "1240",
-                    "1270",
-                    "1300",
-                    "1330",
-                    "1360",
-                    "1390",
-                    "1420",
-                    "1450",
-                    "1480",
-                ],
-                [visit for visit in schedule.visits],
-            )
-
-    def test_requisitions(self):
-        if get_meta_version() == PHASE_TWO:
-            prn = [
-                "blood_glucose_poc",
-                "chemistry",
-                "fbc",
-                "hba1c_poc",
-            ]
-            expected = {
-                "1000": ["chemistry", "fbc", "hba1c_poc"],
-                "1005": [],
-                "1010": [],
-                "1030": ["chemistry"],
-                "1060": ["chemistry", "hba1c_poc"],
-                "1090": ["chemistry"],
-                "1120": ["blood_glucose_poc", "chemistry", "fbc", "hba1c_poc"],
-            }
-            for visit_code, visit in schedule.visits.items():
-                with self.subTest(visit_code=visit_code, visit=visit):
-                    actual = [requisition.name for requisition in visit.requisitions]
-                    actual.sort()
-                    self.assertEqual(
-                        expected.get(visit_code),
-                        actual,
-                        msg=f"see requisitions for visit {visit_code}",
-                    )
-                    actual = [requisition.name for requisition in visit.requisitions_prn]
-                    actual.sort()
-                    self.assertEqual(
-                        prn, actual, msg=f"see PRN requisitions for visit {visit_code}"
-                    )
-
-    def test_crfs_phase_two(self):
-        if get_meta_version() == PHASE_TWO:
-            prn = [
-                "meta_subject.bloodresultsfbc",
-                "meta_subject.bloodresultsglu",
-                "meta_subject.bloodresultshba1c",
-                "meta_subject.bloodresultslft",
-                "meta_subject.bloodresultslipid",
-                "meta_subject.bloodresultsrft",
-                "meta_subject.glucose",
-                "meta_subject.healtheconomics",
-                "meta_subject.malariatest",
-                "meta_subject.urinedipsticktest",
-            ]
-            expected = {
-                "1000": [
-                    "meta_subject.physicalexam",
-                    "meta_subject.patienthistory",
-                    "meta_subject.bloodresultsfbc",
-                    "meta_subject.bloodresultshba1c",
-                    "meta_subject.bloodresultslft",
-                    "meta_subject.bloodresultslipid",
-                    "meta_subject.bloodresultsrft",
-                    "meta_subject.malariatest",
-                    "meta_subject.urinedipsticktest",
-                ],
-                "1005": [
-                    "meta_subject.followupvitals",
-                    "meta_subject.followupexamination",
-                    "meta_subject.healtheconomics",
-                    "meta_subject.medicationadherence",
-                ],
-                "1010": [
-                    "meta_subject.followupvitals",
-                    "meta_subject.followupexamination",
-                    "meta_subject.medicationadherence",
-                ],
-                "1030": [
-                    "meta_subject.bloodresultslft",
-                    "meta_subject.bloodresultsrft",
-                    "meta_subject.followupvitals",
-                    "meta_subject.followupexamination",
-                    "meta_subject.medicationadherence",
-                ],
-                "1060": [
-                    "meta_subject.followupvitals",
-                    "meta_subject.followupexamination",
-                    "meta_subject.medicationadherence",
-                    "meta_subject.glucose",
-                    "meta_subject.bloodresultshba1c",
-                    "meta_subject.bloodresultslft",
-                    "meta_subject.bloodresultsrft",
-                ],
-                "1090": [
-                    "meta_subject.bloodresultslft",
-                    "meta_subject.bloodresultsrft",
-                    "meta_subject.followupvitals",
-                    "meta_subject.followupexamination",
-                    "meta_subject.medicationadherence",
-                ],
-                "1120": [
-                    "meta_subject.followupvitals",
-                    "meta_subject.followupexamination",
-                    "meta_subject.medicationadherence",
-                    "meta_subject.glucose",
-                    "meta_subject.bloodresultshba1c",
-                    "meta_subject.bloodresultsfbc",
-                    "meta_subject.bloodresultslipid",
-                    "meta_subject.bloodresultslft",
-                    "meta_subject.bloodresultsrft",
-                    "meta_subject.malariatest",
-                ],
-            }
-            for visit_code, visit in schedule.visits.items():
-                with self.subTest(visit_code=visit_code, visit=visit):
-                    actual = [crf.model for crf in visit.crfs]
-                    actual.sort()
-                    expected.get(visit_code).sort()
-                    self.assertEqual(
-                        expected.get(visit_code),
-                        actual,
-                        msg=f"see CRFs for visit {visit_code}",
-                    )
-
-                    actual = [crf.model for crf in visit.crfs_prn]
-                    actual.sort()
-                    self.assertEqual(prn, actual, msg=f"see PRN CRFs for visit {visit_code}")