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)