Пример #1
0
    def test_initial_restore(self, config):
        user_id = str(uuid4())
        case_attrs = {
            'create': True,
            'user_id': user_id,
            'owner_id': user_id,
            'case_type': 'duck',
            'update': {'identity': 'mallard'}
        }
        factory = CaseFactory(
            config.receiver_url,
            domain=config.domain,
            form_extras={
                'user_id': user_id,
            }
        )
        [case_block] = factory.create_or_update_cases([
            CaseStructure(attrs=case_attrs),
        ])

        restore_payload = get_restore_payload(config.restore_url, config.domain, dummy_user(user_id))
        synclog_id = synclog_id_from_restore_payload(restore_payload)
        case_xml = case_block.as_string()
        check_xml_line_by_line(
            dummy_restore_xml(dummy_user(user_id), synclog_id, case_xml=case_xml, items=4),
            restore_payload,
        )
Пример #2
0
    def test_user_restore_with_case(self, testapp, client):
        with testapp.app_context():
            factory = CaseFactory(
                self._get_backend(),
                client,
                domain=DOMAIN,
                case_defaults={
                    'user_id': self.user_id,
                    'owner_id': self.user_id,
                    'case_type': 'duck',
                }
            )
            new_case, = factory.create_or_update_case(
                CaseStructure(self.case_id, attrs={
                    'create': True,
                    'case_name': 'Fish',
                    'update': {'last_name': 'Mooney'}})
            )

        user = dummy_user(self.user_id)
        restore_payload = generate_restore_response(client, DOMAIN, user, self._get_restore_url_snippet())

        synclog = self._get_one_synclog()

        case_xml = xml.get_case_xml(
            new_case, [
                const.CASE_ACTION_CREATE,
                const.CASE_ACTION_UPDATE],
            version=V2)

        check_xml_line_by_line(
            dummy_restore_xml(user, synclog.id, case_xml=case_xml, items=4),
            restore_payload,
        )
Пример #3
0
    def test_get_last_modified_dates(self, testapp, client):
        """
        I was having a little trouble manufacturing a scenario that would call
        this Dao.get_last_modified_dates() with meaningful parameters, so I'm
        testing it directly.
        """

        user_id = str(uuid4())
        owner_id = str(uuid4())
        with testapp.app_context():
            factory = CaseFactory(self._get_backend(), client, domain=DOMAIN, case_defaults={
                'user_id': user_id,
                'owner_id': owner_id,
                'case_type': 'duck',
            })
            child, parent = factory.create_or_update_case(
                CaseStructure(
                    attrs={'create': True, 'case_type': 'duckling'},
                    relationships=[
                        CaseRelationship(
                            CaseStructure(attrs={'case_type': 'duck'})
                        ),
                    ])
            )

            ids = [child.id, parent.id]
            dao = get_dao(self._get_backend())
            id_date_map = dao.get_last_modified_dates(DOMAIN, ids)
            assert set(id_date_map.keys()) == set(ids)
Пример #4
0
    def test_create_case(self, testapp, client):
        user_id = str(uuid4())
        form_id = str(uuid4())
        case_id = str(uuid4())
        synclog_id = create_synclog(self._get_backend(), DOMAIN, user_id)
        with testapp.app_context():
            factory = CaseFactory(
                self._get_backend(),
                client,
                domain=DOMAIN,
                case_defaults={
                    'user_id': user_id,
                    'owner_id': user_id,
                    'case_type': 'duck',
                    'update': {'identity': 'mallard'}
                },
                form_extras={
                    'headers': {
                        'last_sync_token': synclog_id
                    }
                }
            )
            factory.create_or_update_cases([
                CaseStructure(case_id, attrs={'create': True}),
            ], form_extras={
                'form_id': form_id,
                'user_id': user_id,
            })

        self._assert_form(form_id, user_id, synclog_id)
        self._assert_case(case_id, user_id)
        self._assert_synclog(synclog_id, case_ids=[case_id])
        assert get_dao(self._get_backend()).case_exists(case_id) is True
Пример #5
0
    def test_get_reverse_indexed_cases(self, testapp, client):
        """
        This tests Dao.get_reverse_indexed_cases().
        Note that the result of get_reverse_indexed_cases() isn't actually
        being used by the receiver.
        """

        user_id = str(uuid4())
        owner_id = str(uuid4())
        with testapp.app_context():
            factory = CaseFactory(self._get_backend(), client, domain=DOMAIN, case_defaults={
                'user_id': user_id,
                'owner_id': owner_id,
                'case_type': 'duck',
            })
            child, parent = factory.create_or_update_case(
                CaseStructure(
                    attrs={'create': True, 'case_type': 'duckling'},
                    relationships=[
                        CaseRelationship(
                            CaseStructure(attrs={'case_type': 'duck'})
                        ),
                    ])
            )

            dao = get_dao(self._get_backend())
            reverse_indexed_case_ids = [c.id for c in dao.get_reverse_indexed_cases(DOMAIN, [parent.id])]
            assert [child.id] == reverse_indexed_case_ids
Пример #6
0
    def test_case_index(self, testapp, client):
        user_id = str(uuid4())
        owner_id = str(uuid4())
        with testapp.app_context():
            factory = CaseFactory(self._get_backend(), client, domain=DOMAIN, case_defaults={
                'user_id': user_id,
                'owner_id': owner_id,
                'case_type': 'duck',
            })
            child, parent = factory.create_or_update_case(
                CaseStructure(
                    attrs={'create': True, 'case_type': 'duckling'},
                    relationships=[
                        CaseRelationship(
                            CaseStructure(attrs={'case_type': 'duck'})
                        ),
                    ])
            )

            self._assert_case(parent.id, owner_id)
            self._assert_case(child.id, owner_id, indices={
                'parent': {
                    'referenced_type': 'duck',
                    'referenced_id': parent.id,
                }
            })
