def single_process_settings(self, env, settings):
from multisite import SiteID
settings['SITE_ID'] = SiteID(default=int(env('SITE_ID', 1)))
settings['INSTALLED_APPS'].append('multisite')
MIDDLEWARE_CLASSES = settings['MIDDLEWARE_CLASSES']
# multisite.middleware.DynamicSiteMiddleware must be before
# cms.middleware.utils.ApphookReloadMiddleware
MIDDLEWARE_CLASSES.insert(
MIDDLEWARE_CLASSES.index(
'cms.middleware.utils.ApphookReloadMiddleware'),
'django_multisite_plus.middlewares.DynamicSiteMiddleware',
)
# djangocms_multisite.middleware.CMSMultiSiteMiddleware must be after
# cms.middleware.utils.ApphookReloadMiddleware
MIDDLEWARE_CLASSES.insert(
MIDDLEWARE_CLASSES.index(
'cms.middleware.utils.ApphookReloadMiddleware') + 1,
'django_multisite_plus.middlewares.CMSMultiSiteMiddleware',
)
# djangocms-multisite has it's own version of cms urls that cache
# correctly. This will no longer be necessary for cms versions that
# include https://github.com/divio/django-cms/pull/5832
settings['ADDON_URLS_I18N_LAST'] = 'django_multisite_plus.cms_urls'
class TestSystemChecks(SiteTestCaseMixin, TestCase):
def setUp(self):
add_or_update_django_sites(sites=self.default_sites)
@override_settings(
SITE_ID=SiteID(default=10),
)
def test_(self):
# app_configs = django_apps.get_app_configs()
holiday_path_check(app_configs=None)
@override_settings(
HOLIDAY_FILE=None,
SITE_ID=SiteID(default=10),
)
def test_file(self):
app_configs = django_apps.get_app_configs()
errors = holiday_path_check(app_configs=app_configs)
self.assertIn("edc_facility.001", [error.id for error in errors])
@override_settings(
HOLIDAY_FILE=os.path.join(settings.BASE_DIR, "edc_facility", "tests", "blah.csv"),
SITE_ID=SiteID(default=10),
)
def test_bad_path(self):
app_configs = django_apps.get_app_configs()
errors = holiday_path_check(app_configs=app_configs)
self.assertIn("edc_facility.002", [error.id for error in errors])
@override_settings(
HOLIDAY_FILE=os.path.join(settings.BASE_DIR, "edc_facility", "tests", "holidays.csv"),
SITE_ID=SiteID(default=60),
)
def test_no_country(self):
app_configs = django_apps.get_app_configs()
errors = holiday_country_check(app_configs=app_configs)
self.assertIn("edc_facility.004", [error.id for error in errors])
@override_settings(
HOLIDAY_FILE=os.path.join(settings.BASE_DIR, "edc_facility", "tests", "holidays.csv"),
SITE_ID=SiteID(default=60),
)
def test_unknown_country(self):
import_holidays()
app_configs = django_apps.get_app_configs()
errors = holiday_country_check(app_configs=app_configs)
self.assertIn("edc_facility.004", [error.id for error in errors])
def test_compare_default_site_id(self):
self.site_id = SiteID(default=self.site.id)
self.assertEqual(self.site_id, self.site.id)
self.assertFalse(self.site_id != self.site.id)
self.assertFalse(self.site_id < self.site.id)
self.assertTrue(self.site_id <= self.site.id)
self.assertFalse(self.site_id > self.site.id)
self.assertTrue(self.site_id >= self.site.id)
class TestSites(SiteTestCaseMixin, TestCase):
@override_settings(SITE_ID=SiteID(default=20))
def test_20(self):
add_or_update_django_sites(sites=self.default_sites, verbose=False)
obj = TestModelWithSite.objects.create()
self.assertEqual(obj.site.pk, 20)
self.assertEqual(obj.site.pk, Site.objects.get_current().pk)
@override_settings(SITE_ID=SiteID(default=30))
def test_30(self):
add_or_update_django_sites(sites=self.default_sites, verbose=False)
obj = TestModelWithSite.objects.create()
self.assertEqual(obj.site.pk, 30)
self.assertEqual(obj.site.pk, Site.objects.get_current().pk)
@override_settings(SITE_ID=SiteID(default=30))
def test_override_current(self):
add_or_update_django_sites(sites=self.default_sites, verbose=False)
site = Site.objects.get(pk=40)
obj = TestModelWithSite.objects.create(site=site)
self.assertEqual(obj.site.pk, 40)
self.assertNotEqual(obj.site.pk, Site.objects.get_current().pk)
def test_get_site_id_by_name(self):
add_or_update_django_sites(sites=self.default_sites)
self.assertEqual(get_site_id("mochudi"), 10)
def test_get_site_id_by_title(self):
add_or_update_django_sites(sites=self.default_sites)
self.assertEqual(get_site_id("Mochudi"), 10)
def test_get_site_id_invalid(self):
add_or_update_django_sites(sites=self.default_sites)
self.assertRaises(InvalidSiteError, get_site_id, "blahblah")
def test_get_site_id_without_sites(self):
add_or_update_django_sites(sites=self.default_sites)
self.assertEqual(get_site_id("mochudi"), 10)
@override_settings(SITE_ID=SiteID(default=30))
def test_site_profile(self):
add_or_update_django_sites(sites=self.default_sites, verbose=False)
obj = TestModelWithSite.objects.create()
site_profile = SiteProfile.objects.get(site=obj.site)
self.assertEqual(obj.site.siteprofile, site_profile)
def test_updates_sites(self):
add_or_update_django_sites(sites=self.default_sites)
for site in self.default_sites:
self.assertIn(site.site_id, [obj.id for obj in Site.objects.all()])
self.assertNotIn("example.com",
str([str(obj) for obj in Site.objects.all()]))
self.assertEqual(len(self.default_sites), Site.objects.all().count())
def test_domain(self):
add_or_update_django_sites(sites=self.default_sites)
obj = Site.objects.get(name="molepolole")
self.assertEqual("molepolole.clinicedc.org", obj.domain)
obj = Site.objects.get(name="mochudi")
self.assertEqual("mochudi.bw.clinicedc.org", obj.domain)
@override_settings(EDC_SITES_UAT_DOMAIN=True)
def test_uat_domain(self):
self.assertTrue(settings.EDC_SITES_UAT_DOMAIN)
add_or_update_django_sites(sites=self.default_sites)
obj = Site.objects.get(name="molepolole")
self.assertEqual("molepolole.uat.clinicedc.org", obj.domain)
obj = Site.objects.get(name="mochudi")
self.assertEqual("mochudi.uat.bw.clinicedc.org", obj.domain)
@override_settings(SITE_ID=SiteID(default=10))
def test_country(self):
for sites in self.default_all_sites.values():
add_or_update_django_sites(sites=sites)
self.assertEqual("mochudi", Site.objects.get_current().name)
self.assertEqual("botswana",
Site.objects.get_current().siteprofile.country)
self.assertEqual("botswana", get_current_country())
self.assertEqual(self.default_all_sites.get("botswana"),
get_sites_by_country("botswana"))
self.assertEqual(self.default_all_sites.get("botswana"),
get_sites_by_country())
self.assertEqual(
self.default_all_sites.get("botswana"),
get_sites_by_country(all_sites=self.default_all_sites),
)
self.assertEqual(
self.default_all_sites.get("botswana"),
get_sites_by_country(country="botswana",
all_sites=self.default_all_sites),
)
@override_settings(EDC_SITES_MODULE_NAME=None)
def test_default_sites_module_domain(self):
self.assertEqual(get_all_sites(), all_sites)
for sites in get_all_sites().values():
add_or_update_django_sites(sites=sites, verbose=False)
site = Site.objects.get(id=1)
self.assertEqual(Alias.objects.get(site=site).domain, "localhost")
@override_settings(EDC_SITES_MODULE_NAME="edc_sites.tests.sites",
EDC_SITES_UAT_DOMAIN=False)
def test_custom_sites_module_domain(self):
self.assertEqual(get_all_sites(), all_test_sites)
self.assertEqual(settings.SITE_ID, 10)
for sites in get_all_sites().values():
add_or_update_django_sites(sites=sites, verbose=False)
site = Site.objects.get(id=10)
self.assertEqual(get_current_country(), "botswana")
self.assertEqual(
Alias.objects.get(site=site).domain, "mochudi.bw.clinicedc.org")
# Internationalization
# https://docs.djangoproject.com/en/3.0/topics/i18n/
LANGUAGE_CODE = "en-us"
TIME_ZONE = "UTC"
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.0/howto/static-files/
STATIC_URL = "/static/"
# SUBJECT_VISIT_MODEL = "sarscov2.subjectvisit"
EMAIL_CONTACTS = {}
ADVERSE_EVENT_APP_LABEL = ""
SUBJECT_REQUISITION_MODEL = ""
SUBJECT_CONSENT_MODEL = ""
EDC_BOOTSTRAP = ""
KEY_PATH = os.path.join(BASE_DIR, "sarscov2", "tests", "etc", "crypto_fields")
ETC_DIR = BASE_DIR
AUTO_CREATE_KEYS = False
SITE_ID = SiteID(default=1)
CRF_STATUS_DEFAULT = COMPLETE
EDC_PROTOCOL_NUMBER = "100"
def setUp(self):
Site.objects.all().delete()
self.site = Site.objects.create(domain='example.com')
self.site_id = SiteID()
self.host = host
def get(self, path, data={}, host=None, **extra):
if host is None:
host = self.host
return super(RequestFactory, self).get(path=path,
data=data,
HTTP_HOST=host,
**extra)
@pytest.mark.django_db
@skipUnless(Site._meta.installed,
'django.contrib.sites is not in settings.INSTALLED_APPS')
@override_settings(
SITE_ID=SiteID(),
CACHE_SITES_KEY_PREFIX='__test__',
)
class TestContribSite(TestCase):
def setUp(self):
Site.objects.all().delete()
self.site = Site.objects.create(domain='example.com')
settings.SITE_ID.set(self.site.id)
def test_get_current_site(self):
current_site = Site.objects.get_current()
self.assertEqual(current_site, self.site)
self.assertEqual(current_site.id, settings.SITE_ID)
# Because we are a middleware package, we have no views available to test with easily
class TestRegistration(SiteTestCaseMixin, TestCase):
def test_creates_registered_subject(self):
obj = SubjectModelOne.objects.create(screening_identifier="12345")
try:
RegisteredSubject.objects.get(
registration_identifier=obj.to_string(
obj.registration_identifier))
except ObjectDoesNotExist:
self.fail("RegisteredSubject was unexpectedly not created")
def test_updates_registered_subject(self):
SubjectModelOne.objects.create(screening_identifier="12345",
dob=get_utcnow() -
relativedelta(years=5))
new_dob = get_utcnow().date()
obj = SubjectModelOne.objects.get(screening_identifier="12345")
obj.dob = new_dob
obj.save()
rs = RegisteredSubject.objects.get(
registration_identifier=obj.to_string(obj.registration_identifier))
self.assertEqual(rs.dob, new_dob)
def test_creates_registered_subject_overridden(self):
"""Assert creates RegisteredSubject with registration_unique_field overridden."""
obj = SubjectModelTwo.objects.create(subject_identifier="12345")
try:
RegisteredSubject.objects.get(
subject_identifier=obj.subject_identifier)
except ObjectDoesNotExist:
self.fail("RegisteredSubject was unexpectedly not created")
def test_updates_registered_subject_overridden(self):
"""Assert updates RegisteredSubject with registration_unique_field overridden."""
SubjectModelTwo.objects.create(subject_identifier="12345",
dob=get_utcnow() -
relativedelta(years=5))
new_dob = get_utcnow().date()
obj = SubjectModelTwo.objects.get(subject_identifier="12345")
obj.dob = new_dob
obj.save()
rs = RegisteredSubject.objects.get(
subject_identifier=obj.subject_identifier)
self.assertEqual(rs.dob, new_dob)
def test_creates_registered_subject_overridden2(self):
"""Assert creates RegisteredSubject with registration_unique_field overridden."""
obj = SubjectModelThree.objects.create(subject_identifier="12345")
try:
RegisteredSubject.objects.get(
subject_identifier=obj.subject_identifier)
except ObjectDoesNotExist:
self.fail("RegisteredSubject was unexpectedly not created")
def test_updates_registered_subject_overridden2(self):
"""Assert updates RegisteredSubject with registration_unique_field overridden."""
SubjectModelThree.objects.create(subject_identifier="12345",
dob=get_utcnow() -
relativedelta(years=5))
new_dob = get_utcnow().date()
obj = SubjectModelThree.objects.get(subject_identifier="12345")
obj.dob = new_dob
obj.save()
rs = RegisteredSubject.objects.get(
subject_identifier=obj.subject_identifier)
self.assertEqual(rs.dob, new_dob)
def test_subject_identifier_as_uuid(self):
obj = SubjectModelOne.objects.create(screening_identifier="12345")
rs = RegisteredSubject.objects.get(
registration_identifier=obj.to_string(obj.registration_identifier))
self.assertFalse(rs.subject_identifier_is_set)
def test_masks_if_not_set(self):
obj = SubjectModelOne.objects.create(screening_identifier="12345")
rs = RegisteredSubject.objects.get(
registration_identifier=obj.to_string(obj.registration_identifier))
self.assertEqual(str(rs), "<identifier not set>")
rs.subject_identifier = "ABCDEF"
rs.save()
rs = RegisteredSubject.objects.get(
registration_identifier=obj.to_string(obj.registration_identifier))
self.assertEqual(str(rs), "ABCDEF")
def test_cannot_change_subject_identifier(self):
obj = SubjectModelOne.objects.create(screening_identifier="12345")
rs = RegisteredSubject.objects.get(
registration_identifier=obj.to_string(obj.registration_identifier))
rs.subject_identifier = "ABCDEF"
rs.save()
rs.subject_identifier = "WXYZ"
self.assertRaises(RegisteredSubjectError, rs.save)
@override_settings(SITE_ID=SiteID(10))
def test_site1(self):
add_or_update_django_sites(sites=self.default_sites, verbose=False)
obj = SubjectModelOne.objects.create(screening_identifier="12345")
rs = RegisteredSubject.objects.get(
registration_identifier=obj.to_string(obj.registration_identifier))
self.assertEqual(rs.site.pk, 10)
@override_settings(SITE_ID=SiteID(20))
def test_site2(self):
add_or_update_django_sites(sites=self.default_sites, verbose=False)
obj = SubjectModelOne.objects.create(screening_identifier="12345")
rs = RegisteredSubject.objects.get(
registration_identifier=obj.to_string(obj.registration_identifier))
self.assertEqual(rs.site.pk, 20)
class TestManifestReport(SiteTestCaseMixin, TestCase):
def setUp(self):
add_or_update_django_sites(sites=self.default_sites, verbose=False)
self.user = User.objects.create(first_name="Noam", last_name="Chomsky")
consignee = Consignee.objects.create(name="consignee")
shipper = Shipper.objects.create(name="shipper")
self.manifest = Manifest.objects.create(consignee=consignee, shipper=shipper)
@override_settings(SITE_ID=SiteID(default=20))
def test_report(self):
self.assertEqual(self.manifest.site.name, "test_site")
report = ManifestReport(manifest=self.manifest, user=self.user)
report.render()
@override_settings(SITE_ID=SiteID(default=20))
def test_report_shipped(self):
self.manifest.shipped = True
self.manifest.save()
self.assertEqual(self.manifest.site.name, "test_site")
report = ManifestReport(manifest=self.manifest, user=self.user)
report.render()
@override_settings(SITE_ID=SiteID(default=20))
def test_report_items_not_in_box(self):
self.manifest.shipped = True
self.manifest.save()
for i in range(0, 3):
ManifestItem.objects.create(
manifest=self.manifest,
identifier=f"{self.manifest.manifest_identifier}{i}",
)
self.assertEqual(self.manifest.site.name, "test_site")
report = ManifestReport(manifest=self.manifest, user=self.user)
self.assertRaises(ManifestReportError, report.render)
try:
report.render()
except ManifestReportError as e:
self.assertEqual(e.code, "unboxed_item")
def test_box_type(self):
BoxType.objects.create(name="box_type", across=8, down=8, total=64)
def test_box(self):
box_type = BoxType.objects.create(name="box_type", across=8, down=8, total=64)
Box.objects.create(box_type=box_type)
def test_box_item(self):
box_type = BoxType.objects.create(name="box_type", across=8, down=8, total=64)
box = Box.objects.create(box_type=box_type)
BoxItem.objects.create(box=box, identifier=box.box_identifier, position=0)
@override_settings(SITE_ID=SiteID(default=20))
def test_report_invalid_invalid_aliquot_identifier(self):
self.manifest.shipped = True
self.manifest.save()
box_type = BoxType.objects.create(name="box_type", across=8, down=8, total=64)
box = Box.objects.create(box_type=box_type)
# add box items with invalid aliquot identifiers
for i in range(0, 3):
BoxItem.objects.create(box=box, identifier=f"{i}", position=i)
ManifestItem.objects.create(manifest=self.manifest, identifier=box.box_identifier)
self.assertEqual(self.manifest.site.name, "test_site")
report = ManifestReport(manifest=self.manifest, user=self.user)
self.assertRaises(ManifestReportError, report.render)
try:
report.render()
except ManifestReportError as e:
self.assertEqual(e.code, "invalid_aliquot_identifier")
@override_settings(SITE_ID=SiteID(default=20))
def test_report_invalid_invalid_requisition_identifier(self):
self.manifest.shipped = True
self.manifest.save()
prefix = "ABCDEFG"
for i in range(0, 3):
Aliquot.objects.create(count=i, aliquot_identifier=f"{prefix}{i}")
box_type = BoxType.objects.create(name="box_type", across=8, down=8, total=64)
box = Box.objects.create(box_type=box_type)
# add box items with invalid aliquot identifiers
for index, aliquot in enumerate(Aliquot.objects.all()):
BoxItem.objects.create(
box=box, identifier=aliquot.aliquot_identifier, position=index
)
ManifestItem.objects.create(manifest=self.manifest, identifier=box.box_identifier)
self.assertEqual(self.manifest.site.name, "test_site")
report = ManifestReport(manifest=self.manifest, user=self.user)
self.assertRaises(ManifestReportError, report.render)
try:
report.render()
except ManifestReportError as e:
self.assertEqual(e.code, "invalid_requisition_identifier")
class TestRandomizer(TestCase):
import_randomization_list = False
site_names = [x.name for x in all_sites]
def setUp(self):
super().setUp()
add_or_update_django_sites(sites=all_sites)
site_randomizers._registry = {}
site_randomizers.register(Randomizer)
def populate_list(self,
randomizer_name=None,
site_names=None,
per_site=None,
overwrite_site=None):
randomizer = site_randomizers.get(randomizer_name)
make_test_list(
full_path=randomizer.get_randomization_list_fullpath(),
site_names=site_names or self.site_names,
per_site=per_site,
)
randomizer.import_list(overwrite=True)
if overwrite_site:
site = Site.objects.get_current()
randomizer.model_cls().objects.update(site_name=site.name)
@override_settings(SITE_ID=SiteID(40))
def test_(self):
randomizer = site_randomizers.get("default")
randomizer.import_list()
@override_settings(SITE_ID=SiteID(40))
def test_with_consent_insufficient_data(self):
randomizer = site_randomizers.get("default")
randomizer.import_list()
subject_consent = SubjectConsent.objects.create(
subject_identifier="12345", user_created="erikvw")
self.assertRaises(
RandomizationError,
Randomizer,
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=None,
)
@override_settings(SITE_ID=SiteID(40))
def test_with_consent(self):
randomizer = site_randomizers.get("default")
randomizer.import_list()
site = Site.objects.get_current()
subject_consent = SubjectConsent.objects.create(
subject_identifier="12345", site=site, user_created="erikvw")
try:
Randomizer(
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_created,
)
except Exception as e:
self.fail(f"Exception unexpectedly raised. Got {str(e)}.")
@override_settings(SITE_ID=SiteID(40))
def test_with_gender_and_consent(self):
class RandomizerWithGender(Randomizer):
def __init__(self, gender=None, **kwargs):
self.gender = gender
super().__init__(**kwargs)
@property
def extra_required_attrs(self):
return dict(gender=self.gender)
randomizer = site_randomizers.get("default")
randomizer.import_list()
site = Site.objects.get_current()
subject_consent = SubjectConsent.objects.create(
subject_identifier="12345",
site=site,
gender=FEMALE,
user_created="erikvw")
try:
RandomizerWithGender(
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
gender=FEMALE,
user=subject_consent.user_created,
)
except Exception as e:
self.fail(f"Exception unexpectedly raised. Got {str(e)}.")
@override_settings(SITE_ID=SiteID(40))
def test_with_list_selects_first(self):
self.populate_list(randomizer_name="default", overwrite_site=True)
first_obj = RandomizationList.objects.all().first()
subject_consent = SubjectConsent.objects.create(
subject_identifier="12345", user_created="erikvw")
rando = Randomizer(
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_created,
)
self.assertEqual(rando.sid, first_obj.sid)
@override_settings(SITE_ID=SiteID(40))
def test_updates_registered_subject(self):
self.populate_list(randomizer_name="default", overwrite_site=True)
subject_consent = SubjectConsent.objects.create(
subject_identifier="12345", user_created="erikvw")
Randomizer(
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_created,
)
first_obj = RandomizationList.objects.all().first()
rs = RegisteredSubject.objects.get(subject_identifier="12345")
self.assertEqual(rs.subject_identifier, first_obj.subject_identifier)
self.assertEqual(rs.sid, str(first_obj.sid))
self.assertEqual(rs.randomization_datetime,
first_obj.allocated_datetime)
self.assertEqual(rs.randomization_list_model,
first_obj._meta.label_lower)
@override_settings(SITE_ID=SiteID(40))
def test_updates_list_obj_as_allocated(self):
self.populate_list(randomizer_name="default", overwrite_site=True)
RandomizationList.objects.all().first()
subject_consent = SubjectConsent.objects.create(
subject_identifier="12345", user_created="erikvw")
Randomizer(
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_created,
)
first_obj = RandomizationList.objects.all().first()
self.assertEqual(first_obj.subject_identifier, "12345")
self.assertTrue(first_obj.allocated)
self.assertIsNotNone(first_obj.allocated_user)
self.assertEqual(first_obj.allocated_user,
subject_consent.user_created)
self.assertEqual(first_obj.allocated_datetime,
subject_consent.consent_datetime)
self.assertGreater(first_obj.modified, subject_consent.created)
@override_settings(SITE_ID=SiteID(40))
def test_cannot_rerandomize(self):
self.populate_list(randomizer_name="default", overwrite_site=True)
first_obj = RandomizationList.objects.all().first()
subject_consent = SubjectConsent.objects.create(
subject_identifier="12345", user_created="erikvw")
rando = Randomizer(
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_created,
)
self.assertEqual(rando.sid, first_obj.sid)
self.assertRaises(
AlreadyRandomized,
Randomizer,
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_created,
)
@override_settings(SITE_ID=SiteID(40))
def test_error_condition1(self):
"""Assert raises if RegisteredSubject not updated correctly."""
self.populate_list(randomizer_name="default", overwrite_site=True)
subject_consent = SubjectConsent.objects.create(
subject_identifier="12345", user_created="erikvw")
rando = Randomizer(
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_created,
)
rando.registered_subject.sid = None
rando.registered_subject.save()
with self.assertRaises(AlreadyRandomized) as cm:
Randomizer(
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_created,
)
self.assertEqual(cm.exception.code,
"edc_randomization.randomizationlist")
@override_settings(SITE_ID=SiteID(40))
def test_error_condition2(self):
"""Assert raises if RandomizationList not updated correctly."""
self.populate_list(randomizer_name="default", overwrite_site=True)
subject_consent = SubjectConsent.objects.create(
subject_identifier="12345", user_created="erikvw")
rando = Randomizer(
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_created,
)
rando.registered_subject.sid = None
rando.registered_subject.save()
with self.assertRaises(AlreadyRandomized) as cm:
Randomizer(
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_created,
)
self.assertEqual(cm.exception.code,
"edc_randomization.randomizationlist")
def test_error_condition3(self):
"""Assert raises if RandomizationList not updated correctly."""
self.populate_list(randomizer_name="default", overwrite_site=True)
site = Site.objects.get_current()
subject_consent = SubjectConsent.objects.create(
subject_identifier="12345", site=site, user_created="erikvw")
Randomizer(
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_created,
)
RandomizationList.objects.update(subject_identifier=None)
with self.assertRaises(AlreadyRandomized) as cm:
Randomizer(
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_created,
)
self.assertEqual(cm.exception.code,
"edc_registration.registeredsubject")
def test_subject_does_not_exist(self):
self.populate_list(randomizer_name="default", overwrite_site=True)
site = Site.objects.get_current()
subject_consent = SubjectConsent.objects.create(
subject_identifier="12345", site=site, user_created="erikvw")
RegisteredSubject.objects.all().delete()
self.assertRaises(
RandomizationError,
Randomizer,
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_modified,
)
def test_str(self):
self.populate_list(randomizer_name="default", overwrite_site=True)
site = Site.objects.get_current()
subject_consent = SubjectConsent.objects.create(
subject_identifier="12345", site=site, user_created="erikvw")
Randomizer(
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_created,
)
obj = RandomizationList.objects.all().first()
self.assertTrue(str(obj))
@override_settings(SITE_ID=SiteID(40))
def test_for_sites(self):
"""Assert that allocates by site correctly."""
site_randomizers._registry = {}
site_randomizers.register(MyRandomizer)
model_cls = MyRandomizer.model_cls()
model_cls.objects.all().delete()
self.populate_list(randomizer_name=MyRandomizer.name,
site_names=self.site_names,
per_site=5)
site_names = [obj.site_name for obj in model_cls.objects.all()]
shuffle(site_names)
self.assertEqual(len(site_names), len(self.site_names * 5))
# consent and randomize 5 for each site
for index, site_name in enumerate(site_names):
site = Site.objects.get(name=site_name)
subject_consent = SubjectConsent.objects.create(
subject_identifier=f"12345{index}",
site=site,
user_created="erikvw")
MyRandomizer(
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_created,
)
# assert consented subjects were allocated SIDs in the
# correct order per site.
for site_name in site_names:
randomized_subjects = [
(obj.subject_identifier, str(obj.sid))
for obj in model_cls.objects.filter(
allocated_site__name=site_name,
subject_identifier__isnull=False).order_by("sid")
]
for index, obj in enumerate(
SubjectConsent.objects.filter(
site__name=site_name).order_by("consent_datetime")):
rs = RegisteredSubject.objects.get(
subject_identifier=obj.subject_identifier)
self.assertEqual(obj.subject_identifier,
randomized_subjects[index][0])
self.assertEqual(rs.sid, randomized_subjects[index][1])
# clear out any unallocated
model_cls.objects.filter(subject_identifier__isnull=True).delete()
# assert raises on next attempt to randomize
subject_consent = SubjectConsent.objects.create(
subject_identifier="ABCDEF",
site=site,
user_created="erikvw",
user_modified="erikvw",
)
self.assertRaises(
AllocationError,
MyRandomizer,
subject_identifier=subject_consent.subject_identifier,
report_datetime=subject_consent.consent_datetime,
site=subject_consent.site,
user=subject_consent.user_modified,
)
@override_settings(SITE_ID=SiteID(40))
def test_not_loaded(self):
try:
RandomizationListVerifier(randomizer_name=Randomizer.name)
except RandomizationListError as e:
self.assertIn("Randomization list has not been loaded", str(e))
else:
self.fail("RandomizationListError unexpectedly NOT raised")
@override_settings(SITE_ID=SiteID(40))
def test_cannot_overwrite(self):
site_randomizers._registry = {}
site_randomizers.register(MyRandomizer)
make_test_list(
full_path=MyRandomizer.get_randomization_list_fullpath(),
site_names=self.site_names,
count=5,
)
randomizer = site_randomizers.get(MyRandomizer.name)
randomizer.import_list()
self.assertRaises(RandomizationListImportError, randomizer.import_list)
@override_settings(SITE_ID=SiteID(40))
def test_can_overwrite_explicit(self):
site_randomizers._registry = {}
site_randomizers.register(MyRandomizer)
make_test_list(
full_path=MyRandomizer.get_randomization_list_fullpath(),
site_names=self.site_names,
count=5,
)
randomizer = site_randomizers.get(MyRandomizer.name)
try:
randomizer.import_list(overwrite=True)
except RandomizationListImportError:
self.fail("RandomizationListImportError unexpectedly raised")
@override_settings(SITE_ID=SiteID(40))
def test_invalid_assignment(self):
site_randomizers._registry = {}
site_randomizers.register(MyRandomizer)
MyRandomizer.get_randomization_list_fullpath()
make_test_list(
full_path=MyRandomizer.get_randomization_list_fullpath(),
site_names=self.site_names,
# change to a different assignments
assignments=[100, 101],
count=5,
)
self.assertRaises(InvalidAssignment, MyRandomizer.import_list)
@override_settings(SITE_ID=SiteID(40))
def test_invalid_sid(self):
self.populate_list(randomizer_name="default")
# change to a different starting SID
obj = RandomizationList.objects.all().order_by("sid").first()
obj.sid = 99999
obj.save()
with self.assertRaises(RandomizationListError) as cm:
RandomizationListVerifier(randomizer_name=Randomizer.name)
self.assertIn("Randomization list has invalid SIDs", str(cm.exception))
@override_settings(SITE_ID=SiteID(40))
def test_invalid_count(self):
site = Site.objects.get_current()
# change number of SIDs in DB
self.populate_list(randomizer_name="default")
RandomizationList.objects.create(sid=100,
assignment=ACTIVE,
site_name=site.name)
self.assertEqual(RandomizationList.objects.all().count(), 51)
with self.assertRaises(RandomizationListError) as cm:
RandomizationListVerifier(randomizer_name=Randomizer.name)
self.assertIn("Randomization list count is off", str(cm.exception))
"""
A settings file with the bare minimum attributes.
"""
import os
from pathlib import Path
import environ
from multisite import SiteID
APP_NAME = "inte_edc"
BASE_DIR = str(Path(os.path.dirname(os.path.abspath(__file__))).parent.parent)
ENV_DIR = str(Path(os.path.dirname(os.path.abspath(__file__))).parent.parent)
env = environ.Env()
env.read_env(os.path.join(ENV_DIR, ".env"))
EDC_SITES_MODULE_NAME = env.str("EDC_SITES_MODULE_NAME")
ETC_DIR = env.str("DJANGO_ETC_FOLDER")
SECRET_KEY = "blahblahblah"
ALLOWED_HOSTS = ["*"]
SITE_ID = SiteID(default=1) # 1 is not a site
def _update_defaults(self):
"""Assumes BASE_DIR, APP_NAME are in kwargs."""
self.settings.update(
ALLOWED_HOSTS=["localhost"],
STATIC_URL="/static/",
DATABASES={
# required for tests when acting as a server that deserializes
"default": {
"ENGINE": "django.db.backends.sqlite3",
"NAME": os.path.join(self.base_dir, "db.sqlite3"),
},
"client": {
"ENGINE": "django.db.backends.sqlite3",
"NAME": os.path.join(self.base_dir, "db.sqlite3"),
},
},
TEMPLATES=[{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"APP_DIRS": True,
"OPTIONS": {
"context_processors": [
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
"django.template.context_processors.request",
]
},
}],
MIDDLEWARE=[
"django.middleware.security.SecurityMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.common.CommonMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
"django.middleware.clickjacking.XFrameOptionsMiddleware",
"django.contrib.sites.middleware.CurrentSiteMiddleware",
],
LANGUAGE_CODE="en-us",
TIME_ZONE="UTC",
USE_I18N=True,
USE_L10N=True,
USE_TZ=True,
DEFAULT_AUTO_FIELD="django.db.models.BigAutoField",
EDC_BOOTSTRAP=3,
GIT_DIR=self.base_dir,
LIVE_SYSTEM=False,
REVIEWER_SITE_ID=0,
SITE_ID=SiteID(default=1) if SiteID else 1,
SILENCED_SYSTEM_CHECKS=[
"sites.E101"
], # The SITE_ID setting must be an integer
SECRET_KEY=uuid4().hex,
HOLIDAY_FILE=os.path.join(self.base_dir, self.app_name, "tests",
"holidays.csv"),
INDEX_PAGE_LABEL="",
DASHBOARD_URL_NAMES={},
DASHBOARD_BASE_TEMPLATES={},
EMAIL_BACKEND="django.core.mail.backends.locmem.EmailBackend",
EMAIL_CONTACTS={
"data_request": "*****@*****.**",
"data_manager": "*****@*****.**",
"tmg": "*****@*****.**",
},
EMAIL_ENABLED=True,
INDEX_PAGE="http://localhost:8000",
SENTRY_ENABLED=False,
TWILIO_ENABLED=False,
TWILIO_TEST_RECIPIENT="+15555555555",
SUBJECT_SCREENING_MODEL=f"{self.app_name}.subjectscreening",
SUBJECT_CONSENT_MODEL=f"{self.app_name}.subjectconsent",
SUBJECT_VISIT_MODEL=f"{self.app_name}.subjectvisit",
SUBJECT_VISIT_MISSED_MODEL=f"{self.app_name}.subjectvisitmissed",
SUBJECT_REQUISITION_MODEL=f"{self.app_name}.subjectrequisition",
SUBJECT_APP_LABEL=f"{self.app_name}",
ADVERSE_EVENT_ADMIN_SITE="adverse_event_app_admin",
ADVERSE_EVENT_APP_LABEL="adverse_event_app",
DJANGO_COLLECT_OFFLINE_ENABLED=False,
DJANGO_COLLECT_OFFLINE_FILES_REMOTE_HOST=None,
DJANGO_COLLECT_OFFLINE_FILES_USB_VOLUME=None,
DJANGO_COLLECT_OFFLINE_FILES_USER=None,
DJANGO_COLLECT_OFFLINE_SERVER_IP=None,
EDC_NAVBAR_DEFAULT=self.app_name,
EDC_PROTOCOL_PROJECT_NAME="EDC TEST PROJECT",
EDC_PROTOCOL_STUDY_OPEN_DATETIME=arrow.utcnow().datetime -
relativedelta(years=1),
EDC_PROTOCOL_STUDY_CLOSE_DATETIME=arrow.utcnow().datetime +
relativedelta(years=1),
EDC_PROTOCOL_NUMBER="101",
EDC_FACILITY_USE_DEFAULTS=True,
EDC_FACILITY_DEFAULT_FACILITY_NAME="7-day-clinic",
LIST_MODEL_APP_LABEL=self.app_name.replace("edc", "lists"),
EDC_RANDOMIZATION_LIST_PATH=os.path.join(self.base_dir,
self.app_name, "tests",
"etc"),
EDC_RANDOMIZATION_REGISTER_DEFAULT_RANDOMIZER=True,
EDC_RANDOMIZATION_SKIP_VERIFY_CHECKS=True,
EDC_SITES_MODULE_NAME=None,
DATA_DICTIONARY_APP_LABELS=[],
DEFAULT_FILE_STORAGE="inmemorystorage.InMemoryStorage",
MIGRATION_MODULES=get_migrations_module(),
PASSWORD_HASHERS=(
"django.contrib.auth.hashers.MD5PasswordHasher", ),
)
