def test_results_should_not_fail_on_missing_objects(self):
data = []
for _ in range(3):
random_dataset = VisibleDatasetFactory()
data.append(DatasetSearch.serialize(random_dataset))
to_delete_random_dataset = VisibleDatasetFactory()
data.append(DatasetSearch.serialize(to_delete_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)
to_delete_random_dataset.delete()
assert len(search_results.get_objects()) == 3
# Missing object should be filtered out
objects = search_results.objects
for o in objects:
assert isinstance(o, Dataset)
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 = [
VisibleDatasetFactory(organization=organization) for _ in range(2)
]
empty_datasets = [
DatasetFactory(organization=organization, resources=[])
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),
len(datasets) + len(private_datasets) + len(empty_datasets))
rendered_private_datasets = [
dataset for dataset in rendered_datasets if dataset.private
]
self.assertEqual(len(rendered_private_datasets), len(private_datasets))
total_datasets = self.get_context_variable('total_datasets')
self.assertEqual(
total_datasets,
len(datasets) + len(private_datasets) + len(empty_datasets))
def test_my_org_discussions_with_search(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='foô', user=user),
Discussion.objects.create(subject=org_reuse,
title='foô',
user=user),
]
# Should not be listed.
Discussion.objects.create(subject=reuse, title='', user=user),
Discussion.objects.create(subject=org_dataset, title='', user=user),
# Should really not be listed.
Discussion.objects.create(subject=VisibleDatasetFactory(),
title='foô',
user=user)
Discussion.objects.create(subject=ReuseFactory(),
title='foô',
user=user)
response = self.get(url_for('api.my_org_discussions'), qs={'q': 'foô'})
self.assert200(response)
self.assertEqual(len(response.json), len(discussions))
def test_index_model_from_datetime(self):
kafka_mock = Mock()
KafkaProducerSingleton.get_instance = lambda: kafka_mock
VisibleDatasetFactory(id='61fd30cb29ea95c7bc0e1211',
last_modified=datetime.datetime(2020, 1, 1))
fake_data = VisibleDatasetFactory(id='61fd30cb29ea95c7bc0e1212',
last_modified=datetime.datetime(
2022, 1, 1))
producer = KafkaProducerSingleton.get_instance()
index_model(DatasetSearch,
start=None,
from_datetime=datetime.datetime(2023, 1, 1))
producer.send.assert_not_called()
index_model(DatasetSearch,
start=None,
from_datetime=datetime.datetime(2021, 1, 1))
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'61fd30cb29ea95c7bc0e1212')
def test_dataset_api_search(self):
'''It should search datasets from the API'''
with self.autoindex():
[VisibleDatasetFactory() for i in range(2)]
dataset = VisibleDatasetFactory(title="some spécial chars")
response = self.get(url_for('api.datasets', q='spécial'))
self.assert200(response)
self.assertEqual(len(response.json['data']), 1)
self.assertEqual(response.json['data'][0]['id'], str(dataset.id))
def test_dataset_api_list_filtered_by_org(self):
'''It should fetch a dataset list for a given org'''
self.login()
with self.autoindex():
member = Member(user=self.user, role='editor')
org = OrganizationFactory(members=[member])
VisibleDatasetFactory()
dataset_org = VisibleDatasetFactory(organization=org)
response = self.get(url_for('api.datasets'),
qs={'organization': str(org.id)})
self.assert200(response)
self.assertEqual(len(response.json['data']), 1)
self.assertEqual(response.json['data'][0]['id'], str(dataset_org.id))
def test_my_org_datasets(self):
user = self.login()
member = Member(user=user, role='editor')
organization = OrganizationFactory(members=[member])
community_resources = [
VisibleDatasetFactory(owner=user) for _ in range(2)
]
org_datasets = [
VisibleDatasetFactory(organization=organization) for _ in range(2)
]
response = self.get(url_for('api.my_org_datasets'))
self.assert200(response)
self.assertEqual(len(response.json),
len(community_resources) + len(org_datasets))
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_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_dataset_archive_one(self, cli):
dataset = VisibleDatasetFactory()
cli('dataset', 'archive-one', str(dataset.id))
dataset.reload()
assert dataset.archived is not None
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
self.assertEqual(owner.metrics['datasets'], 1)
org.reload() # Needs updated metrics
self.assertEqual(org.metrics['datasets'], 0)
admin.reload() # Needs updated metrics
self.assertEqual(admin.metrics['datasets'], 0)
login_user(admin)
transfer = accept_transfer(transfer)
self.assertEqual(transfer.status, 'accepted')
subject.reload()
self.assertEqual(subject.organization, org)
self.assertIsNone(subject.owner)
org.reload()
self.assertEqual(org.metrics['datasets'], 1)
admin.reload()
self.assertEqual(admin.metrics['datasets'], 0)
owner.reload()
self.assertEqual(owner.metrics['datasets'], 0)
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])
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')
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.assertTrue(self.get_context_variable('has_pertinent_datasets'))
self.assertEqual(self.get_context_variable('territory_datasets'), [])
self.assertIn('Some of your datasets have an exact match!', data)
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
self.assertEqual(owner.metrics['datasets'], 1)
recipient.reload() # Needs updated metrics
self.assertEqual(recipient.metrics['datasets'], 0)
login_user(recipient)
transfer = accept_transfer(transfer)
self.assertEqual(transfer.status, 'accepted')
subject.reload()
self.assertEqual(subject.owner, recipient)
recipient.reload()
self.assertEqual(recipient.metrics['datasets'], 1)
owner.reload()
self.assertEqual(owner.metrics['datasets'], 0)
def test_reuse_metrics(self):
dataset = VisibleDatasetFactory()
reuse = VisibleReuseFactory()
issue = IssueFactory(subject=reuse)
DiscussionFactory(subject=reuse)
reuse.count_datasets()
reuse.count_issues()
reuse.count_discussions()
assert reuse.get_metrics()['datasets'] == 1
assert reuse.get_metrics()['issues'] == 1
assert reuse.get_metrics()['discussions'] == 1
with assert_emit(Reuse.on_update):
reuse.datasets.append(dataset)
reuse.save()
reuse.count_datasets()
assert reuse.get_metrics()['datasets'] == 2
dataset.count_reuses()
assert dataset.get_metrics()['reuses'] == 1
with assert_emit(Reuse.on_update):
reuse.datasets.remove(dataset)
reuse.save()
dataset_tasks.update_datasets_reuses_metrics()
dataset.reload()
assert dataset.get_metrics()['reuses'] == 0
def test_dataset_api_delete_deleted(self):
'''It should delete a deleted dataset from the API and raise 410'''
user = self.login()
dataset = VisibleDatasetFactory(owner=user, deleted=datetime.now())
response = self.delete(url_for('api.dataset', dataset=dataset))
self.assert410(response)
def test_request_transfer_user_to_organization(self):
user = UserFactory()
dataset = VisibleDatasetFactory(owner=user)
recipient = OrganizationFactory()
comment = faker.sentence()
login_user(user)
self.assert_transfer_started(dataset, user, recipient, comment)
def test_request_transfer_to_self(self):
user = UserFactory()
dataset = VisibleDatasetFactory(owner=user)
comment = faker.sentence()
login_user(user)
with pytest.raises(ValueError):
self.assert_transfer_started(dataset, user, user, comment)
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)
self.assertNotIn(b'<meta name="robots" content="noindex, nofollow">',
response.data)
def test_dataset_api_get_deleted_but_authorized(self):
'''It should a deleted dataset from the API if user is authorized'''
self.login()
dataset = VisibleDatasetFactory(owner=self.user,
deleted=datetime.now())
response = self.get(url_for('api.dataset', dataset=dataset))
self.assert200(response)
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='foô'),
]
org_datasets = [
VisibleDatasetFactory(organization=organization, title='foô'),
]
# Should not be listed.
VisibleDatasetFactory(owner=user)
VisibleDatasetFactory(organization=organization)
response = self.get(url_for('api.my_org_datasets'), qs={'q': 'foô'})
self.assert200(response)
self.assertEqual(len(response.json), len(datasets) + len(org_datasets))
def test_dataset_api_list(self):
'''It should fetch a dataset list from the API'''
with self.autoindex():
datasets = [VisibleDatasetFactory() for i in range(2)]
response = self.get(url_for('api.datasets'))
self.assert200(response)
self.assertEqual(len(response.json['data']), len(datasets))
self.assertFalse('quality' in response.json['data'][0])
def test_request_transfer_not_authorized_not_owner(self):
user = UserFactory()
dataset = VisibleDatasetFactory(owner=UserFactory())
recipient = UserFactory()
comment = faker.sentence()
login_user(user)
with pytest.raises(PermissionDenied):
request_transfer(dataset, recipient, comment)
def test_render_list(self):
'''It should render the dataset list page'''
with self.autoindex():
datasets = [VisibleDatasetFactory() for i in range(3)]
response = self.get(url_for('datasets.list'))
self.assert200(response)
rendered_datasets = self.get_context_variable('datasets')
self.assertEqual(len(rendered_datasets), len(datasets))
def test_org_editor_cant_accept_transfer(self):
owner = UserFactory()
editor = UserFactory()
org = OrganizationFactory(members=[Member(user=editor, role='editor')])
subject = VisibleDatasetFactory(organization=org)
transfer = TransferFactory(owner=owner, recipient=org, subject=subject)
login_user(editor)
with pytest.raises(PermissionDenied):
accept_transfer(transfer)
def test_dataset_api_list_filtered_by_org_with_or(self):
'''It should fetch a dataset list for two given orgs'''
self.login()
with self.autoindex():
member = Member(user=self.user, role='editor')
org1 = OrganizationFactory(members=[member])
org2 = OrganizationFactory(members=[member])
VisibleDatasetFactory()
dataset_org1 = VisibleDatasetFactory(organization=org1)
dataset_org2 = VisibleDatasetFactory(organization=org2)
response = self.get(
url_for('api.datasets'),
qs={'organization': '{0}|{1}'.format(org1.id, org2.id)})
self.assert200(response)
self.assertEqual(len(response.json['data']), 2)
returned_ids = [item['id'] for item in response.json['data']]
self.assertIn(str(dataset_org1.id), returned_ids)
self.assertIn(str(dataset_org2.id), returned_ids)
def test_request_transfer_organization_to_user(self):
user = UserFactory()
member = Member(user=user, role='admin')
org = OrganizationFactory(members=[member])
dataset = VisibleDatasetFactory(owner=user, organization=org)
recipient = UserFactory()
comment = faker.sentence()
login_user(user)
self.assert_transfer_started(dataset, org, recipient, comment)
def test_dataset_api_list_with_facets(self):
'''It should fetch a dataset list from the API with facets'''
with self.autoindex():
for i in range(2):
VisibleDatasetFactory(tags=['tag-{0}'.format(i)])
response = self.get(url_for('api.datasets', **{'facets': 'tag'}))
self.assert200(response)
self.assertEqual(len(response.json['data']), 2)
self.assertIn('facets', response.json)
self.assertIn('tag', response.json['facets'])
def test_request_transfer_to_same_organization(self):
user = UserFactory()
member = Member(user=user, role='admin')
org = OrganizationFactory(members=[member])
dataset = VisibleDatasetFactory(owner=user, organization=org)
comment = faker.sentence()
login_user(user)
with pytest.raises(ValueError):
self.assert_transfer_started(dataset, org, org, comment)
def test_render_display_with_datasets(self):
'''It should render the organization page with some datasets'''
organization = OrganizationFactory()
datasets = [
VisibleDatasetFactory(organization=organization) for _ in range(3)
]
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))
def test_zone_datasets(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))
self.assert200(response)
self.assertEqual(len(response.json), 3)
