コード例 #1
0
    def setup_models(self):
        self.project = ProjectFactory.create(current_questionnaire='a1')
        self.spatial_unit = SpatialUnitFactory(project=self.project)
        content_type = ContentType.objects.get(
            app_label='party', model='tenurerelationship')
        schema = Schema.objects.create(
            content_type=content_type,
            selectors=(self.project.organization.id, self.project.id, 'a1'))
        attr_type = AttributeType.objects.get(name='text')
        Attribute.objects.create(
            schema=schema,
            name='r_name', long_name='Relationship field',
            attr_type=attr_type, index=0,
            required=False, omit=False
        )

        content_type = ContentType.objects.get(
            app_label='party', model='party')
        schema = Schema.objects.create(
            content_type=content_type,
            selectors=(self.project.organization.id, self.project.id, 'a1'))
        attr_type = AttributeType.objects.get(name='text')
        Attribute.objects.create(
            schema=schema,
            name='p_name', long_name='Party field',
            attr_type=attr_type, index=0,
            required=False, omit=False
        )
コード例 #2
0
    def setup_models(self):
        self.user = UserFactory.create()
        assign_policies(self.user)

        self.prj = ProjectFactory.create(slug='test-project', access='public')
        self.party1 = PartyFactory.create(project=self.prj, name='Landowner')
        self.su2 = SpatialUnitFactory.create(project=self.prj, type='PA')
コード例 #3
0
    def test_update_questionnaire_attribute_schema(self):
        file = self.get_file(
            '/questionnaires/tests/files/xls-form-attrs.xlsx', 'rb')
        form = self.storage.save('xls-forms/xls-form.xlsx', file)
        project = ProjectFactory.create(name='TestProject')
        q1 = models.Questionnaire.objects.create_from_form(
            xls_form=form,
            project=project
        )

        q2 = models.Questionnaire.objects.create_from_form(
            xls_form=form,
            project=project
        )

        assert 12 == Schema.objects.all().count()

        content_type = ContentType.objects.get(
            app_label='party', model='party')
        assert q1.id != q2.id

        s1 = Schema.objects.get(
            content_type=content_type, selectors=(
                project.organization.pk, project.pk, q1.id)
        )
        assert s1 is not None
        s2 = Schema.objects.get(
            content_type=content_type, selectors=(
                project.organization.pk, project.pk,
                project.current_questionnaire)
        )
        assert s2 is not None
        assert s1 != s2
コード例 #4
0
    def setup_models(self):
        self.project = ProjectFactory.create()
        self.resources = ResourceFactory.create_batch(
            2, content_object=self.project, project=self.project)
        self.denied = ResourceFactory.create(content_object=self.project,
                                             project=self.project)
        ResourceFactory.create()

        self.user = UserFactory.create()
        assign_policies(self.user, add_clauses=[
            {
                'effect': 'deny',
                'object': ['resource/*/*/' + self.denied.id],
                'action': ['resource.*'],
            },
            {
                'effect': 'deny',
                'object': ['resource/*/*/*'],
                'action': ['resource.unarchive'],
            },
        ])

        self.storage = self.get_storage()
        self.file = self.get_file(
            '/resources/tests/files/image.jpg', 'rb')
        self.file_name = self.storage.save('resources/image.jpg', self.file)
コード例 #5
0
    def setUp(self):
        self.project = ProjectFactory.create(current_questionnaire='abc1')

        content_type = ContentType.objects.get(
            app_label='party', model='party')
        schema1 = Schema.objects.create(
            content_type=content_type,
            selectors=(
                self.project.organization.id, self.project.id, 'abc1'))
        schema2 = Schema.objects.create(
            content_type=content_type,
            selectors=(
                self.project.organization.id, self.project.id, 'abc1', 'GR'))
        create_attribute_type('text', 'Text', 'CharField',
                              validator_type='str')
        create_attribute_type('boolean', 'boolean', 'BooleanField',
                              validator_type='bool')
        Attribute.objects.create(
            schema=schema1,
            name='fname',
            long_name='Test field',
            attr_type=AttributeType.objects.get(name='text'),
            index=0
        )
        Attribute.objects.create(
            schema=schema2,
            name='homeowner',
            long_name='Homeowner',
            attr_type=AttributeType.objects.get(name='boolean'),
            index=1
        )
コード例 #6
0
    def test_create_location_with_attributes(self):
        data = {
            'geometry': '{"type": "Polygon","coordinates": [[[-0.1418137550354'
                        '004,51.55240622205599],[-0.14117002487182617,51.55167'
                        '905819532],[-0.1411914825439453,51.55181915488898],[-'
                        '0.1411271095275879,51.55254631651022],[-0.14181375503'
                        '54004,51.55240622205599]]]}',
            'type': 'CB',
            'spatialunit::default::fname': 'test'
        }

        project = ProjectFactory.create()
        content_type = ContentType.objects.get(
            app_label='spatial', model='spatialunit')
        schema = Schema.objects.create(
            content_type=content_type,
            selectors=(project.organization.id, project.id, ))
        attr_type = AttributeType.objects.get(name='text')
        Attribute.objects.create(
            schema=schema,
            name='fname', long_name='Test field',
            attr_type=attr_type, index=0,
            required=False, omit=False
        )

        form = forms.LocationForm(project=project, data=data)
        form.is_valid()
        form.save()

        assert SpatialUnit.objects.filter(project=project).count() == 1
        unit = SpatialUnit.objects.filter(project=project).first()
        assert unit.attributes.get('fname') == 'test'
コード例 #7
0
 def test_spatial_unit_attribute_schema(self):
     project = ProjectFactory.create(name='TestProject')
     QuestionnaireFactory.create(project=project)
     content_type = ContentType.objects.get(
         app_label='spatial', model='spatialunit')
     create_attrs_schema(
         project=project, dict=location_xform_group,
         content_type=content_type, errors=[])
     spatial_unit = SpatialUnitFactory.create(
         project=project,
         attributes={
             'quality': 'polygon_high',
             'infrastructure': ['water', 'food']
         }
     )
     assert 1 == Schema.objects.all().count()
     schema = Schema.objects.get(content_type=content_type)
     assert schema is not None
     assert schema.selectors == [
         project.organization.pk, project.pk, project.current_questionnaire]
     assert 'quality' in spatial_unit.attributes.attributes
     assert 'polygon_high' == spatial_unit.attributes['quality']
     assert 'infrastructure' in spatial_unit.attributes.attributes
     assert 'water' in spatial_unit.attributes['infrastructure']
     # notes field is omitted in xform
     assert 'notes' not in spatial_unit.attributes.attributes
