예제 #1
0
    def test_toggle_badge_on(self, cli):
        org = OrganizationFactory()

        cli('badges', 'toggle', str(org.id), PUBLIC_SERVICE)

        org.reload()
        assert org.badges[0].kind == PUBLIC_SERVICE
예제 #2
0
    def test_org_admin_can_accept_transfer(self):
        owner = UserFactory()
        admin = UserFactory()
        org = OrganizationFactory(members=[Member(user=admin, role='admin')])
        subject = VisibleDatasetFactory(owner=owner)
        transfer = TransferFactory(owner=owner,
                                   recipient=org,
                                   subject=subject)

        owner.reload()  # Needs updated metrics
        assert owner.metrics['datasets'] == 1

        org.reload()  # Needs updated metrics
        assert org.metrics['datasets'] == 0

        admin.reload()  # Needs updated metrics
        assert admin.metrics['datasets'] == 0

        login_user(admin)
        transfer = accept_transfer(transfer)

        assert transfer.status == 'accepted'

        subject.reload()
        assert subject.organization == org
        assert subject.owner is None

        org.reload()
        assert org.metrics['datasets'] == 1

        admin.reload()
        assert admin.metrics['datasets'] == 0

        owner.reload()
        assert owner.metrics['datasets'] == 0
예제 #3
0
    def test_toggle_badge_off(self, cli):
        ps_badge = Badge(kind=PUBLIC_SERVICE)
        certified_badge = Badge(kind=CERTIFIED)
        org = OrganizationFactory(badges=[ps_badge, certified_badge])

        cli('badges', 'toggle', str(org.id), PUBLIC_SERVICE)

        org.reload()
        assert org.badges[0].kind == CERTIFIED
예제 #4
0
    def test_organizations_within_sitemap(self, sitemap):
        '''It should return an organization list from the sitemap.'''
        organizations = OrganizationFactory.create_batch(3)

        sitemap.fetch()

        for org in organizations:
            url = sitemap.get_by_url('organizations.show_redirect', org=org)
            assert url is not None
            sitemap.assert_url(url, 0.7, 'weekly')
예제 #5
0
    def test_minimal(self):
        org = OrganizationFactory.build()  # Does not have an URL
        o = organization_to_rdf(org)
        g = o.graph

        self.assertIsInstance(o, RdfResource)
        self.assertEqual(len(list(g.subjects(RDF.type, FOAF.Organization))), 1)

        self.assertEqual(o.value(RDF.type).identifier, FOAF.Organization)

        self.assertIsInstance(o.identifier, BNode)
        self.assertEqual(o.value(FOAF.name), Literal(org.name))
        self.assertEqual(o.value(RDFS.label), Literal(org.name))
예제 #6
0
def swaggerui():
    page_size = 10
    params = {"datasets": "many"}
    organizations = search.iter(Organization)
    organizations = list(itertools.islice(organizations, page_size))
    if len(organizations) < page_size:
        # Fill with dummy values
        needs = page_size - len(organizations)
        extra_orgs = OrganizationFactory.build_batch(needs)
        for org in extra_orgs:
            org.id = ObjectId()
            Organization.slug.generate()
        organizations.extend(extra_orgs)
    return theme.render('apidoc.html', specs_url=api.specs_url, organizations=organizations)
예제 #7
0
    def test_my_org_reuses_with_search(self):
        user = self.login()
        member = Member(user=user, role='editor')
        organization = OrganizationFactory(members=[member])
        reuses = [
            ReuseFactory(owner=user, title='foô'),
        ]
        org_reuses = [
            ReuseFactory(organization=organization, title='foô'),
        ]

        # Should not be listed.
        ReuseFactory(owner=user)
        ReuseFactory(organization=organization)

        response = self.get(url_for('api.my_org_reuses'), qs={'q': 'foô'})
        self.assert200(response)
        self.assertEqual(len(response.json), len(reuses) + len(org_reuses))
