def test_pagination(self): site = SiteFactory() page_size = 3 total = 4 uri = url_for('site.rdf_catalog', _external=True) uri_first = url_for('site.rdf_catalog_format', format='json', page=1, page_size=page_size, _external=True) uri_last = url_for('site.rdf_catalog_format', format='json', page=2, page_size=page_size, _external=True) VisibleDatasetFactory.create_batch(total) # First page datasets = Dataset.objects.paginate(1, page_size) catalog = build_catalog(site, datasets, format='json') graph = catalog.graph assert isinstance(catalog, Resource) assert catalog.identifier == URIRef(uri) types = [o.identifier for o in catalog.objects(RDF.type)] assert DCAT.Catalog in types assert HYDRA.Collection in types assert catalog.value(HYDRA.totalItems) == Literal(total) assert len(list(catalog.objects(DCAT.dataset))) == page_size paginations = list(graph.subjects(RDF.type, HYDRA.PartialCollectionView)) assert len(paginations) == 1 pagination = graph.resource(paginations[0]) assert pagination.identifier == URIRef(uri_first) assert pagination.value(HYDRA.first).identifier == URIRef(uri_first) assert pagination.value(HYDRA.next).identifier == URIRef(uri_last) assert pagination.value(HYDRA.last).identifier == URIRef(uri_last) assert HYDRA.previous not in pagination # Second page datasets = Dataset.objects.paginate(2, page_size) catalog = build_catalog(site, datasets, format='json') graph = catalog.graph assert isinstance(catalog, Resource) assert catalog.identifier == URIRef(uri) types = [o.identifier for o in catalog.objects(RDF.type)] assert DCAT.Catalog in types assert HYDRA.Collection in types assert catalog.value(HYDRA.totalItems) == Literal(total) assert len(list(catalog.objects(DCAT.dataset))) == 1 paginations = list(graph.subjects(RDF.type, HYDRA.PartialCollectionView)) assert len(paginations) == 1 pagination = graph.resource(paginations[0]) assert pagination.identifier == URIRef(uri_last) assert pagination.value(HYDRA.first).identifier == URIRef(uri_first) assert pagination.value(HYDRA.previous).identifier == URIRef(uri_first) assert pagination.value(HYDRA.last).identifier == URIRef(uri_last) assert HYDRA.next not in pagination
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
def test_empty_search_with_filter_and_match(self): '''Should match both the topic criteria and the query''' with self.autoindex(): # Match both the topic condition but the queried tag match = VisibleDatasetFactory.create_batch(2, tags=[ 'in', 'filtered' ]) # Match the topic condition but not the queried tag no_match = VisibleDatasetFactory.create_batch(2, tags=['in']) # Excluded because not matching one of the topic tag excluded = VisibleDatasetFactory.create_batch(2, tags=[ 'out', 'filtered' ]) topic = TopicFactory(tags=['in', 'no-match']) query = topic_search_for(topic, DatasetSearch, tag='filtered') result = search.query(query) found = [d.id for d in result] self.assertEqual(len(found), 2) for dataset in match: self.assertIn(dataset.id, found) for dataset in no_match + excluded: self.assertNotIn(dataset.id, found)
def test_recipient_user_can_accept_transfer(self): owner = UserFactory() recipient = UserFactory() subject = VisibleDatasetFactory(owner=owner) transfer = TransferFactory(owner=owner, recipient=recipient, subject=subject) owner.reload() # Needs updated metrics assert owner.metrics['datasets'] == 1 recipient.reload() # Needs updated metrics assert recipient.metrics['datasets'] == 0 login_user(recipient) transfer = accept_transfer(transfer) assert transfer.status == 'accepted' subject.reload() assert subject.owner == recipient recipient.reload() assert recipient.metrics['datasets'] == 1 owner.reload() assert owner.metrics['datasets'] == 0
def test_empty_search_no_match(self): '''Should return no result if no data match the tags''' with self.autoindex(): VisibleDatasetFactory.create_batch(2, tags=['whatever']) topic = TopicFactory(tags=['no-match']) query = topic_search_for(topic, DatasetSearch) result = search.query(query) self.assertEqual(len(result), 0)
def test_minimal(self, app): site = SiteFactory() home_url = url_for('site.home_redirect', _external=True) uri = url_for('site.rdf_catalog', _external=True) datasets = VisibleDatasetFactory.create_batch(3) catalog = build_catalog(site, datasets) graph = catalog.graph assert isinstance(catalog, Resource) catalogs = graph.subjects(RDF.type, DCAT.Catalog) assert len(list(catalogs)) == 1 assert catalog.value(RDF.type).identifier == DCAT.Catalog assert isinstance(catalog.identifier, URIRef) assert str(catalog.identifier) == uri assert catalog.value(DCT.title) == Literal(site.title) lang = app.config['DEFAULT_LANGUAGE'] assert catalog.value(DCT.language) == Literal(lang) assert len(list(catalog.objects(DCAT.dataset))) == len(datasets) assert catalog.value(FOAF.homepage).identifier == URIRef(home_url) org = catalog.value(DCT.publisher) assert org.value(RDF.type).identifier == FOAF.Organization assert org.value(FOAF.name) == Literal(app.config['SITE_AUTHOR']) graph = catalog.graph graph_datasets = graph.subjects(RDF.type, DCAT.Dataset) assert len(list(graph_datasets)) == len(datasets)
def test_catalog_rdf_paginate(self, client): VisibleDatasetFactory.create_batch(4) url = url_for('site.rdf_catalog_format', format='n3', page_size=3) next_url = url_for('site.rdf_catalog_format', format='n3', page=2, page_size=3, _external=True) response = client.get(url) assert200(response) graph = Graph().parse(data=response.data, format='n3') pagination = graph.value(predicate=RDF.type, object=HYDRA.PartialCollectionView) assert pagination is not None pagination = graph.resource(pagination) assert not pagination.value(HYDRA.previous) assert pagination.value(HYDRA.next).identifier == URIRef(next_url)
def test_no_duplicate(self): site = SiteFactory() org = OrganizationFactory() user = UserFactory() datasets = VisibleDatasetFactory.create_batch(2, owner=user) datasets += VisibleDatasetFactory.create_batch(2, organization=org) catalog = build_catalog(site, datasets) graph = catalog.graph orgs = list(graph.subjects(RDF.type, FOAF.Organization)) assert len(orgs) == 1 + 1 # There is the site publisher users = list(graph.subjects(RDF.type, FOAF.Person)) assert len(users) == 1 org_names = list(graph.objects(orgs[0], FOAF.name)) assert len(org_names) == 1 user_names = list(graph.objects(users[0], FOAF.name)) assert len(user_names) == 1
def test_empty_search_with_match(self): '''Should only return data with at least one tag''' with self.autoindex(): included = VisibleDatasetFactory.create_batch(2, tags=['in']) excluded = VisibleDatasetFactory.create_batch(2, tags=['out']) topic = TopicFactory(tags=['in', 'no-match']) query = topic_search_for(topic, DatasetSearch) result = search.query(query) found = [d.id for d in result] self.assertEqual(len(found), 2) for dataset in included: self.assertIn(dataset.id, found) for dataset in excluded: self.assertNotIn(dataset.id, found)
def test_datasets_within_sitemap(self, sitemap): '''It should return a dataset list from the sitemap.''' datasets = VisibleDatasetFactory.create_batch(3) sitemap.fetch() for dataset in datasets: url = sitemap.get_by_url('datasets.show_redirect', dataset=dataset) assert url is not None sitemap.assert_url(url, 0.8, 'weekly')
def test_datasets_without_dynamic_region(self, autoindex, client): paca, bdr, arles = create_geozones_fixtures() with autoindex: organization = OrganizationFactory() for _ in range(3): VisibleDatasetFactory( organization=organization, spatial=SpatialCoverageFactory(zones=[paca.id])) response = client.get(url_for('api.zone_datasets', id=paca.id)) assert200(response) assert len(response.json) == 3
def test_zone_datasets(self): paca, bdr, arles = create_geozones_fixtures() with self.autoindex(): organization = OrganizationFactory() for _ in range(3): VisibleDatasetFactory( organization=organization, spatial=SpatialCoverageFactory(zones=[paca.id])) response = self.get(url_for('api.zone_datasets', id=paca.id)) self.assert200(response) self.assertEqual(len(response.json), 3)
def test_render_display_with_private_assets_only_member(self): '''It should render the organization page without private and empty assets''' organization = OrganizationFactory() datasets = [ VisibleDatasetFactory(organization=organization) for _ in range(2) ] reuses = [ VisibleReuseFactory(organization=organization) for _ in range(2) ] for _ in range(2): DatasetFactory(organization=organization, resources=[]) # Empty asset VisibleDatasetFactory(organization=organization, private=True) ReuseFactory(organization=organization, datasets=[]) # Empty asset VisibleReuseFactory(organization=organization, private=True) response = self.get(url_for('organizations.show', org=organization)) self.assert200(response) rendered_datasets = self.get_context_variable('datasets') self.assertEqual(len(rendered_datasets), len(datasets)) rendered_reuses = self.get_context_variable('reuses') self.assertEqual(len(rendered_reuses), len(reuses)) rendered_private_datasets = [ dataset for dataset in rendered_datasets if dataset.private ] self.assertEqual(len(rendered_private_datasets), 0) rendered_private_reuses = [ reuse for reuse in rendered_reuses if reuse.private ] self.assertEqual(len(rendered_private_reuses), 0) total_datasets = self.get_context_variable('total_datasets') self.assertEqual(total_datasets, len(datasets)) total_reuses = self.get_context_variable('total_reuses') self.assertEqual(total_reuses, len(reuses))
def test_with_region_datasets(self): with self.autoindex(): organization = OrganizationFactory(zone=self.paca.id) 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') self.assertIn(self.paca.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) for dataset in territory_datasets: self.assertIn( '<div data-udata-dataset-id="{dataset.id}"'.format( dataset=dataset), data) self.assertEqual(self.get_context_variable('other_datasets'), []) self.assertNotIn('dataset-item--cta', data)
def test_counties_with_other_datasets(self): with self.autoindex(): organization = OrganizationFactory() VisibleDatasetFactory.create_batch( 3, 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') self.assertIn(self.bdr.name, data) 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) for dataset in other_datasets: self.assertIn( '<div data-udata-dataset-id="{dataset.id}"'.format( dataset=dataset), data) self.assertEqual(self.get_context_variable('territory_datasets'), []) self.assertIn('You want to add your own datasets to that list?', data)
def test_my_org_issues(self): user = self.login() member = Member(user=user, role='editor') organization = OrganizationFactory(members=[member]) reuse = ReuseFactory(owner=user) org_reuse = ReuseFactory(organization=organization) dataset = VisibleDatasetFactory(owner=user) org_dataset = VisibleDatasetFactory(organization=organization) sender = UserFactory() issues = [ Issue.objects.create(subject=s, title='', user=sender) for s in (dataset, org_dataset, reuse, org_reuse) ] # Should not be listed Issue.objects.create(subject=VisibleDatasetFactory(), title='', user=sender) Issue.objects.create(subject=ReuseFactory(), title='', user=sender) response = self.get(url_for('api.my_org_issues')) self.assert200(response) self.assertEqual(len(response.json), len(issues))
def test_zone_datasets_with_dynamic_and_setting(self): paca, bdr, arles = create_geozones_fixtures() organization = OrganizationFactory() for _ in range(3): VisibleDatasetFactory( organization=organization, spatial=SpatialCoverageFactory(zones=[paca.id])) response = self.get(url_for('api.zone_datasets', id=paca.id), qs={'dynamic': 1}) self.assert200(response) # No dynamic datasets given that they are added by udata-front extension. self.assertEqual(len(response.json), 3)
def test_render_datasets(self): '''It should render a topic datasets page''' with self.autoindex(): [VisibleDatasetFactory(tags=['tag-{0}'.format(i)]) for i in range(3)] topic = TopicFactory(tags=['tag-0', 'tag-2']) response = self.get(url_for('topics.datasets', topic=topic)) self.assert200(response) rendered_datasets = self.get_context_variable('datasets') self.assertEqual(len(rendered_datasets), 2) for dataset in rendered_datasets: self.assertIn(dataset.tags[0], ['tag-0', 'tag-2'])
def test_dataset_api_delete(self): '''It should delete a dataset from the API''' user = self.login() with self.autoindex(): dataset = VisibleDatasetFactory(owner=user) response = self.delete(url_for('api.dataset', dataset=dataset)) self.assertStatus(response, 204) self.assertEqual(Dataset.objects.count(), 1) self.assertIsNotNone(Dataset.objects[0].deleted) response = self.get(url_for('api.datasets')) self.assert200(response) self.assertEqual(len(response.json['data']), 0)
def test_zone_datasets_with_dynamic(self): paca, bdr, arles = create_geozones_fixtures() with self.autoindex(): organization = OrganizationFactory() for _ in range(3): VisibleDatasetFactory( organization=organization, spatial=SpatialCoverageFactory(zones=[paca.id])) response = self.get( url_for('api.zone_datasets', id=paca.id), qs={'dynamic': 1}) self.assert200(response) # No dynamic datasets given that the setting is deactivated by default. self.assertEqual(len(response.json), 3)
def test_regions_with_other_datasets_and_pertinent_ones(self): user = self.login() with self.autoindex(): member = Member(user=user, role='admin') organization = OrganizationFactory(members=[member]) 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') self.assertIn(self.paca.name, data) 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) for dataset in other_datasets: self.assertIn( '<div data-udata-dataset-id="{dataset.id}"'.format( dataset=dataset), data) self.assertEqual(self.get_context_variable('territory_datasets'), [])
def test_my_org_discussions(self): user = self.login() member = Member(user=user, role='editor') organization = OrganizationFactory(members=[member]) reuse = ReuseFactory(owner=user) org_reuse = ReuseFactory(organization=organization) dataset = VisibleDatasetFactory(owner=user) org_dataset = VisibleDatasetFactory(organization=organization) discussions = [ Discussion.objects.create(subject=dataset, title='', user=user), Discussion.objects.create(subject=org_dataset, title='', user=user), Discussion.objects.create(subject=reuse, title='', user=user), Discussion.objects.create(subject=org_reuse, title='', user=user), ] # Should not be listed Discussion.objects.create(subject=VisibleDatasetFactory(), title='', user=user) Discussion.objects.create(subject=ReuseFactory(), title='', user=user) response = self.get(url_for('api.my_org_discussions')) self.assert200(response) self.assertEqual(len(response.json), len(discussions))
def test_empty_search_with_filter_and_match(self): '''Should match both the topic criteria and the query''' with self.autoindex(): # Match both the topic condition but the queried tag match = VisibleDatasetFactory.create_batch(2, tags=['in', 'filtered']) # Match the topic condition but not the queried tag no_match = VisibleDatasetFactory.create_batch(2, tags=['in']) # Excluded because not matching one of the topic tag excluded = VisibleDatasetFactory.create_batch( 2, tags=['out', 'filtered']) topic = TopicFactory(tags=['in', 'no-match']) query = topic_search_for(topic, DatasetSearch, tag='filtered') result = search.query(query) found = [d.id for d in result] self.assertEqual(len(found), 2) for dataset in match: self.assertIn(dataset.id, found) for dataset in no_match + excluded: self.assertNotIn(dataset.id, found)
def generate_fixtures(datasets, reuses): '''Build sample fixture data (users, datasets and reuses).''' user = UserFactory() log.info('Generated user "{user.email}".'.format(user=user)) organization = OrganizationFactory(members=[Member(user=user)]) log.info('Generated organization "{org.name}".'.format(org=organization)) for _ in range(datasets): dataset = VisibleDatasetFactory(organization=organization) DiscussionFactory(subject=dataset, user=user) ReuseFactory.create_batch(reuses, datasets=[dataset], owner=user) msg = 'Generated {datasets} dataset(s) with {reuses} reuse(s) each.' log.info(msg.format(**locals()))
def test_community_resource_api_create_remote(self): '''It should create a remote community resource from the API''' user = self.login() dataset = VisibleDatasetFactory() attrs = CommunityResourceFactory.as_dict() attrs['dataset'] = str(dataset.id) response = self.post(url_for('api.community_resources'), attrs) self.assert201(response) data = json.loads(response.data) self.assertEqual(data['title'], attrs['title']) self.assertEqual(data['url'], attrs['url']) self.assertEqual(CommunityResource.objects.count(), 1) community_resource = CommunityResource.objects.first() self.assertEqual(community_resource.dataset, dataset) self.assertEqual(community_resource.owner, user) self.assertIsNone(community_resource.organization)
def test_render_display(self): '''It should render a topic page''' with self.autoindex(): reuses = [ VisibleReuseFactory(tags=['tag-{0}'.format(i)]) for i in range(3) ] datasets = [ VisibleDatasetFactory(tags=['tag-{0}'.format(i)]) for i in range(3) ] topic = TopicFactory(tags=['tag-0', 'tag-2'], datasets=datasets, reuses=reuses) response = self.get(url_for('topics.display', topic=topic)) self.assert200(response)
def test_regions_with_other_datasets_logged_in(self): self.login() with self.autoindex(): organization = OrganizationFactory() for _ in range(3): VisibleDatasetFactory( 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.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)
def test_community_resource_api_create(self): '''It should create a community resource from the API''' dataset = VisibleDatasetFactory() self.login() response = self.post(url_for('api.upload_new_community_resource', dataset=dataset), {'file': (StringIO(b'aaa'), 'test.txt')}, json=False) self.assert201(response) data = json.loads(response.data) resource_id = data['id'] self.assertEqual(data['title'], 'test.txt') response = self.put( url_for('api.community_resource', community=resource_id), data) self.assertStatus(response, 200) self.assertEqual(CommunityResource.objects.count(), 1) community_resource = CommunityResource.objects.first() self.assertEqual(community_resource.owner, self.user) self.assertIsNone(community_resource.organization)
def test_pending_transfer_request_for_user(self): user = UserFactory() datasets = VisibleDatasetFactory.create_batch(2, owner=user) recipient = UserFactory() comment = faker.sentence() transfers = {} login_user(user) for dataset in datasets: transfer = request_transfer(dataset, recipient, comment) transfers[transfer.id] = transfer assert len(transfer_request_notifications(user)) == 0 notifications = transfer_request_notifications(recipient) assert len(notifications) == len(datasets) for dt, details in notifications: transfer = transfers[details['id']] assert details['subject']['class'] == 'dataset' assert details['subject']['id'] == transfer.subject.id
def test_producer_should_send_a_message_with_payload_if_indexable(self): kafka_mock = Mock() KafkaProducerSingleton.get_instance = lambda: kafka_mock fake_data = VisibleDatasetFactory(id='61fd30cb29ea95c7bc0e1211') reindex.run(*as_task_param(fake_data)) producer = KafkaProducerSingleton.get_instance() expected_value = { 'service': 'udata', 'data': DatasetSearch.serialize(fake_data), 'meta': { 'message_type': 'dataset.index', 'index': 'dataset' } } topic = self.app.config['UDATA_INSTANCE_NAME'] + '.dataset.index' producer.send.assert_called_with(topic, value=expected_value, key=b'61fd30cb29ea95c7bc0e1211')
def test_community_resource_api_create_as_org(self): '''It should create a community resource as org from the API''' dataset = VisibleDatasetFactory() user = self.login() org = OrganizationFactory(members=[Member(user=user, role='admin')]) response = self.post(url_for('api.upload_new_community_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') resource_id = data['id'] data['organization'] = str(org.id) response = self.put( url_for('api.community_resource', community=resource_id), data) self.assertStatus(response, 200) self.assertEqual(CommunityResource.objects.count(), 1) community_resource = CommunityResource.objects.first() self.assertEqual(community_resource.organization, org) self.assertIsNone(community_resource.owner)
def test_count(self): for i in range(1, 4): # Tags should be normalized and deduplicated. tags = ['Tag "{0}"'.format(j) for j in range(i)] + ['tag-0'] VisibleDatasetFactory(tags=tags) VisibleReuseFactory(tags=tags) count_tags.run() expected = { 'tag-0': 3, 'tag-1': 2, 'tag-2': 1, } self.assertEqual(len(Tag.objects), len(expected)) for name, count in expected.items(): tag = Tag.objects.get(name=name) self.assertEqual(tag.total, 2 * count) self.assertEqual(tag.counts['datasets'], count) self.assertEqual(tag.counts['reuses'], count)
def test_pending_transfer_request_for_org(self): user = UserFactory() datasets = VisibleDatasetFactory.create_batch(2, owner=user) recipient = UserFactory() member = Member(user=recipient, role='editor') org = OrganizationFactory(members=[member]) comment = faker.sentence() transfers = {} login_user(user) for dataset in datasets: transfer = request_transfer(dataset, org, comment) transfers[transfer.id] = transfer self.assertEqual(len(transfer_request_notifications(user)), 0) notifications = transfer_request_notifications(recipient) self.assertEqual(len(notifications), len(datasets)) for dt, details in notifications: transfer = transfers[details['id']] self.assertEqual(details['subject']['class'], 'dataset') self.assertEqual(details['subject']['id'], transfer.subject.id)
def test_results_get_objects(self): data = [] for _ in range(3): random_dataset = VisibleDatasetFactory() data.append(DatasetSearch.serialize(random_dataset)) search_class = DatasetSearch.temp_search() search_query = search_class(params={}) service_result = { "data": data, "next_page": None, "page": 1, "previous_page": None, "page_size": 20, "total_pages": 1, "total": 3 } search_results = SearchResult(query=search_query, result=service_result.pop('data'), **service_result) assert len(search_results.get_objects()) == 3
def test_render_display_with_private_datasets(self): '''It should render the organization page with some private datasets''' me = self.login() member = Member(user=me, role='editor') organization = OrganizationFactory(members=[member]) datasets = [ DatasetFactory(organization=organization) for _ in range(2) ] private_datasets = [ VisibleDatasetFactory(organization=organization, private=True) for _ in range(2) ] response = self.get(url_for('organizations.show', org=organization)) self.assert200(response) rendered_datasets = self.get_context_variable('datasets') self.assertEqual(len(rendered_datasets), 0) rendered_private_datasets = self.get_context_variable( 'private_datasets') self.assertEqual(len(rendered_private_datasets), len(datasets) + len(private_datasets))
def test_coverage_for_level(self): GeoLevelFactory(id='top') GeoLevelFactory(id='sub', parents=['top']) GeoLevelFactory(id='child', parents=['sub']) topzones, subzones, childzones = [], [], [] for _ in range(2): zone = GeoZoneFactory(level='top') topzones.append(zone) for _ in range(2): subzone = GeoZoneFactory(level='sub', parents=[zone.id]) subzones.append(subzone) for _ in range(2): childzone = GeoZoneFactory( level='child', parents=[zone.id, subzone.id]) childzones.append(childzone) for zone in topzones + subzones + childzones: VisibleDatasetFactory( spatial=SpatialCoverageFactory(zones=[zone.id])) response = self.get(url_for('api.spatial_coverage', level='sub')) self.assert200(response) self.assertEqual(len(response.json['features']), len(subzones)) for feature in response.json['features']: self.assertEqual(feature['type'], 'Feature') zone = get_by(subzones, 'id', feature['id']) self.assertIsNotNone(zone) assert_json_equal(feature['geometry'], zone.geom) properties = feature['properties'] self.assertEqual(properties['name'], zone.name) self.assertEqual(properties['code'], zone.code) self.assertEqual(properties['level'], 'sub') # Nested levels datasets should be counted self.assertEqual(properties['datasets'], 3)
def test_reindex_model(self): kafka_mock = Mock() KafkaProducerSingleton.get_instance = lambda: kafka_mock fake_data = VisibleDatasetFactory(id='61fd30cb29ea95c7bc0e1211') producer = KafkaProducerSingleton.get_instance() index_model(DatasetSearch, start=datetime.datetime(2022, 2, 20, 20, 2), reindex=True) expected_value = { 'service': 'udata', 'data': DatasetSearch.serialize(fake_data), 'meta': { 'message_type': 'dataset.reindex', 'index': 'dataset-2022-02-20-20-02' } } topic = self.app.config['UDATA_INSTANCE_NAME'] + '.dataset.reindex' producer.send.assert_called_with(topic, value=expected_value, key=b'61fd30cb29ea95c7bc0e1211')
def test_community_resource_api_update_with_file(self): '''It should update a community resource file from the API''' dataset = VisibleDatasetFactory() user = self.login() community_resource = CommunityResourceFactory(dataset=dataset, owner=user) response = self.post(url_for('api.upload_community_resource', community=community_resource), {'file': (StringIO(b'aaa'), 'test.txt')}, json=False) self.assert200(response) data = json.loads(response.data) self.assertEqual(data['id'], str(community_resource.id)) self.assertEqual(data['title'], 'test.txt') data['description'] = 'new description' response = self.put( url_for('api.community_resource', community=community_resource), data) self.assert200(response) self.assertEqual(CommunityResource.objects.count(), 1) self.assertEqual(CommunityResource.objects.first().description, 'new description') self.assertTrue( CommunityResource.objects.first().url.endswith('test.txt'))
def test_render_display_with_private_assets_only_member(self): '''It should render the organization page without private assets''' organization = OrganizationFactory() for _ in range(2): DatasetFactory(organization=organization) VisibleDatasetFactory(organization=organization, private=True) ReuseFactory(organization=organization) VisibleReuseFactory(organization=organization, private=True) response = self.get(url_for('organizations.show', org=organization)) self.assert200(response) rendered_datasets = self.get_context_variable('datasets') self.assertEqual(len(rendered_datasets), 0) rendered_reuses = self.get_context_variable('reuses') self.assertEqual(len(rendered_reuses), 0) rendered_private_datasets = self.get_context_variable( 'private_datasets') self.assertEqual(len(rendered_private_datasets), 0) rendered_private_reuses = self.get_context_variable('private_reuses') self.assertEqual(len(rendered_private_reuses), 0)
def test_render_display(self): '''It should render the dataset page''' dataset = VisibleDatasetFactory() url = url_for('datasets.show', dataset=dataset) response = self.get(url) self.assert200(response)