コード例 #8
0
 def test_repr(self):
     project = ProjectFactory.build(slug='prj')
     questionnaire = factories.QuestionnaireFactory.build(id='abc123',
                                                          project=project,
                                                          title='Questions')
     assert repr(questionnaire) == ('<Questionnaire id=abc123 '
                                    'title=Questions project=prj>')
コード例 #9
0
 def setup_models(self):
     self.prj = ProjectFactory.create()
     self.party = PartyFactory.create(project=self.prj)
     self.resource = ResourceFactory.create(content_object=self.party,
                                            project=self.prj)
     self.user = UserFactory.create()
     assign_policies(self.user)
コード例 #10
0
 def setup_models(self):
     self.user = UserFactory.create()
     assign_policies(self.user)
     self.org = OrganizationFactory.create()
     self.prj = ProjectFactory.create(
         organization=self.org, add_users=[self.user])
     self.party = PartyFactory.create(name="Test Party", project=self.prj)
コード例 #11
0
    def test_login_redirect_to_original_referer(self):
        user = UserFactory.create()
        project = ProjectFactory.create()

        view = LocationsAdd.as_view()

        request = HttpRequest()
        referer = '/organizations/{}/projects/{}'.format(
            project.organization.slug,
            project.slug
        )
        request.META['HTTP_REFERER'] = referer
        setattr(request, 'user', user)
        setattr(request, 'method', 'GET')

        setattr(request, 'session', 'session')
        self.messages = FallbackStorage(request)
        setattr(request, '_messages', self.messages)

        kwargs = {
            'organization': project.organization.slug,
            'project': project.slug
        }

        response = view(request, **kwargs)
        assert response.status_code == 302
        assert referer == response['location']
コード例 #12
0
    def test_get_schema_attrs(self):
        project = ProjectFactory.create(current_questionnaire='123abc')
        content_type = ContentType.objects.get(app_label='spatial',
                                               model='spatialunit')
        schema = Schema.objects.create(
            content_type=content_type,
            selectors=(project.organization.id, project.id, '123abc', ))
        text_type = AttributeType.objects.get(name='text')
        select_m_type = AttributeType.objects.get(name='select_multiple')
        Attribute.objects.create(
            schema=schema,
            name='key', long_name='Test field',
            attr_type=text_type, index=0,
            required=False, omit=False
        )
        Attribute.objects.create(
            schema=schema,
            name='key_2', long_name='Test field',
            attr_type=text_type, index=1,
            required=False, omit=True
        )
        Attribute.objects.create(
            schema=schema,
            name='key_3', long_name='Test select multiple field',
            attr_type=select_m_type, index=2,
            choices=['choice_1', 'choice_2', 'choice_3'],
            choice_labels=['Choice 1', 'Choice 2', 'Choice 3'],
            required=False, omit=False
        )

        exporter = Exporter(project)
        attrs = exporter.get_schema_attrs(content_type)
        assert len(attrs['DEFAULT']) == 2
コード例 #13
0
    def test_invalid_deserialize_json(self):
        data = {
            'id_string': 'yx8sqx6488wbc4yysnkrbnfq',
            'questions': [{
                'name': "start",
                'label': 'Label',
                'type': "ST",
                'required': False,
                'constraint': None
            }, {
                'name': "end",
                'label': 'Label',
                'type': "EN",
            }]
        }
        project = ProjectFactory.create()

        serializer = serializers.QuestionnaireSerializer(
            data=data,
            context={'project': project}
        )
        assert serializer.is_valid() is False
        assert serializer.errors == {'title': ['This field is required.']}

        with pytest.raises(ValidationError):
            assert serializer.is_valid(raise_exception=True)
コード例 #14
0
 def setup_models(self):
     self.prj = ProjectFactory.create()
     self.su = SpatialUnitFactory.create(project=self.prj)
     self.resource = ResourceFactory.create(content_object=self.su,
                                            project=self.prj)
     self.user = UserFactory.create()
     assign_policies(self.user)
コード例 #15
0
    def setup_models(self):
        clauses = {
            'clause': [
                {
                    'effect': 'allow',
                    'object': ['project/*/*',
                               'spatial/*/*/*',
                               'spatial_rel/*/*/*',
                               'party/*/*/*',
                               'party_rel/*/*/*',
                               'tenure_rel/*/*/*'],
                    'action': ['project.*',
                               'project.*.*',
                               'spatial.*',
                               'spatial_rel.*',
                               'party.*',
                               'party_rel.*',
                               'tenure_rel.*']
                }
            ]
        }
        policy = Policy.objects.create(
            name='basic-test',
            body=json.dumps(clauses))
        self.user = UserFactory.create()
        self.user.assign_policies(policy)

        self.prj = ProjectFactory.create(slug='test-project', access='public')
        self.SR = spatial_factories.SpatialRelationshipFactory
        self.PR = party_factories.PartyRelationshipFactory
        self.TR = party_factories.TenureRelationshipFactory
コード例 #16
0
    def test_get_schema_attrs(self):
        project = ProjectFactory.create(current_questionnaire="123abc")
        content_type = ContentType.objects.get(app_label="spatial", model="spatialunit")
        schema = Schema.objects.create(
            content_type=content_type, selectors=(project.organization.id, project.id, "123abc")
        )
        text_type = AttributeType.objects.get(name="text")
        select_m_type = AttributeType.objects.get(name="select_multiple")
        Attribute.objects.create(
            schema=schema, name="key", long_name="Test field", attr_type=text_type, index=0, required=False, omit=False
        )
        Attribute.objects.create(
            schema=schema, name="key_2", long_name="Test field", attr_type=text_type, index=1, required=False, omit=True
        )
        Attribute.objects.create(
            schema=schema,
            name="key_3",
            long_name="Test select multiple field",
            attr_type=select_m_type,
            index=2,
            choices=["choice_1", "choice_2", "choice_3"],
            choice_labels=["Choice 1", "Choice 2", "Choice 3"],
            required=False,
            omit=False,
        )

        exporter = Exporter(project)
        attrs = exporter.get_schema_attrs(content_type)
        assert len(attrs) == 2