예제 #8
0
    def test_unfollow_org(self):
        '''It should unfollow the organization on DELETE'''
        user = self.login()
        to_follow = OrganizationFactory()
        Follow.objects.create(follower=user, following=to_follow)

        response = self.delete(
            url_for('api.organization_followers', id=to_follow.id))
        self.assert200(response)

        nb_followers = Follow.objects.followers(to_follow).count()

        self.assertEqual(nb_followers, 0)
        self.assertEqual(response.json['followers'], nb_followers)

        self.assertEqual(Follow.objects.following(to_follow).count(), 0)
        self.assertEqual(Follow.objects.following(user).count(), 0)
        self.assertEqual(Follow.objects.followers(user).count(), 0)
예제 #9
0
    def test_my_org_datasets_with_search(self):
        user = self.login()
        member = Member(user=user, role='editor')
        organization = OrganizationFactory(members=[member])
        datasets = [
            VisibleDatasetFactory(owner=user, title='foo'),
        ]
        org_datasets = [
            VisibleDatasetFactory(organization=organization, title='foo'),
        ]

        # Should not be listed.
        VisibleDatasetFactory(owner=user)
        VisibleDatasetFactory(organization=organization)

        response = self.get(url_for('api.my_org_datasets'), qs={'q': 'foo'})
        self.assert200(response)
        self.assertEqual(len(response.json), len(datasets) + len(org_datasets))
    def test_suggest_organizations_by_id(self, api, autoindex):
        '''It should suggest an organization by its ID'''
        with autoindex:
            orgs = OrganizationFactory.create_batch(3)

        first_org = orgs[0]
        response = api.get(url_for('api.suggest_organizations'),
                           qs={
                               'q': str(first_org.id),
                               'size': '5'
                           })
        assert200(response)

        # The batch factory generates ids that might be too close
        # which then are found with the fuzzy search.
        suggested_ids = [u['id'] for u in response.json]
        assert len(suggested_ids) >= 1
        assert str(first_org.id) in suggested_ids
예제 #11
0
    def test_idempotence(self):
        filename = 'flat.jsonld'
        url = mock_dcat(filename)
        org = OrganizationFactory()
        source = HarvestSourceFactory(backend='dcat',
                                      url=url,
                                      organization=org)

        # Run the same havester twice
        actions.run(source.slug)
        actions.run(source.slug)

        datasets = {d.extras['dct:identifier']: d for d in Dataset.objects}

        self.assertEqual(len(datasets), 3)
        self.assertEqual(len(datasets['1'].resources), 2)
        self.assertEqual(len(datasets['2'].resources), 2)
        self.assertEqual(len(datasets['3'].resources), 1)
예제 #12
0
    def test_all_fields(self):
        org = OrganizationFactory(url=faker.uri())
        org_url = url_for('organizations.show_redirect',
                          org=org.id,
                          _external=True)
        o = organization_to_rdf(org)
        g = o.graph

        self.assertIsInstance(o, RdfResource)
        self.assertEqual(len(list(g.subjects(RDF.type, FOAF.Organization))), 1)

        self.assertEqual(o.value(RDF.type).identifier, FOAF.Organization)

        self.assertIsInstance(o.identifier, URIRef)
        self.assertEqual(o.identifier.toPython(), org_url)
        self.assertEqual(o.value(FOAF.name), Literal(org.name))
        self.assertEqual(o.value(RDFS.label), Literal(org.name))
        self.assertEqual(o.value(FOAF.homepage).identifier, URIRef(org.url))
예제 #13
0
    def test_supported_mime_type(self, rmock):
        url = mock_dcat(rmock, 'catalog.xml', path='without/extension')
        rmock.head(url,
                   headers={'Content-Type': 'application/xml; charset=utf-8'})
        org = OrganizationFactory()
        source = HarvestSourceFactory(backend='dcat',
                                      url=url,
                                      organization=org)

        actions.run(source.slug)

        source.reload()

        job = source.get_last_job()

        assert job.status == 'done'
        assert job.errors == []
        assert len(job.items) == 3
