def setUpTestData(cls):
cls.domain = "registry-fixture-test"
cls.domain_obj = create_domain(cls.domain)
cls.domain_obj.hr_name = "Registry Fixture Test"
cls.domain_obj.save()
cls.restore_user = create_restore_user(cls.domain,
username=f'{cls.domain}-user')
cls.restore_user_domain_1 = create_restore_user(
"domain1", username='******')
invitations = [Invitation("domain1"), Invitation("domain2")]
grants = [
Grant("domain1", [cls.domain]),
Grant("domain2", [cls.domain])
]
cls.registry = create_registry_for_test(
cls.restore_user._couch_user.get_django_user(),
cls.domain,
invitations=invitations,
grants=grants,
name="Test Registry")
factory = AppFactory(domain=cls.domain)
module1, form1 = factory.new_basic_module("patient", "patient")
module1.search_config.properties = [CaseSearchProperty()]
module1.search_config.data_registry = cls.registry.slug
factory.new_report_module("reports")
cls.app = factory.app
cls.app.save()
def setUpClass(cls):
super().setUpClass()
cls.user = create_user("admin", "123")
cls.registry_owner_domain = "registry-owner"
cls.participator_1 = "domain1"
cls.participator_2 = "domain2"
cls.participator_3 = "domain3"
cls.participants = (cls.participator_1, cls.participator_2,
cls.participator_3)
invitations = [Invitation(domain) for domain in cls.participants]
grants = [
Grant(from_domain=cls.participator_1,
to_domains=[cls.participator_2, cls.participator_3]),
Grant(from_domain=cls.participator_2,
to_domains=[cls.participator_1]),
]
cls.registry_1 = create_registry_for_test(
cls.user,
cls.registry_owner_domain,
invitations=invitations,
grants=grants,
)
# UCR in domain1 should get data from itself and from domain2
cls.config = get_sample_registry_data_source(
domain=cls.participator_1, registry_slug=cls.registry_1.slug)
cls.config.save()
cls.adapter = get_indicator_adapter(cls.config)
cls.adapter.build_table()
cls.pillow = get_kafka_ucr_registry_pillow(ucr_configs=[cls.config],
processor_chunk_size=100)
def test_get_granted_domains(self):
invitations = [Invitation('A'), Invitation('B'), Invitation('C')]
grants = [
Grant("A", ["B"]),
Grant("B", ["A", "C"]),
Grant("C", ["A"]),
]
registry = create_registry_for_test(self.user, self.domain, invitations, grants, name="reg1")
self.assertEqual({"A"}, registry.get_granted_domains("B"))
self.assertEqual({"B", "C"}, registry.get_granted_domains("A"))
self.assertEqual({"B"}, registry.get_granted_domains("C"))
def setUpClass(cls):
super().setUpClass()
cls.domain = 'registry-permissions'
cls.user = create_user('admin', '123')
cls.registry_slug = create_registry_for_test(
cls.user,
cls.domain,
invitations=[Invitation("A"), Invitation("B")],
grants=[
Grant("A", [cls.domain]),
Grant("B", [cls.domain]),
],
name="reg1",
case_types=["herb"]).slug
def setUpClass(cls):
super().setUpClass()
cls.user = create_user("admin", "123")
cls.domain_1 = "jane-the-virgin"
cls.setup_domain(cls.domain_1, [
case("Jane", 'person', {"family": "Villanueva"}),
case("Xiomara", 'person', {"family": "Villanueva"}),
case("Alba", 'person', {"family": "Villanueva"}),
case("Rogelio", 'person', {"family": "de la Vega"}),
case("Jane", 'person', {"family": "Ramos"}),
] + parent_and_child_cases(
"Jennie Snyder Urman",
"Jane the Virgin",
))
cls.domain_2 = "jane-eyre"
cls.setup_domain(cls.domain_2, [
case("Jane", 'person', {"family": "Eyre"}),
case("Sarah", 'person', {"family": "Reed"}),
case("John", 'person', {"family": "Reed"}),
case("Eliza", 'person', {"family": "Reed"}),
case("Georgiana", 'person', {"family": "Reed"}),
] + parent_and_child_cases(
"Charlotte Brontë",
"Jane Eyre",
))
cls.domain_3 = "janes-addiction"
cls.setup_domain(cls.domain_3, [
case("Jane", 'person', {"family": "Villanueva"}),
case("Perry", 'person', {"family": "Farrell"}),
case("Dave", 'person', {"family": "Navarro"}),
case("Stephen", 'person', {"family": "Perkins"}),
case("Chris", 'person', {"family": "Chaney"}),
])
cls.registry_slug = create_registry_for_test(
cls.user,
cls.domain_1,
invitations=[
Invitation(cls.domain_2),
Invitation(cls.domain_3),
],
grants=[
Grant(cls.domain_1, [cls.domain_2]),
Grant(cls.domain_2, [cls.domain_1]),
Grant(cls.domain_3, [cls.domain_1]),
],
name="reg1",
case_types=["person", "creative_work"]).slug
def setUpClass(cls):
super(DomainChoiceProviderTest, cls).setUpClass()
cls.domain_a = create_domain(name="A")
cls.domain_b = create_domain(name="B")
cls.domain_c = create_domain(name="C")
cls.domain_d = create_domain(name="D")
for domain in [cls.domain_a, cls.domain_b, cls.domain_c, cls.domain_d]:
domain.save()
cls.user = create_user("admin", "123")
cls.web_user = cls.make_web_user_with_registry_role(
'*****@*****.**', cls.domain_a, has_registry_access=True)
cls.web_user_no_registry_access = cls.make_web_user_with_registry_role(
'*****@*****.**', cls.domain_a)
invitations = [Invitation('A'), Invitation('B'), Invitation('C')]
# A, B, and C are in the registry A has access to B and C, B has access to C
grants = [
Grant("C", ["B", "A"]),
Grant("B", ["A"]),
Grant("A", []),
]
cls.registry = create_registry_for_test(cls.user,
cls.domain,
invitations,
grants=grants,
name="registry")
cls.config = RegistryDataSourceConfiguration(
domain="A",
table_id='foo',
referenced_doc_type='CommCareCase',
registry_slug=cls.registry.slug,
)
cls.config.save()
cls.report = RegistryReportConfiguration(domain="A",
config_id=cls.config._id)
cls.report.save()
choices = [
SearchableChoice("A", "A", ["A"]),
SearchableChoice("B", "B", ["B"]),
SearchableChoice("C", "C", ["C"]),
]
choices.sort(key=lambda choice: choice.display)
cls.choice_provider = DomainChoiceProvider(cls.report, None)
cls.static_choice_provider = StaticChoiceProvider(choices)
def test_get_accessible_grants(self):
invitations = [
Invitation('A'),
Invitation('B'),
]
create_registry_for_test(self.user, self.domain, invitations, grants=[Grant("B", ["A"])], name="reg1")
self.assertEqual(
{"reg1"},
{reg.slug for reg in DataRegistry.objects.accessible_to_domain('A', has_grants=True)}
)
# B has no grants
self.assertEqual(0, len(DataRegistry.objects.accessible_to_domain('B', has_grants=True)))
def setUpTestData(cls):
cls.user = create_user("admin", "123")
cls.registry_1 = create_registry_for_test(
cls.user,
'foo_bar',
invitations=[
Invitation(cls.domain),
Invitation("granted-domain"),
],
grants=[Grant("granted-domain", to_domains=[cls.domain])],
name='test')
cls.registry_2 = create_registry_for_test(
cls.user,
'bazz',
invitations=[
Invitation(cls.domain),
Invitation("other-domain"),
],
grants=[Grant("other-domain", to_domains=[cls.domain])],
name='bazz')
def setUpClass(cls):
super().setUpClass()
cls.domain_obj = create_domain(cls.domain)
# DATA_FORWARDING is on PRO and above
cls.setup_subscription(cls.domain, SoftwarePlanEdition.PRO)
cls.connx = ConnectionSettings.objects.create(
domain=cls.domain,
url="case-repeater-url/{domain}/",
username="******")
cls.repeater = DataRegistryCaseUpdateRepeater(
domain=cls.domain,
connection_settings_id=cls.connx.id,
white_listed_case_types=[IntentCaseBuilder.CASE_TYPE])
cls.repeater.save()
cls.user = create_user("admin", "123")
cls.registry_slug = create_registry_for_test(
cls.user,
cls.domain,
invitations=[
Invitation(cls.target_domain),
],
grants=[
Grant(cls.target_domain, [cls.domain]),
],
name="reg1",
case_types=["patient"]).slug
cls.mobile_user = CommCareUser.create(cls.domain,
"user1",
"123",
None,
None,
is_admin=True)
cls.target_case_id_1 = uuid.uuid4().hex
cls.target_case_id_2 = uuid.uuid4().hex
post_case_blocks([
CaseBlock(
case_id=case_id,
create=True,
case_type="patient",
).as_xml()
for case_id in [cls.target_case_id_1, cls.target_case_id_2]
],
domain=cls.target_domain)
def test_get_accessible_grants_no_invite(self):
create_registry_for_test(self.user, self.domain, grants=[Grant("B", ["A"])])
self.assertEqual(0, len(DataRegistry.objects.accessible_to_domain("A", has_grants=True)))