コード例 #17
0
    def setUp(self):
        super().setUp()

        # Create a floating resource
        self.user = UserFactory.build(
            full_name='John Lennon',
            username='******'
        )
        self.last_updated = datetime.now()
        self.resource = ResourceFactory.build(
            name='Resource Name',
            file='https://example.com/file.txt',
            original_file='original_file.jpg',
            mime_type='image/png',
            contributor=self.user,
            last_updated=self.last_updated,
        )

        # Attach it to a project
        project = ProjectFactory.create()
        ContentObject.objects.create(
            resource=self.resource,
            content_type=ContentType.objects.get_for_model(project),
            object_id=project.id,
        )
コード例 #18
0
    def _test_serialize(self, https=False):
        form = self._get_form('xls-form')
        self.url = '/collect/'
        user = UserFactory.create()
        request = APIRequestFactory().get(self.url)
        force_authenticate(request, user=user)
        if https:
            request.META['SERVER_PROTOCOL'] = 'HTTPS/1.1'
        project = ProjectFactory.create()
        questionnaire = QuestionnaireSerializer(
            data={'xls_form': form},
            context={'project': project}
        )

        assert questionnaire.is_valid(raise_exception=True) is True
        questionnaire.save()
        form = Questionnaire.objects.get(filename__contains='xls-form')

        serializer = serializers.XFormListSerializer(
            form, context={'request': request})
        url_refix = 'https' if https else 'http'

        assert serializer.data['formID'] == questionnaire.data['id_string']
        assert serializer.data['name'] == questionnaire.data['title']
        assert serializer.data['version'] == questionnaire.data['version']
        assert (serializer.data['downloadUrl'] ==
                url_refix + '://testserver' +
                reverse('form-download', args=[form.id]))
        assert serializer.data['hash'] == questionnaire.data['md5_hash']
コード例 #19
0
    def test_login_redirect_from_project_dashboard_to_org_dashboard(self):
        user = UserFactory.create()
        assign_user_policies(user, *[])
        project = ProjectFactory.create()

        view = org_views.ProjectDashboard.as_view()

        request = HttpRequest()
        request.META['HTTP_REFERER'] = '/account/login/'
        setattr(request, 'user', user)
        setattr(request, 'method', 'GET')

        setattr(request, 'session', 'session')
        self.messages = FallbackStorage(request)
        setattr(request, '_messages', self.messages)

        kwargs = {
            'organization': project.organization.slug,
            'project': project.slug
        }

        def get_full_path():
            return '/organizations/{}/projects/{}/'.format(
                project.organization.slug,
                project.slug
            )
        setattr(request, 'get_full_path', get_full_path)

        exp_redirect = reverse('organization:dashboard', kwargs={
            'slug': project.organization.slug})
        response = view(request, **kwargs)
        assert response.status_code == 302
        assert exp_redirect == response['location']
コード例 #20
0
 def setup_models(self):
     self.user = UserFactory.create()
     self.project = ProjectFactory.create()
     self.resource = ResourceFactory.create(content_object=self.project,
                                            project=self.project,
                                            archived=True)
     assign_permissions(self.user)
コード例 #21
0
    def setup_models(self):
        self.user = UserFactory.create()
        self.org = OrganizationFactory.create()
        self.prj = ProjectFactory.create(organization=self.org)

        OrganizationRole.objects.create(
            organization=self.org, user=self.user, admin=True)
コード例 #22
0
 def setup_models(self):
     self.project = ProjectFactory.create()
     self.relationship = TenureRelationshipFactory.create(
         project=self.project)
     self.attached = ResourceFactory.create(
         project=self.project, content_object=self.relationship)
     self.unattached = ResourceFactory.create(project=self.project)
コード例 #23
0
    def test_deserialize_json(self):
        data = {
            'title': 'yx8sqx6488wbc4yysnkrbnfq',
            'id_string': 'yx8sqx6488wbc4yysnkrbnfq',
            'questions': [{
                'name': "start",
                'label': 'Label',
                'type': "ST",
                'required': False,
                'constraint': None
            }, {
                'name': "end",
                'label': 'Label',
                'type': "EN",
            }]
        }
        project = ProjectFactory.create()

        serializer = serializers.QuestionnaireSerializer(
            data=data,
            context={'project': project}
        )
        serializer.is_valid(raise_exception=True)
        serializer.save()
        assert Questionnaire.objects.count() == 1
        questionnaire = Questionnaire.objects.first()
        assert project.current_questionnaire == questionnaire.id
        assert questionnaire.questions.count() == 2
コード例 #24
0
    def test_create_party_with_attributes(self):
        data = {"name": "Cadasta", "type": "IN", "attributes::fname": "test"}
        project = ProjectFactory.create()

        content_type = ContentType.objects.get(app_label="party", model="party")
        schema = Schema.objects.create(content_type=content_type, selectors=(project.organization.id, project.id))

        Attribute.objects.create(
            schema=schema,
            name="fname",
            long_name="Test field",
            attr_type=AttributeType.objects.get(name="text"),
            index=0,
        )

        form = forms.PartyForm(
            project_id=project.id,
            data=data,
            schema_selectors=(
                {"name": "organization", "value": project.organization, "selector": project.organization.id},
                {"name": "project", "value": project, "selector": project.id},
            ),
        )
        form.is_valid()
        form.save()

        assert Party.objects.filter(project=project).count() == 1
        party = Party.objects.filter(project=project).first()
        assert party.attributes.get("fname") == "test"
コード例 #25
0
    def test_deserialize(self):
        form = self.get_form('xls-form')

        project = ProjectFactory.create()

        serializer = serializers.QuestionnaireSerializer(
            data={'xls_form': form},
            context={'project': project}
        )
        assert serializer.is_valid(raise_exception=True) is True
        serializer.save()

        assert Questionnaire.objects.count() == 1
        questionnaire = Questionnaire.objects.first()

        assert questionnaire.id_string == 'question_types'
        assert questionnaire.filename == 'xls-form'
        assert questionnaire.title == 'Question types'

        assert serializer.data['id'] == questionnaire.id
        assert serializer.data['filename'] == questionnaire.filename
        assert serializer.data['title'] == questionnaire.title
        assert serializer.data['id_string'] == questionnaire.id_string
        assert serializer.data['xls_form'] == questionnaire.xls_form.url
        assert serializer.data['version'] == questionnaire.version
        assert len(serializer.data['questions']) == 1