예제 #14
0
    def test_suggest_organizations_by_id(self):
        '''It should suggest an organization by its ID'''
        with self.autoindex():
            orgs = OrganizationFactory.create_batch(3)

        first_org = orgs[0]
        response = self.get(url_for('api.suggest_organizations'),
                            qs={
                                'q': str(first_org.id),
                                'size': '5'
                            })
        self.assert200(response)

        # The batch factory generates ids that might be too close
        # which then are found with the fuzzy search.
        suggested_ids = [u['id'] for u in response.json]
        self.assertGreaterEqual(len(suggested_ids), 1)
        self.assertIn(str(first_org.id), suggested_ids)
예제 #15
0
    def test_create_badge_public_service_mail(self):
        member = Member(user=self.user, role='admin')
        org = OrganizationFactory(members=[member])

        data = self.factory.as_dict()
        data['kind'] = PUBLIC_SERVICE

        with self.capture_mails() as mails:
            self.post(url_for('api.organization_badges', org=org), data)
            # do it a second time, no email expected for this one
            self.post(
                url_for('api.organization_badges', org=self.organization),
                data)

        # Should have sent one mail to each member of organization
        members_emails = [m.user.email for m in org.members]
        self.assertEqual(len(mails), len(members_emails))
        self.assertListEqual([m.recipients[0] for m in mails], members_emails)
예제 #16
0
 def test_regions_with_other_datasets_logged_in(self):
     self.login()
     with self.autoindex():
         organization = OrganizationFactory()
         VisibleDatasetFactory.create_batch(
             3,
             organization=organization,
             spatial=SpatialCoverageFactory(zones=[self.paca.id]))
     response = self.client.get(
         url_for('territories.territory', territory=self.paca))
     self.assert200(response)
     data = response.data.decode('utf-8')
     base_datasets = self.get_context_variable('base_datasets')
     self.assertEqual(len(base_datasets), 0)
     other_datasets = self.get_context_variable('other_datasets')
     self.assertEqual(len(other_datasets), 3)
     self.assertEqual(self.get_context_variable('territory_datasets'), [])
     self.assertIn('If you want your datasets to appear in that list', data)
    def test_unfollow_org(self, api):
        '''It should unfollow the organization on DELETE'''
        user = api.login()
        to_follow = OrganizationFactory()
        Follow.objects.create(follower=user, following=to_follow)

        url = url_for('api.organization_followers', id=to_follow.id)
        response = api.delete(url)
        assert200(response)

        nb_followers = Follow.objects.followers(to_follow).count()

        assert nb_followers is 0
        assert response.json['followers'] == nb_followers

        assert Follow.objects.following(to_follow).count() is 0
        assert Follow.objects.following(user).count() is 0
        assert Follow.objects.followers(user).count() is 0
예제 #18
0
    def test_set_organization_if_permissions(self):
        Ownable, OwnableForm = self.factory()
        user = UserFactory()
        member = Member(user=user, role='editor')
        org = OrganizationFactory(members=[member])
        ownable = Ownable(owner=user)

        login_user(user)

        form = OwnableForm(MultiDict({'organization': str(org.id)}),
                           obj=ownable)

        self.assertTrue(form.validate())
        self.assertEqual(form.errors, {})

        form.populate_obj(ownable)
        self.assertIsNone(ownable.owner)
        self.assertEqual(ownable.organization, org)
예제 #19
0
    def test_unsupported_mime_type(self, rmock):
        url = DCAT_URL_PATTERN.format(path='', domain=TEST_DOMAIN)
        rmock.head(url, headers={'Content-Type': 'text/html; charset=utf-8'})
        org = OrganizationFactory()
        source = HarvestSourceFactory(backend='dcat',
                                      url=url,
                                      organization=org)

        actions.run(source.slug)

        source.reload()

        job = source.get_last_job()

        assert job.status == 'failed'
        assert len(job.errors) == 1

        error = job.errors[0]
        assert error.message == 'Unsupported mime type "text/html"'
