Esempio n. 1
0
    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)
Esempio n. 2
0
    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)
Esempio n. 3
0
    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
Esempio n. 4
0
    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)
Esempio n. 6
0
 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()
Esempio n. 7
0
    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)
Esempio n. 9
0
 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()
Esempio n. 10
0
    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()
Esempio n. 11
0
    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()
Esempio n. 12
0
    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)
Esempio n. 13
0
    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))
Esempio n. 14
0
 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)
Esempio n. 15
0
 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)
            )
Esempio n. 17
0
    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()
Esempio n. 18
0
    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()
Esempio n. 19
0
    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()
Esempio n. 20
0
    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()
Esempio n. 21
0
 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)
Esempio n. 22
0
    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()
Esempio n. 23
0
    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()
Esempio n. 24
0
    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)
Esempio n. 25
0
    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)
Esempio n. 26
0
 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()
Esempio n. 27
0
    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)
Esempio n. 28
0
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()
Esempio n. 29
0
 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()
Esempio n. 30
0
    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()
Esempio n. 31
0
    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
        )
Esempio n. 32
0
 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', []),
             ]),
         ])
Esempio n. 33
0
    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'])
Esempio n. 34
0
    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)
Esempio n. 35
0
    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()
Esempio n. 36
0
    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)
Esempio n. 37
0
    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)
Esempio n. 38
0
    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'])
Esempio n. 39
0
    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)
Esempio n. 41
0
    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)
Esempio n. 42
0
 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'}],
         }]
     })
Esempio n. 43
0
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)
Esempio n. 45
0
    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'])
Esempio n. 46
0
 def setUpClass(cls):
     super(UserReindexerTest, cls).setUpClass()
     create_domain(DOMAIN)
     ensure_index_deleted(USER_INDEX)
Esempio n. 47
0
    def setUp(self):

        self.domain = create_domain(self.domain_name)
        self.domain.two_factor_auth = False
        self.request = self.create_request(request_url='/account/')
Esempio n. 48
0
 def setUpClass(cls):
     super(UserPillowTestBase, cls).setUpClass()
     create_domain(TEST_DOMAIN)
Esempio n. 49
0
    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(),
                        )
Esempio n. 50
0
 def setUpClass(cls):
     super(CallCenterUtilsUserCaseTests, cls).setUpClass()
     cls.domain = create_domain(TEST_DOMAIN)
     cls.domain.usercase_enabled = True
     cls.domain.save()
Esempio n. 51
0
 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)
Esempio n. 53
0
 def setUpClass(cls):
     super(TestSendToHubspot, cls).setUpClass()
     cls.domain_obj = create_domain(cls.domain)
     cls.user = WebUser.create(cls.domain, "*****@*****.**", "*****")
     cls.user.save()
Esempio n. 54
0
 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)
Esempio n. 56
0
 def setUpClass(cls):
     super(SiteCodeTest, cls).setUpClass()
     cls.project = create_domain(cls.domain)
     LocationType(domain=cls.domain, name='type').save()
Esempio n. 57
0
 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])