コード例 #26
0
 def test_party_attribute_schema(self):
     project = ProjectFactory.create(name='TestProject')
     QuestionnaireFactory.create(project=project)
     content_type = ContentType.objects.get(
         app_label='party', model='party')
     create_attrs_schema(
         project=project, dict=individual_party_xform_group,
         content_type=content_type, errors=[])
     party = PartyFactory.create(
         name='TestParty', project=project,
         type='IN',
         attributes={
             'homeowner': 'yes',
             'dob': '1980-01-01'
         }
     )
     assert 1 == Schema.objects.all().count()
     schema = Schema.objects.get(content_type=content_type)
     assert schema is not None
     assert schema.selectors == [
         project.organization.pk, project.pk,
         project.current_questionnaire, party.type]
     assert 'homeowner' in party.attributes.attributes
     assert 'dob' in party.attributes.attributes
     assert 'gender' in party.attributes.attributes
     assert 3 == Attribute.objects.filter(schema=schema).count()
     assert party.attributes['homeowner'] == 'yes'
     assert party.attributes['dob'] == '1980-01-01'
コード例 #27
0
    def setup_models(self, access='public'):
        self.user = UserFactory.create()
        assign_policies(self.user)

        self.prj = ProjectFactory.create(slug='test-project', access='public')
        self.su1 = SpatialUnitFactory.create(project=self.prj, type='AP')
        self.su2 = SpatialUnitFactory.create(project=self.prj, type='BU')
コード例 #28
0
    def test_get_values(self):
        project = ProjectFactory.create(current_questionnaire="123abc")
        exporter = Exporter(project)
        content_type = ContentType.objects.get(app_label="party", model="tenurerelationship")
        schema = Schema.objects.create(
            content_type=content_type, selectors=(project.organization.id, project.id, "123abc")
        )
        text_type = AttributeType.objects.get(name="text")
        select_m_type = AttributeType.objects.get(name="select_multiple")
        attr = Attribute.objects.create(
            schema=schema, name="key", long_name="Test field", attr_type=text_type, index=0, required=False, omit=False
        )
        attr2 = Attribute.objects.create(
            schema=schema,
            name="key_2",
            long_name="Test select multiple field",
            attr_type=select_m_type,
            index=1,
            choices=["choice_1", "choice_2", "choice_3"],
            choice_labels=["Choice 1", "Choice 2", "Choice 3"],
            required=False,
            omit=False,
        )

        ttype = TenureRelationshipType.objects.get(id="LH")
        item = TenureRelationshipFactory.create(
            project=project, tenure_type=ttype, attributes={"key": "text", "key_2": ["choice_1", "choice_2"]}
        )
        model_attrs = ("id", "party_id", "spatial_unit_id", "tenure_type.label")
        schema_attrs = [attr, attr2]
        values = exporter.get_values(item, model_attrs, schema_attrs)
        assert values == [item.id, item.party_id, item.spatial_unit_id, "Leasehold", "text", "choice_1, choice_2"]
コード例 #29
0
    def setup_models(self):
        self.project = ProjectFactory.create()
        self.org_slug = self.project.organization.slug
        self.resource = ResourceFactory.create(project=self.project)
        self.location = SpatialUnitFactory.create(project=self.project)
        self.party = PartyFactory.create(project=self.project)
        self.tenurerel = TenureRelationshipFactory.create(project=self.project)
        self.project_attachment = ContentObject.objects.create(
            resource_id=self.resource.id,
            content_object=self.project,
        )
        self.location_attachment = ContentObject.objects.create(
            resource_id=self.resource.id,
            content_object=self.location,
        )
        self.party_attachment = ContentObject.objects.create(
            resource_id=self.resource.id,
            content_object=self.party,
        )
        self.tenurerel_attachment = ContentObject.objects.create(
            resource_id=self.resource.id,
            content_object=self.tenurerel,
        )

        self.user = UserFactory.create()
        assign_permissions(self.user)
コード例 #30
0
    def test_save_new_party_with_attributes(self):
        project = ProjectFactory.create()
        questionnaire = QuestionnaireFactory.create(project=project)
        spatial_unit = SpatialUnitFactory.create(project=project)

        content_type = ContentType.objects.get(
            app_label='party', model='tenurerelationship')
        schema = Schema.objects.create(
            content_type=content_type,
            selectors=(
                project.organization.id, project.id, questionnaire.id, ))
        attr_type = AttributeType.objects.get(name='text')
        Attribute.objects.create(
            schema=schema,
            name='r_name', long_name='Relationship field',
            attr_type=attr_type, index=0,
            required=False, omit=False
        )

        content_type = ContentType.objects.get(
            app_label='party', model='party')
        schema_gr = Schema.objects.create(
            content_type=content_type,
            selectors=(
                project.organization.id, project.id, questionnaire.id, 'GR'))
        Attribute.objects.create(
            schema=schema_gr,
            name='p_gr_name', long_name='Party GR field',
            attr_type=attr_type, index=0,
            required=True, omit=False
        )

        form = forms.TenureRelationshipForm(
            project=project,
            spatial_unit=spatial_unit,
            data={'new_entity': 'on',
                  'id': '',
                  'name': 'The Beatles',
                  'party::gr::p_gr_name': 'Party Group Name',
                  'party_type': 'GR',
                  'tenure_type': 'CU',
                  'tenurerelationship::default::r_name': 'Rel Name'})

        assert form.is_valid()
        form.save()

        assert Party.objects.count() == 1
        party = Party.objects.first()
        assert party.name == 'The Beatles'
        assert party.type == 'GR'

        assert party.attributes.get('p_gr_name') == 'Party Group Name'

        assert TenureRelationship.objects.count() == 1
        rel = TenureRelationship.objects.first()
        assert rel.party == party
        assert rel.spatial_unit == spatial_unit
        assert rel.tenure_type_id == 'CU'
        assert rel.attributes.get('r_name') == 'Rel Name'
コード例 #31
0
    def test_pack_resource_data(self):
        project = ProjectFactory.create()
        exporter = ResourceExporter(project)

        res = ResourceFactory.create(project=project)
        loc = SpatialUnitFactory.create(project=project)
        loc2 = SpatialUnitFactory.create(project=project)
        par = PartyFactory.create(project=project)
        rel = TenureRelationshipFactory.create(project=project)

        ContentObject.objects.create(resource=res, content_object=loc)
        ContentObject.objects.create(resource=res, content_object=loc2)
        ContentObject.objects.create(resource=res, content_object=par)
        ContentObject.objects.create(resource=res, content_object=rel)

        packed = exporter.pack_resource_data(res)
        assert packed[0] == res.id
        assert packed[1] == res.name
        assert packed[2] == res.description
        assert packed[3] == res.original_file
        assert loc.id in packed[4]
        assert loc2.id in packed[4]
        assert par.id in packed[5]
        assert rel.id in packed[6]