예제 #20
0
    def test_suggest_organizations_with_multiple_words(self, api):
        '''It should suggest organizations with words'''
        for i in range(4):
            OrganizationFactory(
                name='mon testé-{0}'.format(i) if i % 2 else faker.word())

        response = api.get(url_for('api.suggest_organizations'),
                           qs={'q': 'mon testé', 'size': '5'})
        assert200(response)

        assert len(response.json) <= 5
        assert len(response.json) > 1

        for suggestion in response.json:
            assert 'id' in suggestion
            assert 'slug' in suggestion
            assert 'name' in suggestion
            assert 'image_url' in suggestion
            assert 'mon testé' in suggestion['name']
예제 #21
0
    def test_list_org_discussions(self, api):
        '''Should list organization discussions'''
        user = UserFactory()
        org = OrganizationFactory()
        reuse = ReuseFactory(organization=org)
        dataset = DatasetFactory(organization=org)
        discussions = [
            Discussion.objects.create(subject=dataset, title='', user=user),
            Discussion.objects.create(subject=reuse, title='', user=user)
        ]

        response = api.get(url_for('api.org_discussions', org=org))

        assert200(response)
        assert len(response.json) == len(discussions)

        discussions_ids = [str(d.id) for d in discussions]
        for discussion in response.json:
            assert discussion['id'] in discussions_ids
예제 #22
0
 def test_with_old_region_datasets(self):
     lr, occitanie = create_old_new_regions_fixtures()
     with self.autoindex():
         for region in [lr, occitanie]:
             organization = OrganizationFactory(zone=region.id)
             VisibleDatasetFactory.create_batch(
                 3, organization=organization,
                 spatial=SpatialCoverageFactory(zones=[region.id]))
     response = self.client.get(
         url_for('territories.territory', territory=occitanie))
     self.assert200(response)
     data = response.data.decode('utf-8')
     self.assertIn(occitanie.name, data)
     base_datasets = self.get_context_variable('base_datasets')
     self.assertEqual(len(base_datasets), 0)
     territory_datasets = self.get_context_variable('territory_datasets')
     self.assertEqual(len(territory_datasets), 3)
     territory_datasets = self.get_context_variable('other_datasets')
     self.assertEqual(len(territory_datasets), 3)
예제 #23
0
    def test_create_source_with_org(self, api):
        '''It should create and attach a new source to an organization'''
        user = api.login()
        member = Member(user=user, role='admin')
        org = OrganizationFactory(members=[member])
        data = {
            'name': faker.word(),
            'url': faker.url(),
            'backend': 'factory',
            'organization': str(org.id)
        }
        response = api.post(url_for('api.harvest_sources'), data)

        assert201(response)

        source = response.json
        assert source['validation']['state'] == VALIDATION_PENDING
        assert source['owner'] is None
        assert source['organization']['id'] == str(org.id)
예제 #24
0
    def test_render_display_with_private_reuses(self):
        '''It should render the organization page with some private reuses'''
        me = self.login()
        member = Member(user=me, role='editor')
        organization = OrganizationFactory(members=[member])
        reuses = [ReuseFactory(organization=organization) for _ in range(2)]
        private_reuses = [
            VisibleReuseFactory(organization=organization, private=True)
            for _ in range(2)
        ]
        response = self.get(url_for('organizations.show', org=organization))

        self.assert200(response)
        rendered_reuses = self.get_context_variable('reuses')
        self.assertEqual(len(rendered_reuses), 0)

        rendered_private_reuses = self.get_context_variable('private_reuses')
        self.assertEqual(len(rendered_private_reuses),
                         len(reuses) + len(private_reuses))
예제 #25
0
    def test_create_with_file_chunks(self):
        '''It should create a resource from the API with a chunked file'''
        user = self.login()
        with self.autoindex():
            org = OrganizationFactory(
                members=[Member(user=user, role='admin')])
            dataset = DatasetFactory(organization=org)

        uuid = str(uuid4())
        parts = 4
        url = url_for('api.upload_new_dataset_resource', dataset=dataset)

        for i in range(parts):
            response = self.post(url, {
                'file': (StringIO(b'a'), 'blob'),
                'uuid': uuid,
                'filename': 'test.txt',
                'partindex': i,
                'partbyteoffset': 0,
                'totalfilesize': parts,
                'totalparts': parts,
                'chunksize': 1,
            },
                                 json=False)

            self.assert200(response)
            assert response.json['success']
            assert 'filename' not in response.json
            assert 'url' not in response.json
            assert 'size' not in response.json
            assert 'sha1' not in response.json
            assert 'url' not in response.json

        response = self.post(url, {
            'uuid': uuid,
            'filename': 'test.txt',
            'totalfilesize': parts,
            'totalparts': parts,
        },
                             json=False)
        self.assert201(response)
        data = json.loads(response.data)
        self.assertEqual(data['title'], 'test.txt')
