def test_get_accessible_slug(self):
create_registry_for_test(self.user, self.domain, [Invitation('A')], name="reg1")
create_registry_for_test(self.user, self.domain, [Invitation('A')], name="reg2")
self.assertEqual(
{"reg1"},
{reg.slug for reg in DataRegistry.objects.accessible_to_domain('A', slug="reg1")}
)
def test_get_accessible(self):
create_registry_for_test(self.user, self.domain, [Invitation('A')], name="reg1")
create_registry_for_test(self.user, self.domain, [Invitation('A')], name="reg2")
self.assertEqual(
{"reg1", "reg2"},
{reg.slug for reg in DataRegistry.objects.accessible_to_domain('A')}
)
# no invitation
self.assertEqual(0, len(DataRegistry.objects.accessible_to_domain('B')))
def test_visible_to_domain(self):
invitations = [Invitation('A'), Invitation('B'), Invitation('C')]
registries = [
self.active,
self.inactive,
create_registry_for_test(self.user, self.domain, invitations),
create_registry_for_test(self.user, "other", [Invitation(self.domain, accepted=False)]),
]
visible = DataRegistry.objects.visible_to_domain(self.domain)
self.assertEqual({r.name for r in registries}, {v.name for v in visible})
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.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_participating_domains(self):
invitations = [
Invitation('A'),
Invitation('B', accepted=False),
Invitation('C', rejected=True)
]
registry = create_registry_for_test(self.user, self.domain, invitations)
domains = registry.get_participating_domains()
self.assertEqual({self.domain, 'A'}, domains)
def setUp(self):
self.registry = create_registry_for_test(self.user,
self.domain,
invitations=[
Invitation(
"A",
accepted=False,
rejected=False),
])
self.helper = DataRegistryCrudHelper(self.domain, self.registry.slug,
self.user)
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 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 = '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().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 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 setUpClass(cls):
super(RegistryDataSourceConfigurationDbTest, cls).setUpClass()
cls.user = create_user("admin", "123")
cls.owning_domain = 'foo_bar'
cls.registry = create_registry_for_test(cls.user,
cls.owning_domain,
invitations=[
Invitation('foo'),
Invitation('bar'),
],
name='foo_bar')
for domain, table in [('foo', 'foo1'), ('foo', 'foo2'),
('bar', 'bar1')]:
RegistryDataSourceConfiguration(
domain=domain,
table_id=table,
referenced_doc_type='CommCareCase',
registry_slug=cls.registry.slug).save()
def test_builder_for_registry(self):
case_type_for_registry = CaseType(domain=self.domain,
name='registry_prop',
fully_generated=True)
case_type_for_registry.save()
CaseProperty(case_type=case_type_for_registry,
name='registry_property',
deprecated=False,
data_type='plain',
group='').save()
user = create_user("admin", "123")
registry = create_registry_for_test(user,
self.domain,
invitations=[
Invitation('foo',
accepted=True),
Invitation('user-reports',
accepted=True),
],
name='registry')
registry_data_source = get_sample_registry_data_source(
registry_slug=registry.slug)
registry_data_source.save()
registry.schema = RegistrySchemaBuilder(["registry_prop"]).build()
registry.save()
builder = RegistryCaseDataSourceHelper(self.domain, registry.slug,
'case',
case_type_for_registry.name)
expected_property_names = [
'closed', 'closed_on', 'registry_property', 'computed/owner_name',
'computed/user_name', 'commcare_project'
]
self.assertEqual(expected_property_names,
list(builder.data_source_properties.keys()))
registry_prop = builder.data_source_properties['registry_property']
self.assertEqual('registry_property', registry_prop.get_id())
self.assertEqual('registry property', registry_prop.get_text())
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)))
def test_check_ownership(self):
registry = create_registry_for_test(self.user, self.domain)
registry.check_ownership(self.domain)
with self.assertRaises(RegistryAccessDenied):
registry.check_ownership('not the owner')
def test_get_accessible_inactive(self):
registry = create_registry_for_test(self.user, self.domain, [Invitation('A')])
registry.deactivate(self.user)
self.assertEqual(0, len(DataRegistry.objects.accessible_to_domain('A')))
def setUpTestData(cls):
cls.user = create_user("marg", "hairspray")
cls.registry = create_registry_for_test(
cls.user, cls.domain, invitations=[Invitation(cls.invited_domain)])
cls.registry.schema = RegistrySchemaBuilder(
["grandparent", "parent", "child", "extension"]).build()
cls.registry.save()
cls.helper = DataRegistryHelper(cls.domain, cls.registry.slug)
"""
springfield <--ext--
mona <-------
abraham(closed) <------- homer <------- bart
<--ext-- beer
"""
cls.host_case_id = 'springfield'
cls.grand_parent_case_id = 'mona'
cls.grand_parent_case_id_closed = 'abraham'
cls.parent_case_id = 'homer'
cls.child_case_id = 'bart'
cls.extension_case_id = 'beer'
host_case = CaseStructure(
case_id=cls.host_case_id,
attrs={
'create': True,
'case_type': 'town'
},
)
grand_parent_case = CaseStructure(
case_id=cls.grand_parent_case_id,
attrs={
'create': True,
'case_type': 'grandparent'
},
)
grand_parent_case_closed = CaseStructure(
case_id=cls.grand_parent_case_id_closed,
attrs={
'create': True,
'case_type': 'grandparent',
'close': True
},
)
parent_case = CaseStructure(
case_id=cls.parent_case_id,
attrs={
'create': True,
'case_type': 'parent'
},
indices=[
CaseIndex(grand_parent_case, identifier='mother'),
CaseIndex(grand_parent_case_closed, identifier='father'),
CaseIndex(host_case,
identifier='host',
relationship='extension'),
],
)
child_case = CaseStructure(
case_id=cls.child_case_id,
attrs={
'create': True,
'case_type': 'child'
},
indices=[CaseIndex(parent_case, identifier='parent')],
)
extension_case = CaseStructure(case_id=cls.extension_case_id,
attrs={
'create': True,
'case_type': 'extension'
},
indices=[
CaseIndex(parent_case,
identifier='host',
relationship='extension')
],
walk_related=False)
cls.cases = CaseFactory(cls.domain).create_or_update_cases(
[child_case, extension_case])
# create some cases in the 'invited domain'
cls.invited_domain_parent_id = "alternate homer"
cls.invited_domain_child_id = "alternate bart"
invited_domain_parent = CaseStructure(
case_id=cls.invited_domain_parent_id,
attrs={
'create': True,
'case_type': 'parent'
},
)
cls.invited_domain_cases = CaseFactory(
cls.domain).create_or_update_cases([
CaseStructure(
case_id=cls.invited_domain_child_id,
attrs={
'create': True,
'case_type': 'child'
},
indices=[
CaseIndex(invited_domain_parent,
identifier='host',
relationship='extension')
],
)
])
def test_get_accessible_rejected(self):
create_registry_for_test(self.user, self.domain, [Invitation('A', rejected=True)])
self.assertEqual(0, len(DataRegistry.objects.accessible_to_domain('A')))
def test_get_accessible_accepted_then_rejected(self):
invitations = [
Invitation('A', accepted=True, rejected=True), # accepted and later rejected
]
create_registry_for_test(self.user, self.domain, invitations)
self.assertEqual(0, len(DataRegistry.objects.accessible_to_domain('A')))