コード例 #32
0
    def test_login_redirect_to_project_dashboard(self):
        user = UserFactory.create()
        project = ProjectFactory.create()

        view = LocationsAdd.as_view()

        request = HttpRequest()
        request.META['HTTP_REFERER'] = '/account/login/'
        setattr(request, 'user', user)
        setattr(request, 'method', 'GET')

        setattr(request, 'session', 'session')
        self.messages = FallbackStorage(request)
        setattr(request, '_messages', self.messages)

        kwargs = {
            'organization': project.organization.slug,
            'project': project.slug
        }

        exp_redirect = reverse('organization:project-dashboard', kwargs=kwargs)
        response = view(request, **kwargs)
        assert response.status_code == 302
        assert exp_redirect == response['location']
コード例 #33
0
    def setup_models(self):
        clauses = {
            'clause': [{
                'effect':
                'allow',
                'object': [
                    'project/*/*', 'spatial/*/*/*', 'spatial_rel/*/*/*',
                    'party/*/*/*', 'party_rel/*/*/*', 'tenure_rel/*/*/*'
                ],
                'action': [
                    'project.*', 'project.*.*', 'spatial.*', 'spatial_rel.*',
                    'party.*', 'party_rel.*', 'tenure_rel.*'
                ]
            }]
        }
        policy = Policy.objects.create(name='basic-test',
                                       body=json.dumps(clauses))
        self.user = UserFactory.create()
        self.user.assign_policies(policy)

        self.prj = ProjectFactory.create(slug='test-project', access='public')
        self.SR = spatial_factories.SpatialRelationshipFactory
        self.PR = party_factories.PartyRelationshipFactory
        self.TR = party_factories.TenureRelationshipFactory
コード例 #34
0
    def setUp(self):
        super().setUp()
        self.project = ProjectFactory.create()
        QuestionnaireFactory.create(project=self.project)

        content_type = ContentType.objects.get(app_label='spatial',
                                               model='spatialunit')
        create_attrs_schema(
            project=self.project,
            dict=attr_schemas.location_xform_group,
            content_type=content_type,
        )
        content_type = ContentType.objects.get(app_label='party',
                                               model='party')
        create_attrs_schema(
            project=self.project,
            dict=attr_schemas.default_party_xform_group,
            content_type=content_type,
        )
        create_attrs_schema(
            project=self.project,
            dict=attr_schemas.individual_party_xform_group,
            content_type=content_type,
        )
        create_attrs_schema(
            project=self.project,
            dict=attr_schemas.group_party_attributes,
            content_type=content_type,
        )
        content_type = ContentType.objects.get(app_label='party',
                                               model='tenurerelationship')
        create_attrs_schema(
            project=self.project,
            dict=attr_schemas.tenure_relationship_xform_group,
            content_type=content_type,
        )
コード例 #35
0
    def test_save_new_party(self):
        project = ProjectFactory.create()
        spatial_unit = SpatialUnitFactory.create(project=project)
        form = forms.TenureRelationshipForm(project=project,
                                            spatial_unit=spatial_unit,
                                            data={'new_entity': 'on',
                                                  'id': '',
                                                  'name': 'The Beatles',
                                                  'party_type': 'GR',
                                                  'tenure_type': 'CU'})

        form.is_valid()
        form.save()

        assert Party.objects.count() == 1
        party = Party.objects.first()
        assert party.name == 'The Beatles'
        assert party.type == 'GR'

        assert TenureRelationship.objects.count() == 1
        rel = TenureRelationship.objects.first()
        assert rel.party == party
        assert rel.spatial_unit == spatial_unit
        assert rel.tenure_type_id == 'CU'
コード例 #36
0
    def test_deserialize(self):
        form = self.get_form('xls-form')

        project = ProjectFactory.create()

        serializer = serializers.QuestionnaireSerializer(
            data={'xls_form': form}, context={'project': project})
        assert serializer.is_valid(raise_exception=True) is True
        serializer.save()

        assert Questionnaire.objects.count() == 1
        questionnaire = Questionnaire.objects.first()

        assert questionnaire.id_string == 'question_types'
        assert questionnaire.filename == 'xls-form'
        assert questionnaire.title == 'Question types'

        assert serializer.data['id'] == questionnaire.id
        assert serializer.data['filename'] == questionnaire.filename
        assert serializer.data['title'] == questionnaire.title
        assert serializer.data['id_string'] == questionnaire.id_string
        assert serializer.data['xls_form'] == questionnaire.xls_form.url
        assert serializer.data['version'] == questionnaire.version
        assert len(serializer.data['questions']) == 1
コード例 #37
0
 def test_left_and_right_project_ids(self):
     with pytest.raises(exceptions.ProjectRelationshipError):
         project1 = ProjectFactory()
         project2 = ProjectFactory()
         PartyRelationshipFactory.create(party1__project=project1,
                                         party2__project=project2)
コード例 #38
0
 def setup_models(self):
     self.user = UserFactory.create()
     assign_policies(self.user)
     self.prj = ProjectFactory.create(slug='test-project', access='public')
     self.su = SpatialUnitFactory(project=self.prj, type='PA')
コード例 #39
0
 def test_project_relationship_invalid(self):
     with pytest.raises(exceptions.ProjectRelationshipError):
         project = ProjectFactory()
         PartyRelationshipFactory.create(party1__project=project)
コード例 #40
0
 def test_init(self):
     project = ProjectFactory.build()
     exporter = ResourceExporter(project)
     assert exporter.project == project
コード例 #41
0
 def test_left_and_right_project_ids(self):
     with pytest.raises(exceptions.ProjectRelationshipError):
         project = ProjectFactory()
         SpatialRelationshipFactory(su1__project=project)