예제 #26
0
    def test_unsupported_mime_type(self):
        url = DCAT_URL_PATTERN.format(path='', domain=TEST_DOMAIN)
        httpretty.register_uri(httpretty.HEAD, url, content_type='text/html; charset=utf-8')
        org = OrganizationFactory()
        source = HarvestSourceFactory(backend='dcat',
                                      url=url,
                                      organization=org)

        actions.run(source.slug)

        source.reload()

        job = source.get_last_job()

        self.assertEqual(job.status, 'failed')
        self.assertEqual(len(job.errors), 1)

        error = job.errors[0]
        self.assertEqual(error.message, 'Unsupported mime type "text/html"')
예제 #27
0
 def test_oembed_region_territory_api_get(self):
     '''It should fetch a region territory in the oembed format.'''
     midi_pyrenees = GeoZoneFactory(id='fr/region/73',
                                    level='fr/region',
                                    name='Midi-Pyrénées',
                                    code='73')
     licence_ouverte = LicenseFactory(id='fr-lo', title='Licence Ouverte')
     LicenseFactory(id='notspecified', title='Not Specified')
     for territory_dataset_class in TERRITORY_DATASETS['region'].values():
         organization = OrganizationFactory(
             id=territory_dataset_class.organization_id)
         territory = territory_dataset_class(midi_pyrenees)
         reference = 'territory-{id}'.format(id=territory.slug)
         response = self.get(url_for('api.oembeds', references=reference))
         self.assert200(response)
         data = json.loads(response.data)[0]
         self.assertIn('html', data)
         self.assertIn('width', data)
         self.assertIn('maxwidth', data)
         self.assertIn('height', data)
         self.assertIn('maxheight', data)
         self.assertTrue(data['type'], 'rich')
         self.assertTrue(data['version'], '1.0')
         self.assertIn(territory.title, data['html'])
         self.assertIn(cgi.escape(territory.url), data['html'])
         self.assertIn('alt="{name}"'.format(name=organization.name),
                       data['html'])
         self.assertIn(md(territory.description, source_tooltip=True),
                       data['html'])
         self.assertIn('Download from localhost', data['html'])
         self.assertIn('Add to your own website', data['html'])
         if territory_dataset_class not in (
                 TERRITORY_DATASETS['region']['comptes_r'],
                 TERRITORY_DATASETS['region']['zonages_r']):
             self.assertIn(
                 'License: {title}'.format(title=licence_ouverte.title),
                 data['html'])
             self.assertIn(
                 '© {license_id}'.format(license_id=licence_ouverte.id),
                 data['html'])
             self.assertIn(
                 '<a data-tooltip="Source" href="http://localhost/datasets',
                 data['html'])
예제 #28
0
 def test_counties_with_other_datasets_logged_in(self):
     self.login()
     with self.autoindex():
         organization = OrganizationFactory()
         for _ in range(3):
             VisibleDatasetFactory(
                 organization=organization,
                 spatial=SpatialCoverageFactory(zones=[self.bdr.id]))
     response = self.client.get(
         url_for('territories.territory', territory=self.bdr))
     self.assert200(response)
     data = response.data.decode('utf-8')
     base_datasets = self.get_context_variable('base_datasets')
     self.assertEqual(len(base_datasets), 0)
     other_datasets = self.get_context_variable('other_datasets')
     self.assertEqual(len(other_datasets), 3)
     self.assertFalse(self.get_context_variable('has_pertinent_datasets'))
     self.assertEqual(self.get_context_variable('territory_datasets'), [])
     self.assertIn('If you want your datasets to appear in that list', data)