Пример #7
0
    def test_update_case(self, testapp, client):
        user_id = str(uuid4())
        case_id = str(uuid4())
        synclog_id = create_synclog(self._get_backend(), DOMAIN, user_id)
        with testapp.app_context():
            factory = CaseFactory(
                self._get_backend(),
                client,
                domain=DOMAIN,
                case_defaults={
                    'user_id': user_id,
                    'owner_id': user_id,
                    'case_type': 'duck',
                },
                form_extras={
                    'headers': {
                        'last_sync_token': synclog_id
                    }
                }
            )
            factory.create_or_update_cases([
                CaseStructure(case_id, attrs={'create': True}),
            ])

            self._assert_case(case_id, user_id)
            self._assert_synclog(synclog_id, case_ids=[case_id])

            updated_case, = factory.create_or_update_case(
                CaseStructure(case_id, attrs={'update': {'identity': 'mallard'}, 'close': True})
            )

            assert updated_case.identity == 'mallard'
            assert updated_case.closed is True
            self._assert_case(case_id, user_id, num_forms=2, closed=True)
            self._assert_synclog(synclog_id, case_ids=[])
Пример #8
0
    def test_sync_token(self, testapp, client):
        """
        Tests sync token / sync mode support
        """
        self.test_user_restore_with_case(testapp, client)
        user = dummy_user(self.user_id)

        synclog = self._get_one_synclog()
        synclog_id = synclog.id

        restore_payload = generate_restore_response(client, DOMAIN, user, self._get_restore_url_snippet(), since=synclog_id)
        new_synclog = self._get_synclog_by_previous_id(synclog_id)
        new_synclog_id = new_synclog.id

        # should no longer have a case block in the restore XML
        check_xml_line_by_line(
            dummy_restore_xml(user, new_synclog_id, items=3),
            restore_payload,
        )

        time.sleep(1)  # current jsonobject doesn't support microseconds in datetime fields
        # update the case
        with testapp.app_context():
            factory = CaseFactory(
                self._get_backend(),
                client,
                domain=DOMAIN,
                case_defaults={
                    'user_id': str(uuid4()),
                    'owner_id': self.user_id,
                    'case_type': 'duck',
                }
            )
            updated_case, = factory.create_or_update_case(
                CaseStructure(self.case_id, attrs={'update': {'occupation': 'restaurant owner'}}),
            )

        new_restore_payload = generate_restore_response(client, DOMAIN, user, self._get_restore_url_snippet(), since=new_synclog_id)

        new_new_synclog = self._get_synclog_by_previous_id(new_synclog_id)

        case_xml = xml.get_case_xml(updated_case, [const.CASE_ACTION_UPDATE], version=V2)
        # case block should come back
        check_xml_line_by_line(
            dummy_restore_xml(user, new_new_synclog.id, case_xml=case_xml, items=4),
            new_restore_payload,
        )
Пример #9
0
    def test_basic_workflow(self, config):
        """
        Sync, create a case
        Verify sync doesn't contain case
        Update case by another user
        Verify sync contains updated case
        """
        user_id = str(uuid4())
        case_id = str(uuid4())
        user = dummy_user(user_id)

        initial_payload = get_restore_payload(config.restore_url, config.domain, user)
        synclog_id = synclog_id_from_restore_payload(
            initial_payload
        )

        # payload should not contain any cases
        check_xml_line_by_line(
            dummy_restore_xml(user, synclog_id, items=3),
            initial_payload,
        )

        factory = CaseFactory(
            config.receiver_url,
            domain=config.domain,
            form_extras={
                'user_id': user_id,
            }
        )
        case_attrs = {
            'create': True,
            'user_id': user_id,
            'owner_id': user_id,
            'case_type': 'gangster',
            'case_name': 'Fish',
            'update': {'last_name': 'Mooney'}
        }
        factory.create_or_update_case(
            CaseStructure(case_id, attrs=case_attrs),
            form_extras={'headers': {'last_sync_token': synclog_id}}
        )

        restore_payload = get_restore_payload(config.restore_url, config.domain, user, since=synclog_id)
        new_synclog_id = synclog_id_from_restore_payload(restore_payload)
        # restore still does not contain case
        check_xml_line_by_line(
            dummy_restore_xml(user, new_synclog_id, items=3),
            restore_payload,
        )

        # update the case
        case_updates = {'cover_job': 'restaurant owner'}
        date_modified = datetime.utcnow()
        factory.create_or_update_case(
            CaseStructure(case_id, attrs={'update': case_updates, 'date_modified': date_modified}),
            form_extras={
                'user_id': user_id,
                # 'headers': {
                #     'last_sync_token': new_synclog_id
                }#}
        )

        restore_payload = get_restore_payload(config.restore_url, config.domain, user, since=new_synclog_id)
        new_new_synclog_id = synclog_id_from_restore_payload(restore_payload)

        case_attrs['create'] = False
        case_attrs['update'].update(case_updates)
        case_block = CaseBlock(case_id, date_modified=date_modified, **case_attrs)
        # restore contain case
        check_xml_line_by_line(
            dummy_restore_xml(user, new_new_synclog_id, case_xml=case_block.as_string(), items=4),
            restore_payload,
        )