コード例 #42
0
    def test_get_values_with_conditional_selector(self):
        project = ProjectFactory.create(current_questionnaire='123abc')
        exporter = Exporter(project)
        content_type = ContentType.objects.get(app_label='party',
                                               model='party')
        schema = Schema.objects.create(content_type=content_type,
                                       selectors=(
                                           project.organization.id,
                                           project.id,
                                           '123abc',
                                       ))
        schema_in = Schema.objects.create(content_type=content_type,
                                          selectors=(project.organization.id,
                                                     project.id, '123abc',
                                                     'IN'))
        schema_gr = Schema.objects.create(content_type=content_type,
                                          selectors=(project.organization.id,
                                                     project.id, '123abc',
                                                     'GR'))
        text_type = AttributeType.objects.get(name='text')
        select_m_type = AttributeType.objects.get(name='select_multiple')
        Attribute.objects.create(schema=schema,
                                 name='key',
                                 long_name='Test field',
                                 attr_type=text_type,
                                 index=0,
                                 required=False,
                                 omit=False)
        Attribute.objects.create(
            schema=schema_in,
            name='key_2',
            long_name='Test select multiple field',
            attr_type=select_m_type,
            index=1,
            choices=['choice_1', 'choice_2', 'choice_3'],
            choice_labels=['Choice 1', 'Choice 2', 'Choice 3'],
            required=False,
            omit=False)
        Attribute.objects.create(schema=schema_gr,
                                 name='gr_key',
                                 long_name='Test Group Field',
                                 attr_type=text_type,
                                 index=0,
                                 required=False,
                                 omit=False)

        # test individual attrs
        item = PartyFactory.create(project=project,
                                   name='Test Party',
                                   type='IN',
                                   attributes={
                                       'key': 'text',
                                       'key_2': ['choice_1', 'choice_2']
                                   })
        model_attrs = ('id', 'name', 'type')
        schema_attrs = exporter.get_schema_attrs(content_type)
        values = exporter.get_values(item, model_attrs, schema_attrs)
        assert values == {
            'id': item.id,
            'name': item.name,
            'type': item.type,
            'key': 'text',
            'key_2': 'choice_1, choice_2'
        }

        # test group attrs
        item = PartyFactory.create(project=project,
                                   name='Test Party',
                                   type='GR',
                                   attributes={
                                       'key': 'text',
                                       'gr_key': 'Test Group Field'
                                   })
        model_attrs = ('id', 'name', 'type')
        schema_attrs = exporter.get_schema_attrs(content_type)
        values = exporter.get_values(item, model_attrs, schema_attrs)
        assert values == {
            'id': item.id,
            'name': item.name,
            'type': item.type,
            'key': 'text',
            'gr_key': 'Test Group Field'
        }
コード例 #43
0
    def test_write_features(self):
        ensure_dirs()
        project = ProjectFactory.create(current_questionnaire='123abc')
        exporter = ShapeExporter(project)

        content_type = ContentType.objects.get(app_label='spatial',
                                               model='spatialunit')
        schema = Schema.objects.create(content_type=content_type,
                                       selectors=(
                                           project.organization.id,
                                           project.id,
                                           '123abc',
                                       ))
        attr_type = AttributeType.objects.get(name='text')
        Attribute.objects.create(schema=schema,
                                 name='geom_type',
                                 long_name='Test field',
                                 attr_type=attr_type,
                                 index=0,
                                 required=False,
                                 omit=False)

        su1 = SpatialUnitFactory.create(project=project,
                                        geometry='SRID=4326;POINT (30 10)',
                                        attributes={'geom_type': 'point'})
        su2 = SpatialUnitFactory.create(
            project=project,
            geometry='SRID=4326;LINESTRING (30 10, 10 30, 40 40)',
            attributes={'geom_type': 'linestring'})
        su3 = SpatialUnitFactory.create(
            project=project,
            geometry='SRID=4326;POLYGON ((30 10, 40 40, 20 40, 10 20, 30 10))',
            attributes={'geom_type': 'polygon'})
        su4 = SpatialUnitFactory.create(
            project=project,
            geometry='SRID=4326;'
            'MULTIPOINT ((10 40), (40 30), (20 20), (30 10))',
            attributes={'geom_type': 'multipoint'})
        su5 = SpatialUnitFactory.create(
            project=project,
            geometry='SRID=4326;'
            'MULTILINESTRING ((10 10, 20 20, 10 40),'
            '(40 40, 30 30, 40 20, 30 10))',
            attributes={'geom_type': 'multilinestring'})
        su6 = SpatialUnitFactory.create(
            project=project,
            geometry='SRID=4326;'
            'MULTIPOLYGON (((30 20, 45 40, 10 40, 30 20)),'
            '((15 5, 40 10, 10 20, 5 10, 15 5)))',
            attributes={'geom_type': 'multipolygon'})

        dst_dir = os.path.join(settings.MEDIA_ROOT, 'temp/file4')
        ds = exporter.create_datasource(dst_dir)
        filename = os.path.join(dst_dir, 'locations.csv')

        layers = exporter.write_features(ds, filename)
        assert len(layers.keys()) == 6
        for layer_name, layer in layers.items():
            su = SpatialUnit.objects.get(attributes={'geom_type': layer_name})
            geom = su.geometry
            feature = layer.GetNextFeature()
            assert geom.equals(GEOSGeometry(feature.geometry().ExportToWkt()))
            assert feature.GetFieldAsString('id') == su.id
        ds.Destroy()

        with open(filename) as csvfile:
            csvreader = csv.reader(csvfile)
            for i, row in enumerate(csvreader):
                if i == 0:
                    assert row == ['id', 'type', 'geom_type']
                if i == 1:
                    assert row == [su1.id, su1.type, 'point']
                if i == 2:
                    assert row == [su2.id, su2.type, 'linestring']
                if i == 3:
                    assert row == [su3.id, su3.type, 'polygon']
                if i == 4:
                    assert row == [su4.id, su4.type, 'multipoint']
                if i == 5:
                    assert row == [su5.id, su5.type, 'multilinestring']
                if i == 6:
                    assert row == [su6.id, su6.type, 'multipolygon']

        # remove this so other tests pass
        os.remove(filename)
コード例 #44
0
 def setup_models(self):
     self.project = ProjectFactory.create()
コード例 #45
0
 def setup_models(self):
     self.project = ProjectFactory.create()
     self.location = SpatialUnitFactory.create(project=self.project)
     TenureRelationshipFactory.create(project=self.project,
                                      spatial_unit=self.location)
