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 setUpClass(cls):
super().setUpClass()
cls.user = create_user("admin", "123")
CaseSearchConfig.objects.create(domain=cls.domain, enabled=True)
household_1 = str(uuid.uuid4())
case_blocks = [
CaseBlock(
case_id=household_1,
case_type='household',
case_name="Villanueva",
create=True,
)
]
case_blocks.extend([
CaseBlock(
case_id=str(uuid.uuid4()),
case_type='person',
case_name=name,
create=True,
update=properties,
index={
'parent': IndexAttrs('household', household_id, 'child')
} if household_id else None,
) for name, properties, household_id in [
("Jane", {
"family": "Villanueva"
}, household_1),
("Xiomara", {
"family": "Villanueva"
}, household_1),
("Alba", {
"family": "Villanueva"
}, household_1),
("Rogelio", {
"family": "de la Vega"
}, household_1),
("Jane", {
"family": "Ramos"
}, None),
]
])
case_search_es_setup(cls.domain, case_blocks)
cls.factory = AppFactory(domain=cls.domain)
module, form = cls.factory.new_basic_module('person', 'person')
module.search_config = CaseSearch(
properties=[CaseSearchProperty(name='name')])
module.case_details.short.columns = [
DetailColumn(format='plain',
field=field,
header={'en': field},
model='person') for field in ['name', 'parent/name']
]
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 create(cls, domain, username, password, email=None, uuid='', date='', **kwargs):
django_user = create_user(username, password=password, email=email)
if uuid:
if not re.match(r'[\w-]+', uuid):
raise cls.InvalidID('invalid id %r' % uuid)
couch_user = cls(_id=uuid)
else:
couch_user = cls()
if date:
couch_user.created_on = force_to_datetime(date)
else:
couch_user.created_on = datetime.utcnow()
couch_user.sync_from_django_user(django_user)
return couch_user
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 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 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 setUpTestData(cls):
cls.user = create_user("admin", "123")
def setUpTestData(cls):
cls.user = create_user("admin", "123")
cls.active = DataRegistry.objects.create(domain=cls.domain, name="active")
cls.inactive = DataRegistry.objects.create(domain=cls.domain, name="inactive", is_active=False)
