def setUp(self): """ Two groups A and B, with users A1, A2 and B1, B2 respectively, and supervisor X who belongs to both. """ self.domain = "test-domain" create_domain(self.domain) password = "******" def create_user(username): return CommCareUser.create(self.domain, format_username(username, self.domain), password) def create_group(name, *users): group = Group(users=[user.user_id for user in users], name=name, domain=self.domain, case_sharing=True) group.save() return group self.userX = create_user("X") self.userA1 = create_user("A1") self.userA2 = create_user("A2") self.userB1 = create_user("B1") self.userB2 = create_user("B2") self.groupA = create_group("A", self.userX, self.userA1, self.userA2) self.groupB = create_group("B", self.userX, self.userB1, self.userB2)
def setUp(self): self.case_ids = {'c1': 10, 'c2': 30, 'c3': 50} self.section_ids = {'s1': 2, 's2': 9} self.product_ids = {'p1': 1, 'p2': 3, 'p3': 5} self.domain = self._get_name_for_domain() create_domain(self.domain) SQLProduct.objects.bulk_create([ SQLProduct(product_id=id) for id in self.product_ids ]) transactions_flat = [] self.transactions = {} for case, c_bal in self.case_ids.items(): for section, s_bal in self.section_ids.items(): for product, p_bal in self.product_ids.items(): bal = c_bal + s_bal + p_bal transactions_flat.append( STrans( case_id=case, section_id=section, product_id=product, action='soh', quantity=bal ) ) self.transactions.setdefault(case, {}).setdefault(section, {})[product] = bal self.new_stock_report, self.form = self.create_report(transactions_flat) self.new_stock_report.create_models(self.domain)
def setUp(self): create_domain(self.domain) self._clearData() password = "******" def create_user(username): return CommCareUser.create(self.domain, format_username(username, self.domain), password) self.users = [create_user(id) for id in self.user_ids] def create_case_set(user, child_user): # for each user we need one open and one closed case of # two different types. for type in self.case_types: c1 = _create_case(user, type, close=False) # open _create_case(user, type, close=True) # closed # child _create_case(child_user, _child_case_type(type), close=False, index={'parent': ('parent-case', c1._id)}) for i, user in enumerate(self.users): create_case_set(user, self.users[(i + 1) % len(self.users)]) self.test_type = self.case_types[0] self.test_user_id = self.users[0]._id
def setUp(self): create_domain(self.domain) self.password = "******" def create_user(username): return CommCareUser.create(self.domain, format_username(username, self.domain), self.password) self.users = [create_user(id) for id in self.user_ids] def create_case_set(user, child_user): # for each user we need one open and one closed case of # two different types. for type in self.case_types: c1 = _create_case(user, type, close=False) # open _create_case(user, type, close=True) # closed # child _create_case(child_user, _child_case_type(type), close=False, index={'parent': ('parent-case', c1._id)}) for i, user in enumerate(self.users): create_case_set(user, self.users[(i + 1) % len(self.users)]) self.test_type = self.case_types[0] self.test_user_id = self.users[0]._id update_toggle_cache(toggles.CLOUDCARE_CACHE.slug, TEST_DOMAIN, True, toggles.NAMESPACE_DOMAIN)
def setUp(self): self.domain = 'test-domain' create_domain(self.domain) self.app = Application.new_app(self.domain, "TestApp", application_version=APP_V1) for i in range(3): module = self.app.new_module("Module%d" % i, "en") for j in range(3): self.app.new_form(module.id, name="Form%s-%s" % (i,j), attachment=self.xform_str, lang="en") module = self.app.get_module(i) detail = module.get_detail("ref_short") detail.append_column( DetailColumn(name={"en": "test"}, model="case", field="test", format="plain", enum={}) ) detail.append_column( DetailColumn(name={"en": "age"}, model="case", field="age", format="years-ago", enum={}) ) self.app.save() self.build1 = {'version': '1.2.dev', 'build_number': 7106} self.build2 = {'version': '2.7.0', 'build_number': 20655} def add_build(version, build_number): path = os.path.join(os.path.dirname(__file__), "jadjar") jad_path = os.path.join(path, 'CommCare_%s_%s.zip' % (version, build_number)) CommCareBuild.create_from_zip(jad_path, version, build_number) add_build(**self.build1) add_build(**self.build2)
def setUp(self): self.domain = "test-domain" create_domain(self.domain) self.user = CommCareUser.create(self.domain, 'reconciliation-test', 'password') self.user.save() self.other_user = CommCareUser.create(self.domain, 'reconciliation-test-other', 'password') self.other_user.save()
def setUpClass(cls): create_domain(cls.domain) toggles.MOBILE_UCR.set(cls.domain, True, toggles.NAMESPACE_DOMAIN) cls.user = CommCareUser.create(cls.domain, 'john_doe', 's3cr3t') cls.app1 = Application.new_app(cls.domain, 'Test App 1', application_version=APP_V2) cls.report_config1 = get_sample_report_config() cls.report_config1.save() report_app_config = { 'report_id': cls.report_config1.get_id, 'uuid': '123456' } module = cls.app1.add_module(ReportModule.new_module('Reports', None)) module.report_configs = [ReportAppConfig.wrap(report_app_config)] cls.app1.save() cls.app2 = Application.new_app(cls.domain, 'Test App 2', application_version=APP_V2) cls.report_config2 = get_sample_report_config() cls.report_config2.save() report_app_config = { 'report_id': cls.report_config2.get_id, 'uuid': 'abcdef' } module = cls.app2.add_module(ReportModule.new_module('Reports', None)) module.report_configs = [ReportAppConfig.wrap(report_app_config)] cls.app2.save() cls.app3 = Application.new_app(cls.domain, 'Test App 3', application_version=APP_V2) cls.app3.save()
def setUp(self): self.domain = _get_name_for_domain() self.ledger_processor = FormProcessorInterface(domain=self.domain).ledger_processor create_domain(self.domain) transactions_flat = [] self.transactions = {} for case, c_bal in self.case_ids.items(): for section, s_bal in self.section_ids.items(): for product, p_bal in self.product_ids.items(): bal = c_bal + s_bal + p_bal transactions_flat.append( StockTransactionHelper( case_id=case, section_id=section, product_id=product, action='soh', quantity=bal, timestamp=datetime.utcnow() ) ) self.transactions.setdefault(case, {}).setdefault(section, {})[product] = bal self.new_stock_report, self.form = self.create_report(transactions_flat) self._create_models_for_stock_report_helper(self.form, self.new_stock_report)
def setUp(self): create_domain(self.domain) self.couch_user = CommCareUser.create(self.domain, self.username, self.password) userID = self.couch_user.user_id self.couch_user.first_name = self.first_name self.couch_user.last_name = self.last_name self.couch_user.save()
def setUpClass(cls): delete_all_users() create_domain(cls.domain) toggles.MOBILE_UCR.set(cls.domain, True, toggles.NAMESPACE_DOMAIN) cls.user = create_restore_user(cls.domain) cls.app1 = Application.new_app(cls.domain, "Test App 1") cls.report_config1 = get_sample_report_config() cls.report_config1.domain = cls.domain cls.report_config1.save() report_app_config = {"report_id": cls.report_config1.get_id, "uuid": "123456"} module = cls.app1.add_module(ReportModule.new_module("Reports", None)) module.report_configs = [ReportAppConfig.wrap(report_app_config)] cls.app1.save() cls.app2 = Application.new_app(cls.domain, "Test App 2") cls.report_config2 = get_sample_report_config() cls.report_config2.domain = cls.domain cls.report_config2.save() report_app_config = {"report_id": cls.report_config2.get_id, "uuid": "abcdef"} module = cls.app2.add_module(ReportModule.new_module("Reports", None)) module.report_configs = [ReportAppConfig.wrap(report_app_config)] cls.app2.save() cls.app3 = Application.new_app(cls.domain, "Test App 3") cls.app3.save()
def setUpClass(cls): load_data() create_domain(DOMAIN) cls.couch_user = WebUser.create(None, "report_test", "foobar") cls.couch_user.add_domain_membership(DOMAIN, is_admin=True) cls.couch_user.save() cls.factory = RequestFactory()
def setUpClass(cls): cls.build1 = {'version': '1.2.dev', 'build_number': 7106} cls.build2 = {'version': '2.7.0', 'build_number': 20655} add_build(**cls.build1) add_build(**cls.build2) cls.domain = 'test-domain' create_domain(cls.domain)
def test_test_local_domain_sql_backend_override_overrides(self): domain_name = uuid.uuid4().hex create_domain(domain_name) self.assertFalse(should_use_sql_backend(domain_name)) set_local_domain_sql_backend_override(domain_name) self.assertTrue(should_use_sql_backend(domain_name)) clear_local_domain_sql_backend_override(domain_name) self.assertFalse(should_use_sql_backend(domain_name))
def setUp(self): self.client = Client() self.domain = "test-domain" create_domain(self.domain) self.case_repeater = CaseRepeater(domain=self.domain, url="case-repeater-url", version=V1) self.case_repeater.save() self.form_repeater = FormRepeater(domain=self.domain, url="form-repeater-url") self.form_repeater.save() self.log = [] self.post_xml(xform_xml)
def setUp(self): self.client = Client() self.domain = "test-domain" create_domain(self.domain) self.case_repeater = CaseRepeater(domain=self.domain, url='case-repeater-url', version=V1, next_check=datetime.utcnow() - timedelta(seconds=5)) self.case_repeater.save() self.form_repeater = FormRepeater(domain=self.domain, url='form-repeater-url', next_check=datetime.utcnow() - timedelta(seconds=10)) self.form_repeater.save() self.log = [] self.post_xml(xform_xml)
def setUp(self): create_domain(self.domain) couch_user = CommCareUser.create(self.domain, self.username, self.password) userID = couch_user.user_id couch_user.first_name = self.first_name couch_user.last_name = self.last_name couch_user.save() self.sm = SuccessMessage(self.message, userID, tz=self.tz) c = Client() app = Application.new_app(self.domain, "Test App", application_version=APP_V1) app.add_module(Module.new_module("Test Module", "en")) form = app.new_form(0, "Test Form", "en") form.xmlns = self.xmlns app.success_message = {"en": self.message} app.save() # hack: prime the view once so the success message takes even though we use stale queries in submissions Application.get_db().view('exports_forms/by_xmlns', limit=1).one() def fake_form_submission(userID=userID, username=self.username, xmlns=self.xmlns, time=None): submission = submission_template % { "userID": userID, "username": username, "xmlns": xmlns } f = StringIO(submission.encode('utf-8')) f.name = "tempfile.xml" kwargs = dict(HTTP_X_SUBMIT_TIME=json_format_datetime(time)) if time else {} response = c.post("/a/{self.domain}/receiver/".format(self=self), { 'xml_submission_file': f, }, **kwargs) return response self.num_forms_today = 0 self.num_forms_this_week = 0 now = datetime.utcnow() tznow = now + self.tz week_start = tznow - timedelta(days=tznow.weekday()) week_start = datetime(week_start.year, week_start.month, week_start.day) - self.tz day_start = datetime(tznow.year, tznow.month, tznow.day) - self.tz spacing = 6 for h in xrange((24/spacing)*8): time = now-timedelta(hours=spacing*h) response = fake_form_submission(time=time) if time > week_start: self.num_forms_this_week += 1 if time > day_start: self.num_forms_today += 1 self.assertEqual( response.content, get_simple_response_xml(("Thanks {self.first_name} ({self.first_name} {self.last_name})! " "You have submitted {self.num_forms_today} forms today " "and {self.num_forms_this_week} forms since Monday.").format(self=self), nature=ResponseNature.SUBMIT_SUCCESS) )
def setUp(self): self.domain = "test-domain" create_domain(self.domain) self.repeater = FormRepeater( domain=self.domain, url='form-repeater-url', version=V1, format='new_format' ) self.repeater.save()
def setUp(self): super(IgnoreDocumentTest, self).setUp() self.domain = "test-domain" create_domain(self.domain) self.repeater = FormRepeater( domain=self.domain, url='form-repeater-url', format='new_format' ) self.repeater.save()
def setUpClass(cls): cls.build1 = {"version": "1.2.dev", "build_number": 7106} cls.build2 = {"version": "2.7.0", "build_number": 20655} add_build(**cls.build1) add_build(**cls.build2) cls.domain = "test-domain" create_domain(cls.domain) with codecs.open(os.path.join(os.path.dirname(__file__), "data", "itext_form.xml"), encoding="utf-8") as f: cls.xform_str = f.read()
def setUp(self): self.domain = "test-domain" create_domain(self.domain) self.post_xml(xform_xml, self.domain) self.repeater = CaseRepeater( domain=self.domain, url='case-repeater-url', version=V1, format='new_format' ) self.repeater.save()
def test_domain_reindexer(self): delete_all_domains() ensure_index_deleted(DOMAIN_INDEX) name = 'reindex-test-domain' create_domain(name) call_command('ptop_reindexer_v2', index='domain', cleanup=True, noinput=True) results = DomainES().run() self.assertEqual(1, results.total, results.hits) domain_doc = results.hits[0] self.assertEqual(name, domain_doc['name']) self.assertEqual('Domain', domain_doc['doc_type']) delete_es_index(DOMAIN_INDEX)
def setUp(self): super(TestRepeaterFormat, self).setUp() self.domain = "test-domain" create_domain(self.domain) self.post_xml(self.xform_xml, self.domain) self.repeater = CaseRepeater( domain=self.domain, url='case-repeater-url', format='new_format', ) self.repeater.save()
def setUpClass(cls): super(AppManagerTest, cls).setUpClass() cls.build1 = {'version': '1.2.dev', 'build_number': 7106} cls.build2 = {'version': '2.7.0', 'build_number': 20655} add_build(**cls.build1) add_build(**cls.build2) cls.domain = 'test-domain' create_domain(cls.domain) with codecs.open(os.path.join(os.path.dirname(__file__), "data", "very_simple_form.xml"), encoding='utf-8') as f: cls.xform_str = f.read()
def setUpClass(cls): super(CaseAPITest, cls).setUpClass() create_domain(cls.domain) cls.password = "******" def create_user(username): return CommCareUser.create(cls.domain, format_username(username, cls.domain), cls.password) cls.users = [create_user(id) for id in cls.user_ids] update_toggle_cache(toggles.CLOUDCARE_CACHE.slug, TEST_DOMAIN, True, toggles.NAMESPACE_DOMAIN)
def setUpClass(cls): w_username = "******" w_email = "*****@*****.**" w2_username = "******" w2_email = "*****@*****.**" cc_username = "******" password = "******" cls.domain_obj = create_domain(cls.domain) cls.nodomain_obj = create_domain('nodomain') cls.project = Domain(name=cls.domain) cls.project.save() cls.webuser = WebUser.create(cls.domain, w_username, password, w_email) cls.webuser2 = WebUser.create('nodomain', w2_username, password, w2_email) cls.ccuser = CommCareUser.create(cls.domain, cc_username, password)
def setUp(self): self.domain = 'test' self.username = "******" self.password = "******" self.domain_obj = create_domain(self.domain) self.commcare_user = CommCareUser.create(self.domain, self.username, self.password) self.commcare_user.save()
def setUpClass(cls): cls.domain_name = "test-domain" cls.domain_obj = create_domain(cls.domain_name) cls.location_type = LocationType( domain=cls.domain_name, name="state", code="state", ) cls.location_type.save() cls.location = SQLLocation( domain="test-domain", name="Braavos", location_type=cls.location_type ) cls.location.save() cls.unique_id = cls.location.location_id cls.spec = { "type": "location_type_name", "location_id_expression": { "type": "property_name", "property_name": "_id" } } cls.expression = ExpressionFactory.from_spec(cls.spec)
def setUpModule(): if isinstance(Domain.get_db(), Mock): # needed to skip setUp for javascript tests thread on Travis return _call_center_domain_mock = mock.patch( 'corehq.apps.callcenter.data_source.call_center_data_source_configuration_provider' ) _call_center_domain_mock.start() domain = create_domain('champ-cameroon') with override_settings(SERVER_ENVIRONMENT='production'): configs = StaticDataSourceConfiguration.by_domain(domain.name) adapters = [get_indicator_adapter(config) for config in configs] for adapter in adapters: adapter.build_table() engine = connection_manager.get_engine(UCR_ENGINE_ID) metadata = sqlalchemy.MetaData(bind=engine) metadata.reflect(bind=engine, extend_existing=True) path = os.path.join(os.path.dirname(__file__), 'fixtures') for file_name in os.listdir(path): with open(os.path.join(path, file_name), encoding='utf-8') as f: table_name = get_table_name(domain.name, file_name[:-4]) table = metadata.tables[table_name] postgres_copy.copy_from( f, table, engine, format='csv' if six.PY3 else b'csv', null='' if six.PY3 else b'', header=True ) _call_center_domain_mock.stop()
def setUp(self): domain = 'test' username = "******" password = "******" self.domain_obj = create_domain(domain) self.web_user = WebUser.create(domain, username, password) self.web_user.save()
def setUpClass(cls): cls.session_helper = connection_manager.get_session_helper(settings.SQL_REPORTING_DATABASE_URL) cls.engine = cls.session_helper.engine cls.domain = create_domain(TEST_DOMAIN) cls.region_type = LocationType.objects.create(domain=TEST_DOMAIN, name=u'Région') cls.district_type = LocationType.objects.create(domain=TEST_DOMAIN, name=u'District') cls.pps_type = LocationType.objects.create(domain=TEST_DOMAIN, name=u'PPS') cls.region = Location(domain=TEST_DOMAIN, name='Test region', location_type=u'Région') cls.region.save() cls.district = Location( domain=TEST_DOMAIN, name='Test district', location_type=u'District', parent=cls.region ) cls.district.save() cls.pps = Location(domain=TEST_DOMAIN, name='Test PPS', location_type=u'PPS', parent=cls.district) cls.pps.save() cls.mobile_worker = create_mobile_worker( domain=TEST_DOMAIN, username='******', password='******', phone_number='777777' ) cls.mobile_worker.location_id = cls.pps.get_id cls.mobile_worker.save() cls.product = Product(_id=u'81457658bdedd663f8b0bdadb19d8f22', name=u'ASAQ Nourisson', domain=TEST_DOMAIN) cls.product2 = Product( _id=u'81457658bdedd663f8b0bdadb19d83d8', name=u'ASAQ Petit Enfant', domain=TEST_DOMAIN ) cls.product.save() cls.product2.save()
def setUpClass(cls): # Create domain cls.domain = create_domain(TEST_DOMAIN) cls.domain.call_center_config = cls.get_call_center_config() cls.domain.save() # Create user cls.user = CommCareUser.create(TEST_DOMAIN, 'user1', '***') # Create locations LocationType.objects.get_or_create( domain=cls.domain.name, name=LOCATION_TYPE, ) cls.root_location = make_loc( 'root_loc', type=LOCATION_TYPE, domain=TEST_DOMAIN ) cls.child_location = make_loc( 'child_loc', type=LOCATION_TYPE, domain=TEST_DOMAIN, parent=cls.root_location ) cls.grandchild_location = make_loc( 'grandchild_loc', type=LOCATION_TYPE, domain=TEST_DOMAIN, parent=cls.child_location )
def setUp(self): self.old_domain_obj = create_domain(self.old_domain) self.mobile_worker = CommCareUser.create( self.old_domain, '*****@*****.**', '123') self.web_user = WebUser.create(self.old_domain, '*****@*****.**', '***', is_active=True) self.location_types, self.locations = setup_locations_and_types( self.old_domain, location_types=["state", "county", "city"], stock_tracking_types=[], locations=[ ('Massachusetts', [('Middlesex', [ ('Cambridge', []), ('Somerville', []), ]), ('Suffolk', [ ('Boston', []), ])]), ('California', [ ('Los Angeles', []), ]), ])
def setUp(self): super(CallCenterTestOpenedClosed, self).setUp() self.domain = create_domain(self.domain_name) self.supervisor = CommCareUser.create(self.domain_name, 'supervisor@' + self.domain_name, '***') self.domain.call_center_config.enabled = True self.domain.call_center_config.case_owner_id = self.supervisor.get_id self.domain.call_center_config.case_type = 'cc_flw' self.domain.save() self.user = CommCareUser.create(self.domain_name, 'user@' + self.domain_name, '***') sync_call_center_user_case(self.user) load_data(self.domain_name, self.user.user_id, case_opened_by='not me', case_closed_by='not me') # create one case of each type so that we get the indicators where there is no data for the period create_cases_for_types(self.domain_name, ['person', 'dog'])
def setUp(self): super(CallCenterSupervisorGroupTest, self).setUp() self.domain = create_domain(self.domain_name) self.supervisor = CommCareUser.create(self.domain_name, 'supervisor@' + self.domain_name, '***') self.supervisor_group = Group(domain=self.domain_name, name='supervisor group', case_sharing=True, users=[self.supervisor.get_id]) self.supervisor_group.save() self.domain.call_center_config.enabled = True self.domain.call_center_config.case_owner_id = self.supervisor_group.get_id self.domain.call_center_config.case_type = 'cc_flw' self.domain.save() self.user = CommCareUser.create(self.domain_name, 'user@' + self.domain_name, '***') sync_call_center_user_case(self.user) load_data(self.domain_name, self.user.user_id)
def setUpClass(cls): super().setUpClass() cls.domain = 'test-domain' cls.domain_obj = create_domain(cls.domain) cls.addClassCleanup(cls.domain_obj.delete) cls.definition = CustomDataFieldsDefinition( domain=cls.domain, field_type=UserFieldsView.field_type) cls.definition.save() cls.definition.set_fields([ Field( slug='conflicting_field', label='Conflicting Field', choices=['yes', 'no'], ), ]) cls.definition.save() cls.profile = CustomDataFieldsProfile( name='character', fields={'conflicting_field': 'yes'}, definition=cls.definition, ) cls.profile.save()
def test_reverted_domain_pillow_deletion(self): domain_name = 'domain-pillow-delete' with drop_connected_signals(commcare_domain_post_save): domain = create_domain(domain_name) # send to kafka since = get_topic_offset(topics.DOMAIN) publish_domain_saved(domain) # send to elasticsearch pillow = get_domain_kafka_to_elasticsearch_pillow() pillow.process_changes(since=since, forever=False) self.elasticsearch.indices.refresh(self.index_info.index) # verify there self._verify_domain_in_es(domain_name) domain_obj = Domain.get_by_name(domain_name) domain_obj.doc_type = 'Domain-DUPLICATE' domain_obj.save() # send to kafka since = get_topic_offset(topics.DOMAIN) publish_domain_saved(domain_obj) # undelete domain_obj = Domain.get_by_name(domain_name) domain_obj.doc_type = 'Domain' domain_obj.save() # process pillow changes pillow = get_domain_kafka_to_elasticsearch_pillow() pillow.process_changes(since=since, forever=False) self.elasticsearch.indices.refresh(self.index_info.index) # confirm domain still exists self._verify_domain_in_es(domain_name)
def setUpClass(cls): super(TestUsersByLocation, cls).setUpClass() cls.domain = 'test-domain' cls.domain_obj = create_domain(cls.domain) bootstrap_location_types(cls.domain) def make_user(name, location): user = CommCareUser.create(cls.domain, name, 'password') user.set_location(location) return user cls.meereen = make_loc('meereen', type='outlet', domain=cls.domain) cls.pentos = make_loc('pentos', type='outlet', domain=cls.domain) cls.varys = make_user('Varys', cls.pentos) cls.tyrion = make_user('Tyrion', cls.meereen) cls.daenerys = make_user('Daenerys', cls.meereen) cls.george = WebUser.create( cls.domain, username="******", password='******' ) cls.george.set_location(cls.domain, cls.meereen)
def setUpClass(cls): super(CustomCriteriaTestCase, cls).setUpClass() cls.domain_obj = create_domain(cls.domain) location_type_structure = [ LocationTypeStructure( SUPERVISOR_LOCATION_TYPE_CODE, [LocationTypeStructure(AWC_LOCATION_TYPE_CODE, [])]) ] location_structure = [ LocationStructure('LS1', SUPERVISOR_LOCATION_TYPE_CODE, [ LocationStructure('AWC1', AWC_LOCATION_TYPE_CODE, []), ]) ] cls.loc_types = setup_location_types_with_structure( cls.domain, location_type_structure) cls.locs = setup_locations_with_structure(cls.domain, location_structure) cls.ls = cls._make_user('ls', cls.locs['LS1']) cls.aww = cls._make_user('aww', cls.locs['AWC1'])
def setUpClass(cls): super().setUpClass() cls.elasticsearch = get_es_new() initialize_index_and_mapping(cls.elasticsearch, USER_INDEX_INFO) cls.domain = 'test-user-es' cls.domain_obj = create_domain(cls.domain) with sync_users_to_es(): cls._create_mobile_worker('stark', metadata={ 'sigil': 'direwolf', 'seat': 'Winterfell' }) cls._create_mobile_worker('lannister', metadata={ 'sigil': 'lion', 'seat': 'Casterly Rock' }) cls._create_mobile_worker('targaryen', metadata={ 'sigil': 'dragon', 'false_sigil': 'direwolf' }) cls.elasticsearch.indices.refresh(USER_INDEX)
def setUpClass(cls): cls.domain_obj = create_domain(cls.domain) report = ReportConfiguration(domain=cls.domain) bootstrap_location_types(cls.domain) location_code_name_pairs = ( ('cambridge_ma', 'Cambridge'), ('somerville_ma', 'Somerville'), ('boston_ma', 'Boston'), ) cls.locations = [] choices = [] for location_code, location_name in location_code_name_pairs: location = cls.make_location(location_code, location_name) cls.locations.append(location) choices.append( SearchableChoice( location.location_id, location.sql_location.display_name, searchable_text=[location_code, location_name])) choices.sort(key=lambda choice: choice.display) cls.choice_provider = LocationChoiceProvider(report, None) cls.static_choice_provider = StaticChoiceProvider(choices)
def setUpClass(cls): super().setUpClass() cls.domain_obj = create_domain(DOMAIN) cls.setup_subscription(DOMAIN, SoftwarePlanEdition.PRO) url = 'https://www.example.com/api/' conn = ConnectionSettings.objects.create(domain=DOMAIN, name=url, url=url) cls.repeater = FormRepeater( domain=DOMAIN, connection_settings_id=conn.id, include_app_id_param=False, ) cls.repeater.save(sync_to_sql=False) cls.sql_repeater = SQLFormRepeater( domain=DOMAIN, repeater_id=cls.repeater.get_id, connection_settings=conn, format='form_xml', ) cls.sql_repeater.save(sync_to_couch=False) cls.instance_id = str(uuid4()) post_xform(cls.instance_id)
def setUp(self): super(FormExportTest, self).setUp() self.app_id = 'kasdlfkjsldfkjsdlkjf' self.domain_name = 'form-export-test' self.domain = create_domain(self.domain_name) self.username = '******' self.couch_user = CommCareUser.create(self.domain_name, self.username, password='******') self.couch_user.save() self.client = Client() self.client.login(username=self.couch_user.username, password='******') self.url = reverse("receiver_post_with_app_id", args=[self.domain_name, self.app_id]) self.custom_export = FormExportSchema.wrap({ 'type': 'form', 'app_id': self.app_id, 'default_format': Format.JSON, 'index': json.dumps([self.domain_name, XMLNS]), 'tables': [{ 'index': '#', 'display': 'Export', 'columns': [{'index': 'form.name', 'display': 'Name'}], }] })
def setUpModule(): if _skip_if_nose_attr(): return if settings.USE_PARTITIONED_DATABASE: print( '============= WARNING: not running test setup because settings.USE_PARTITIONED_DATABASE is True.' ) return global _stop_transaction_exemption _stop_transaction_exemption = exempt_from_test_transactions([ "icds-ucr", "icds-ucr-citus", ]) domain = create_domain('icds-cas') setup_location_hierarchy(domain.name) with override_settings(SERVER_ENVIRONMENT='icds', STATIC_DATA_SOURCE_PROVIDERS=[]): with flag_enabled('ICDS_LOCATION_REASSIGNMENT_AGG'): setup_tables_and_fixtures(domain.name) aggregate_state_form_data() try: with mock.patch( 'custom.icds_reports.tasks.update_aggregate_locations_tables' ): move_ucr_data_into_aggregation_tables(datetime( 2017, 5, 28), intervals=2) build_bihar_api() build_incentive_report(agg_date=datetime(2017, 5, 28)) except Exception as e: print(e) tearDownModule() raise
def setUp(self): self.domain = create_domain(DOMAIN) self.user = CommCareUser.create(DOMAIN, USERNAME, PASSWORD) initialize_index_and_mapping(get_es_new(), CASE_SEARCH_INDEX_INFO) CaseSearchConfig.objects.get_or_create(pk=DOMAIN, enabled=True) delete_all_cases() self.case_id = uuid4().hex _, [self.case] = post_case_blocks([ CaseBlock( create=True, case_id=self.case_id, case_type=CASE_TYPE, case_name=CASE_NAME, external_id=CASE_NAME, user_id=OWNER_ID, owner_id=OWNER_ID, update={ 'opened_by': OWNER_ID }, ).as_xml() ], {'domain': DOMAIN}) CaseSearchReindexerFactory(domain=DOMAIN).build().reindex() es = get_es_new() es.indices.refresh(CASE_SEARCH_INDEX)
def setUpClass(cls): super().setUpClass() # Set up domains cls.domain = 'state' create_domain(cls.domain) create_domain('county') create_domain('staging') # Set up users cls.master_role = UserRole.create( "state", "role1", permissions=Permissions( view_web_users=True, edit_web_users=False, view_groups=True, edit_groups=False, edit_apps=True, # needed for InternalFixtureResource view_apps=True, )) cls.web_user_admin = WebUser.create('state', 'emma', 'badpassword', None, None, email='*****@*****.**', is_admin=True) cls.web_user_non_admin = WebUser.create('state', 'clementine', 'worsepassword', None, None, email='*****@*****.**') cls.web_user_non_admin.set_role('state', cls.master_role.get_qualified_id()) cls.web_user_non_admin.save() cls.api_key, _ = HQApiKey.objects.get_or_create( user=WebUser.get_django_user(cls.web_user_non_admin)) # Set up permissions create_enterprise_permissions(cls.web_user_admin.username, 'state', ['county'], ['staging'])
def setUpClass(cls): super(UserReindexerTest, cls).setUpClass() create_domain(DOMAIN) ensure_index_deleted(USER_INDEX)
def setUp(self): self.domain = create_domain(self.domain_name) self.domain.two_factor_auth = False self.request = self.create_request(request_url='/account/')
def setUpClass(cls): super(UserPillowTestBase, cls).setUpClass() create_domain(TEST_DOMAIN)
def setUpClass(cls): cls.domain = create_domain(TEST_DOMAIN) cls.couch_user = WebUser.create(None, "report_test", "foobar") cls.couch_user.add_domain_membership(TEST_DOMAIN, is_admin=True) cls.couch_user.save() cls.products = { 'pA': make_product(TEST_DOMAIN, 'prod A', 'pA'), 'pB': make_product(TEST_DOMAIN, 'prod B', 'pB') } test_setup = { 'A': { 'A-a': { 'A-a-1': { 'pA': 4, 'pB': 0 }, 'A-a-2': { 'pB': 3 }, }, 'A-b': { 'A-b-1': { 'pA': 2 } } }, 'B': { 'B-a': { 'B-a-1': { 'pA': 1, 'pB': 1 } } } } cls.sites = {} cls.regions = {} cls.districts = {} for region_name, districts in test_setup.items(): region = make_loc(region_name, type='region') cls.regions[region_name] = region for district_name, sites in districts.items(): district = make_loc(district_name, type='district', parent=region) cls.districts[district_name] = district for site_name, products in sites.items(): site = make_loc(site_name, type='site', parent=district, domain=TEST_DOMAIN) cls.sites[site_name] = (site, products) supply_point = site.linked_supply_point() for p_code, stock in products.items(): prod = cls.products[p_code] StockState.objects.create( section_id='stock', case_id=supply_point.case_id, product_id=prod._id, stock_on_hand=stock, last_modified_date=datetime.utcnow(), )
def setUpClass(cls): super(CallCenterUtilsUserCaseTests, cls).setUpClass() cls.domain = create_domain(TEST_DOMAIN) cls.domain.usercase_enabled = True cls.domain.save()
def setUpClass(cls): super(DBAccessorsTest, cls).setUpClass() cls.domain = 'domain-domain' cls.project = create_domain(cls.domain) cls.db = get_db()
def setUpClass(cls): super(DigestOtaRestoreTest, cls).setUpClass() create_domain(cls.domain) create_domain(cls.wrong_domain) cls.commcare_user = CommCareUser.create(cls.domain, cls.username, cls.password, None, None) cls.web_user = WebUser.create(cls.domain, cls.web_username, cls.password, None, None)
def setUpClass(cls): super(TestSendToHubspot, cls).setUpClass() cls.domain_obj = create_domain(cls.domain) cls.user = WebUser.create(cls.domain, "*****@*****.**", "*****") cls.user.save()
def setUpClass(cls): cls.domain = 'fixture-upload-test' cls.project = create_domain(cls.domain)
def setUpClass(cls): super(TransformDomainForElasticsearchTest, cls).setUpClass() cls.domain = 'domain-transform-test' cls.project = create_domain(cls.domain)
def setUpClass(cls): super(SiteCodeTest, cls).setUpClass() cls.project = create_domain(cls.domain) LocationType(domain=cls.domain, name='type').save()
def setUpClass(cls): super(ReportUtilTests, cls).setUpClass() create_domain(DOMAIN)
def setUpClass(cls): super().setUpClass() cls.project = create_domain(cls.domain)
def setUpClass(cls): create_domain('test-domain') LocationType.objects.create(domain='test-domain', name='test-type')
def setUpClass(cls): cls.domain = uuid.uuid4().hex cls.project = create_domain(cls.domain) cls.user = CommCareUser.create(cls.domain, 'mtest', 'abc') cls.auth_header = _get_auth_header('mtest', 'abc') cls.restore_uri = reverse('ota_restore', args=[cls.domain])