コード例 #46
0
    def setup_models(self):
        self.user = UserFactory.create()
        assign_policies(self.user)
        self.project = ProjectFactory.create(slug='test-project')
        QuestionnaireFactory.create(project=self.project)

        content_type = ContentType.objects.get(app_label='party',
                                               model='party')
        create_attrs_schema(
            project=self.project,
            dict=attr_schemas.individual_party_xform_group,
            content_type=content_type,
        )
        create_attrs_schema(
            project=self.project,
            dict=attr_schemas.default_party_xform_group,
            content_type=content_type,
        )
        content_type = ContentType.objects.get(app_label='party',
                                               model='tenurerelationship')
        create_attrs_schema(
            project=self.project,
            dict=attr_schemas.tenure_relationship_xform_group,
            content_type=content_type,
        )

        self.su = SpatialUnitFactory.create(project=self.project, type='CB')
        self.party = PartyFactory.create(project=self.project,
                                         type='IN',
                                         attributes={
                                             'gender': 'm',
                                             'homeowner': 'yes',
                                             'dob': '1951-05-05'
                                         })
        self.tenure_rel = TenureRelationshipFactory.create(
            spatial_unit=self.su,
            party=self.party,
            project=self.project,
            attributes={'notes': 'PBS is the best.'})
        self.resource = ResourceFactory.create(project=self.project)

        self.results = get_fake_es_api_results(self.project, self.su,
                                               self.party, self.tenure_rel,
                                               self.resource)
        self.proj_result = self.results['hits']['hits'][0]
        self.su_result = self.results['hits']['hits'][1]
        self.party_result = self.results['hits']['hits'][2]
        self.tenure_rel_result = self.results['hits']['hits'][3]
        self.resource_result = self.results['hits']['hits'][4]

        self.query = 'searching'
        self.query_body = {
            'query': parse_query(self.query),
            'from': 10,
            'size': 20,
            'sort': {
                '_score': {
                    'order': 'desc'
                }
            },
        }
        url = '{}/project-{}/spatial,party,resource/_search/'
        self.es_endpoint = url.format(api_url, self.project.id)
        self.es_body = json.dumps(self.query_body, sort_keys=True)
コード例 #47
0
 def setup_models(self):
     self.user = UserFactory.create()
     assign_policies(self.user)
     self.org = OrganizationFactory.create()
     self.prj = ProjectFactory.create(
         organization=self.org, add_users=[self.user])
コード例 #48
0
    def test_init(self):
        project = ProjectFactory.create()
        spatial_unit = SpatialUnitFactory.create(project=project)
        form = forms.TenureRelationshipForm(project=project,
                                            spatial_unit=spatial_unit)
        content_type = ContentType.objects.get(
            app_label='party', model='tenurerelationship')
        schema = Schema.objects.create(
            content_type=content_type,
            selectors=(project.organization.id, project.id, ))
        attr_type = AttributeType.objects.get(name='text')
        Attribute.objects.create(
            schema=schema,
            name='r_name', long_name='Relationship field',
            attr_type=attr_type, index=0,
            required=False, omit=False
        )

        content_type = ContentType.objects.get(
            app_label='party', model='party')
        schema = Schema.objects.create(
            content_type=content_type,
            selectors=(project.organization.id, project.id, ))

        Attribute.objects.create(
            schema=schema, name='p_name', long_name='Party field',
            attr_type=AttributeType.objects.get(name='text'),
            index=0, required=True, default='John'
        )
        Attribute.objects.create(
            schema=schema, name='p_choice1', long_name='Party field',
            attr_type=AttributeType.objects.get(name='select_one'),
            index=1, choices=['1', '2']
        )
        Attribute.objects.create(
            schema=schema, name='p_choice2', long_name='Party field',
            attr_type=AttributeType.objects.get(name='select_one'),
            index=2, choices=['1', '2'], choice_labels=['Choice 1', 'Choice 2']
        )
        Attribute.objects.create(
            schema=schema, name='p_bool', long_name='Party field',
            attr_type=AttributeType.objects.get(name='boolean'),
            index=3, default='False'
        )

        form = forms.TenureRelationshipForm(
            data={'new_item': 'on'},
            project=project,
            spatial_unit=spatial_unit,
            schema_selectors=(
                {'name': 'organization',
                 'value': project.organization,
                 'selector': project.organization.id},
                {'name': 'project',
                 'value': project,
                 'selector': project.id}
            ))

        assert form.project == project
        assert form.spatial_unit == spatial_unit
        assert isinstance(form.fields['id'].widget, SelectPartyWidget)
        assert isinstance(form.fields['party::p_name'], CharField)
        assert form.fields['party::p_name'].initial == 'John'
        assert form.fields['party::p_name'].required is True
        assert isinstance(form.fields['party::p_choice1'], ChoiceField)
        assert isinstance(form.fields['party::p_choice2'], ChoiceField)
        assert isinstance(form.fields['party::p_bool'], BooleanField)
        assert form.fields['party::p_bool'].initial is False
        assert isinstance(form.fields['relationship::r_name'], CharField)
        assert isinstance(form.fields['tenure_type'], ChoiceField)
        assert form.fields['tenure_type'].choices == (
            [('', _('Please select a relationship type'))] +
            sorted(list(TENURE_RELATIONSHIP_TYPES))
        )
        assert ("All Types" not in
                dict(form.fields['tenure_type'].choices).values())
コード例 #49
0
    def test_save_new_party_with_attributes(self):
        project = ProjectFactory.create()
        spatial_unit = SpatialUnitFactory.create(project=project)

        content_type = ContentType.objects.get(
            app_label='party', model='tenurerelationship')
        schema = Schema.objects.create(
            content_type=content_type,
            selectors=(project.organization.id, project.id, ))
        attr_type = AttributeType.objects.get(name='text')
        Attribute.objects.create(
            schema=schema,
            name='r_name', long_name='Relationship field',
            attr_type=attr_type, index=0,
            required=False, omit=False
        )

        content_type = ContentType.objects.get(
            app_label='party', model='party')
        schema = Schema.objects.create(
            content_type=content_type,
            selectors=(project.organization.id, project.id, ))
        attr_type = AttributeType.objects.get(name='text')
        Attribute.objects.create(
            schema=schema,
            name='p_name', long_name='Party field',
            attr_type=attr_type, index=0,
            required=False, omit=False
        )

        form = forms.TenureRelationshipForm(
            project=project,
            spatial_unit=spatial_unit,
            data={'new_entity': 'on',
                  'id': '',
                  'name': 'The Beatles',
                  'party::p_name': 'Party Name',
                  'party_type': 'GR',
                  'tenure_type': 'CU',
                  'relationship::r_name': 'Rel Name'},
            schema_selectors=(
                {'name': 'organization',
                 'value': project.organization,
                 'selector': project.organization.id},
                {'name': 'project',
                 'value': project,
                 'selector': project.id}
            ))

        form.is_valid()
        form.save()

        assert Party.objects.count() == 1
        party = Party.objects.first()
        assert party.name == 'The Beatles'
        assert party.type == 'GR'
        assert party.attributes.get('p_name') == 'Party Name'

        assert TenureRelationship.objects.count() == 1
        rel = TenureRelationship.objects.first()
        assert rel.party == party
        assert rel.spatial_unit == spatial_unit
        assert rel.tenure_type_id == 'CU'
        assert rel.attributes.get('r_name') == 'Rel Name'