예제 #29
0
    def test_with_organization_object_from_json(self):
        Ownable, OwnableForm = self.factory()
        user = UserFactory()
        member = Member(user=user, role='editor')
        org = OrganizationFactory(members=[member])

        login_user(user)

        form = OwnableForm.from_json({'organization': {'id': str(org.id)}})

        self.assertEqual(form.organization.data, org)

        form.validate()
        self.assertEqual(form.errors, {})

        ownable = Ownable()
        form.populate_obj(ownable)
        self.assertIsNone(ownable.owner)
        self.assertEqual(ownable.organization, org)
예제 #30
0
    def test_recent_feed_org(self):
        owner = UserFactory()
        org = OrganizationFactory()
        DatasetFactory(
            owner=owner, organization=org, resources=[ResourceFactory()])

        response = self.get(url_for('datasets.recent_feed'))

        self.assert200(response)

        feed = feedparser.parse(response.data)

        self.assertEqual(len(feed.entries), 1)
        entry = feed.entries[0]
        self.assertEqual(len(entry.authors), 1)
        author = entry.authors[0]
        self.assertEqual(author.name, org.name)
        self.assertEqual(author.href,
                         self.full_url('organizations.show', org=org.id))
예제 #31
0
 def test_oembed_town_territory_api_get(self):
     '''It should fetch a town territory in the oembed format.'''
     paca, bdr, arles = create_geozones_fixtures()
     licence_ouverte = LicenseFactory(id='fr-lo', title='Licence Ouverte')
     odbl_license = LicenseFactory(id='odc-odbl', title='ODbL')
     LicenseFactory(id='notspecified', title='Not Specified')
     town_datasets = TERRITORY_DATASETS['commune']
     for territory_dataset_class in town_datasets.values():
         organization = OrganizationFactory(
             id=territory_dataset_class.organization_id)
         territory = territory_dataset_class(arles)
         reference = 'territory-{id}'.format(id=territory.slug)
         response = self.get(url_for('api.oembeds', references=reference))
         self.assert200(response)
         data = json.loads(response.data)[0]
         self.assertIn('html', data)
         self.assertIn('width', data)
         self.assertIn('maxwidth', data)
         self.assertIn('height', data)
         self.assertIn('maxheight', data)
         self.assertTrue(data['type'], 'rich')
         self.assertTrue(data['version'], '1.0')
         self.assertIn(territory.title, data['html'])
         self.assertIn(cgi.escape(territory.url), data['html'])
         self.assertIn('alt="{name}"'.format(name=organization.name),
                       data['html'])
         self.assertIn(md(territory.description, source_tooltip=True),
                       data['html'])
         self.assertIn('Download from localhost', data['html'])
         self.assertIn('Add to your own website', data['html'])
         if territory_dataset_class not in (town_datasets['comptes_com'], ):
             if territory_dataset_class == town_datasets['ban_odbl_com']:
                 license = odbl_license
             else:
                 license = licence_ouverte
             self.assertIn('License: {title}'.format(title=license.title),
                           data['html'])
             self.assertIn('© {license_id}'.format(license_id=license.id),
                           data['html'])
             self.assertIn(
                 '<a data-tooltip="Source" href="http://localhost/datasets',
                 data['html'])
예제 #32
0
    def test_issues_for_user_with_org(self):
        user = UserFactory()
        member = Member(user=user, role='editor')
        org = OrganizationFactory(members=[member])
        dataset = DatasetFactory(organization=org)
        reuse = ReuseFactory(organization=org)

        open_issues = []
        for i in range(3):
            sender = UserFactory()
            message = Message(content=faker.sentence(), posted_by=sender)
            open_issues.append(Issue.objects.create(
                subject=dataset,
                user=sender,
                title=faker.sentence(),
                discussion=[message]
            ))
            open_issues.append(Issue.objects.create(
                subject=reuse,
                user=sender,
                title=faker.sentence(),
                discussion=[message]
            ))
        # Creating a closed issue that shouldn't show up in response.
        other_user = UserFactory()
        message = Message(content=faker.sentence(), posted_by=other_user)
        Issue.objects.create(
            subject=dataset,
            user=other_user,
            title=faker.sentence(),
            discussion=[message],
            closed=datetime.now(),
            closed_by=user
        )

        issues = issues_for(user)

        self.assertIsInstance(issues, db.BaseQuerySet)
        self.assertEqual(len(issues), len(open_issues))

        for issue in issues:
            self.assertIn(issue, open_issues)