コード例 #50
0
 def setUp(self):
     super().setUp()
     self.project = ProjectFactory(name='TestProject')
コード例 #51
0
 def test_project_relationship_invalid(self):
     with pytest.raises(exceptions.ProjectRelationshipError):
         project = ProjectFactory()
         TenureRelationshipFactory.create(party__project=project,
                                          spatial_unit__project=project)
コード例 #52
0
 def setup_models(self):
     self.project = ProjectFactory.create()
     self.locations = SpatialUnitFactory.create_batch(2,
                                                      project=self.project)
     SpatialUnitFactory.create()
コード例 #53
0
 def test_left_and_right_project_ids(self):
     with pytest.raises(exceptions.ProjectRelationshipError):
         project = ProjectFactory()
         TenureRelationshipFactory.create(party__project=project)
コード例 #54
0
 def setup_models(self):
     self.project = ProjectFactory.create()
     self.location = SpatialUnitFactory.create(project=self.project)
     self.attached = ResourceFactory.create(project=self.project,
                                            content_object=self.location)
     self.unattached = ResourceFactory.create(project=self.project)
コード例 #55
0
 def test_get_schema_attrs_empty(self):
     project = ProjectFactory.create()
     content_type = ContentType.objects.get(app_label='spatial',
                                            model='spatialunit')
     exporter = Exporter(project)
     assert exporter.get_schema_attrs(content_type) == {}
コード例 #56
0
 def setup_models(self):
     self.project = ProjectFactory.create()
     self.location = SpatialUnitFactory.create(project=self.project)
コード例 #57
0
    def setUp(self):
        super().setUp()
        self.project = ProjectFactory.create(current_questionnaire='123abc')
        self.spatial_content_type = ContentType.objects.get(
            app_label='spatial', model='spatialunit')
        sp_schema = Schema.objects.create(
            content_type=self.spatial_content_type,
            selectors=(
                self.project.organization.id,
                self.project.id,
                '123abc',
            ))
        attr_type_text = AttributeType.objects.get(name='text')
        attr_type_int = AttributeType.objects.get(name='integer')
        attr_type_dec = AttributeType.objects.get(name='decimal')
        Attribute.objects.create(schema=sp_schema,
                                 name='key',
                                 long_name='Test field',
                                 attr_type=attr_type_text,
                                 index=0,
                                 required=False,
                                 omit=False)
        Attribute.objects.create(schema=sp_schema,
                                 name='integer',
                                 long_name='Test integer field',
                                 attr_type=attr_type_int,
                                 index=1,
                                 required=False,
                                 omit=False)
        Attribute.objects.create(schema=sp_schema,
                                 name='decimal',
                                 long_name='Test decimal field',
                                 attr_type=attr_type_dec,
                                 index=2,
                                 required=False,
                                 omit=False)
        self.spatialunit_1 = SpatialUnitFactory.create(project=self.project,
                                                       geometry='POINT (1 1)',
                                                       attributes={
                                                           'key': 'value 1',
                                                           'integer': '1',
                                                           'decimal': '1.0'
                                                       })
        self.spatialunit_2 = SpatialUnitFactory.create(project=self.project,
                                                       geometry='POINT (2 2)',
                                                       attributes={
                                                           'key': 'value 2',
                                                           'integer': '2',
                                                           'decimal': '2.0'
                                                       })
        self.spatialunits = [self.spatialunit_1, self.spatialunit_2]
        self.spatial_attrs = ['id', 'geometry.ewkt']

        self.party_content_type = ContentType.objects.get(app_label='party',
                                                          model='party')
        pt_schema = Schema.objects.create(content_type=self.party_content_type,
                                          selectors=(
                                              self.project.organization.id,
                                              self.project.id,
                                              '123abc',
                                          ))
        pt_schema_in = Schema.objects.create(
            content_type=self.party_content_type,
            selectors=(self.project.organization.id, self.project.id, '123abc',
                       'IN'))
        pt_schema_gr = Schema.objects.create(
            content_type=self.party_content_type,
            selectors=(self.project.organization.id, self.project.id, '123abc',
                       'GR'))
        attr_type = AttributeType.objects.get(name='text')
        Attribute.objects.create(schema=pt_schema,
                                 name='default_attr',
                                 long_name='Test field',
                                 attr_type=attr_type,
                                 index=0,
                                 required=False,
                                 omit=False)
        Attribute.objects.create(schema=pt_schema_in,
                                 name='party_in',
                                 long_name='Test IN field',
                                 attr_type=attr_type,
                                 index=0,
                                 required=False,
                                 omit=False)
        Attribute.objects.create(schema=pt_schema_gr,
                                 name='party_gr',
                                 long_name='Test GR field',
                                 attr_type=attr_type,
                                 index=0,
                                 required=False,
                                 omit=False)
        party_in = PartyFactory.create(project=self.project,
                                       type='IN',
                                       attributes={
                                           'default_attr': 'Test Schema',
                                           'party_in': 'Test IN attribute'
                                       })
        party_gr = PartyFactory.create(project=self.project,
                                       type='GR',
                                       attributes={
                                           'default_attr':
                                           'Another Test Schema',
                                           'party_gr': 'Test GR attribute'
                                       })
        self.parties = [party_in, party_gr]

        TenureRelationshipFactory.create(project=self.project,
                                         party=self.parties[0],
                                         spatial_unit=self.spatialunit_1)
コード例 #58
0
 def setup_models(self):
     self.user = UserFactory.create()
     assign_policies(self.user)
     self.prj = ProjectFactory.create(slug='test-project', access='public')
コード例 #59
0
 def test_project_relationship_invalid(self):
     with pytest.raises(exceptions.ProjectRelationshipError):
         project = ProjectFactory()
         SpatialRelationshipFactory(su1__project=project,
                                    su2__project=project)
コード例 #60
0
 def test_init_without_questionnaire(self):
     project = ProjectFactory.create()
     form = forms.PartyForm(project)
     assert hasattr(form.fields['name'], 'labels_xlang') is False
     assert hasattr(form.fields['type'], 'labels_xlang') is False