예제 #33
0
    def test_simple_flat(self):
        filename = 'flat.jsonld'
        url = mock_dcat(filename)
        org = OrganizationFactory()
        source = HarvestSourceFactory(backend='dcat',
                                      url=url,
                                      organization=org)

        actions.run(source.slug)

        source.reload()

        job = source.get_last_job()
        self.assertEqual(len(job.items), 3)

        datasets = {d.extras['dct:identifier']: d for d in Dataset.objects}

        self.assertEqual(len(datasets), 3)

        for i in '1 2 3'.split():
            d = datasets[i]
            self.assertEqual(d.title, 'Dataset {0}'.format(i))
            self.assertEqual(d.description,
                             'Dataset {0} description'.format(i))
            self.assertEqual(d.extras['dct:identifier'], i)

        # First dataset
        dataset = datasets['1']
        self.assertEqual(
            dataset.tags,
            ['tag-1', 'tag-2', 'tag-3', 'tag-4', 'theme-1', 'theme-2'])
        self.assertEqual(len(dataset.resources), 2)

        # Second dataset
        dataset = datasets['2']
        self.assertEqual(dataset.tags, ['tag-1', 'tag-2', 'tag-3'])
        self.assertEqual(len(dataset.resources), 2)

        # Third dataset
        dataset = datasets['3']
        self.assertEqual(dataset.tags, ['tag-1', 'tag-2'])
        self.assertEqual(len(dataset.resources), 1)
예제 #34
0
    def test_unable_to_detect_format(self):
        url = DCAT_URL_PATTERN.format(path='', domain=TEST_DOMAIN)
        httpretty.register_uri(httpretty.HEAD, url, content_type='')
        org = OrganizationFactory()
        source = HarvestSourceFactory(backend='dcat',
                                      url=url,
                                      organization=org)

        actions.run(source.slug)

        source.reload()

        job = source.get_last_job()

        self.assertEqual(job.status, 'failed')
        self.assertEqual(len(job.errors), 1)

        error = job.errors[0]
        expected = 'Unable to detect format from extension or mime type'
        self.assertEqual(error.message, expected)
예제 #35
0
    def test_unable_to_detect_format(self, rmock):
        url = DCAT_URL_PATTERN.format(path='', domain=TEST_DOMAIN)
        rmock.head(url, headers={'Content-Type': ''})
        org = OrganizationFactory()
        source = HarvestSourceFactory(backend='dcat',
                                      url=url,
                                      organization=org)

        actions.run(source.slug)

        source.reload()

        job = source.get_last_job()

        assert job.status == 'failed'
        assert len(job.errors) == 1

        error = job.errors[0]
        expected = 'Unable to detect format from extension or mime type'
        assert error.message == expected
예제 #36
0
 def test_create_with_file(self):
     '''It should create a resource from the API with a file'''
     user = self.login()
     with self.autoindex():
         org = OrganizationFactory(
             members=[Member(user=user, role='admin')])
         dataset = DatasetFactory(organization=org)
     response = self.post(url_for('api.upload_new_dataset_resource',
                                  dataset=dataset),
                          {'file': (StringIO(b'aaa'), 'test.txt')},
                          json=False)
     self.assert201(response)
     data = json.loads(response.data)
     self.assertEqual(data['title'], 'test.txt')
     response = self.put(
         url_for('api.resource', dataset=dataset, rid=data['id']), data)
     self.assert200(response)
     dataset.reload()
     self.assertEqual(len(dataset.resources), 1)
     self.assertTrue(dataset.resources[0].url.endswith('test.txt'))