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_reuses_csv(self):
with self.autoindex():
reuses = [
ReuseFactory(datasets=[DatasetFactory()]) for _ in range(5)
]
hidden_reuse = ReuseFactory()
response = self.get(url_for('site.reuses_csv'))
self.assert200(response)
self.assertEqual(response.mimetype, 'text/csv')
self.assertEqual(response.charset, 'utf-8')
csvfile = StringIO(response.data.decode('utf8'))
reader = csv.get_reader(csvfile)
header = next(reader)
self.assertEqual(header[0], 'id')
self.assertIn('title', header)
self.assertIn('description', header)
self.assertIn('created_at', header)
self.assertIn('last_modified', header)
self.assertIn('tags', header)
self.assertIn('metric.datasets', header)
rows = list(reader)
ids = [row[0] for row in rows]
self.assertEqual(len(rows), len(reuses))
for reuse in reuses:
self.assertIn(str(reuse.id), ids)
self.assertNotIn(str(hidden_reuse.id), ids)
def test_suggest_reuses_api(self, api):
'''It should suggest reuses'''
for i in range(3):
ReuseFactory(title='test-{0}'.format(i) if i % 2 else faker.word(),
visible=True,
metrics={"followers": i})
max_follower_reuse = ReuseFactory(title='test-4',
visible=True,
metrics={"followers": 10})
response = api.get(url_for('api.suggest_reuses'),
qs={
'q': 'tes',
'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 'title' in suggestion
assert 'image_url' in suggestion
assert 'test' in suggestion['title']
assert response.json[0]['id'] == str(max_follower_reuse.id)
def setup(self, api, clean_db):
# Register at least two badges
Reuse.__badges__['test-1'] = 'Test 1'
Reuse.__badges__['test-2'] = 'Test 2'
self.factory = badge_factory(Reuse)
self.user = api.login(AdminFactory())
self.reuse = ReuseFactory()
def test_owned_by_user(self):
user = UserFactory()
reuse = ReuseFactory(owner=user)
ReuseFactory(owner=UserFactory())
result = Reuse.objects.owned_by(user)
self.assertEqual(len(result), 1)
self.assertEqual(result[0], reuse)
def test_owned_by_org(self):
org = OrganizationFactory()
reuse = ReuseFactory(organization=org)
ReuseFactory(organization=OrganizationFactory())
result = Reuse.objects.owned_by(org)
self.assertEqual(len(result), 1)
self.assertEqual(result[0], reuse)
def test_reuse_api_feature_already(self):
'''It shouldn't do anything to feature an already featured reuse'''
reuse = ReuseFactory(featured=True)
with self.api_user(AdminFactory()):
response = self.post(url_for('api.reuse_featured', reuse=reuse))
self.assert200(response)
reuse.reload()
self.assertTrue(reuse.featured)
def test_reuse_api_unfeature(self):
'''It should mark the reuse featured on POST'''
reuse = ReuseFactory(featured=True)
with self.api_user(AdminFactory()):
response = self.delete(url_for('api.reuse_featured', reuse=reuse))
self.assert200(response)
reuse.reload()
self.assertFalse(reuse.featured)
def test_reuse_api_update(self, api):
'''It should update a reuse from the API'''
user = api.login()
reuse = ReuseFactory(owner=user)
data = reuse.to_dict()
data['description'] = 'new description'
response = api.put(url_for('api.reuse', reuse=reuse), data)
assert200(response)
assert Reuse.objects.count() == 1
assert Reuse.objects.first().description == 'new description'
def test_reuse_api_update(self):
'''It should update a reuse from the API'''
self.login()
reuse = ReuseFactory(owner=self.user)
data = reuse.to_dict()
data['description'] = 'new description'
response = self.put(url_for('api.reuse', reuse=reuse), data)
self.assert200(response)
self.assertEqual(Reuse.objects.count(), 1)
self.assertEqual(Reuse.objects.first().description, 'new description')
def test_reuse_api_unfeature(self):
'''It should mark the reuse featured on POST'''
reuse = ReuseFactory(featured=True)
with self.api_user(AdminFactory()):
response = self.delete(url_for('api.reuse_featured', reuse=reuse))
self.assert200(response)
reuse.reload()
self.assertFalse(reuse.featured)
def test_reuse_api_unfeature_already(self):
'''It shouldn't do anything to unfeature a not featured reuse'''
reuse = ReuseFactory(featured=False)
with self.api_user(AdminFactory()):
response = self.delete(url_for('api.reuse_featured', reuse=reuse))
self.assert200(response)
reuse.reload()
self.assertFalse(reuse.featured)
def test_reuse_api_feature_already(self):
'''It shouldn't do anything to feature an already featured reuse'''
reuse = ReuseFactory(featured=True)
with self.api_user(AdminFactory()):
response = self.post(url_for('api.reuse_featured', reuse=reuse))
self.assert200(response)
reuse.reload()
self.assertTrue(reuse.featured)
def test_reuse_api_unfeature(self, api):
'''It should mark the reuse featured on POST'''
reuse = ReuseFactory(featured=True)
with api.user(AdminFactory()):
response = api.delete(url_for('api.reuse_featured', reuse=reuse))
assert200(response)
reuse.reload()
assert not reuse.featured
def test_reuse_api_update(self):
'''It should update a reuse from the API'''
self.login()
reuse = ReuseFactory(owner=self.user)
data = reuse.to_dict()
data['description'] = 'new description'
response = self.put(url_for('api.reuse', reuse=reuse), data)
self.assert200(response)
self.assertEqual(Reuse.objects.count(), 1)
self.assertEqual(Reuse.objects.first().description, 'new description')
def test_list_org_reuses_hide_private(self, api):
'''Should not include private reuses when not member'''
org = OrganizationFactory()
reuses = ReuseFactory.create_batch(3, organization=org)
ReuseFactory.create_batch(2, organization=org, private=True)
response = api.get(url_for('api.org_reuses', org=org))
assert200(response)
assert len(response.json) == len(reuses)
def test_reuse_api_unfeature_already(self):
'''It shouldn't do anything to unfeature a not featured reuse'''
reuse = ReuseFactory(featured=False)
with self.api_user(AdminFactory()):
response = self.delete(url_for('api.reuse_featured', reuse=reuse))
self.assert200(response)
reuse.reload()
self.assertFalse(reuse.featured)
def test_suggest_reuses_api_no_match(self, api):
'''It should not provide reuse suggestion if no match'''
ReuseFactory.create_batch(3, visible=True)
response = api.get(url_for('api.suggest_reuses'),
qs={
'q': 'xxxxxx',
'size': '5'
})
assert200(response)
assert len(response.json) == 0
def test_render_profile_reuses(self):
'''It should render the user profile reuses page'''
user = UserFactory()
reuses = [ReuseFactory(owner=user, datasets=[DatasetFactory()])
for _ in range(3)]
for _ in range(2):
ReuseFactory(datasets=[DatasetFactory()])
response = self.get(url_for('users.reuses', user=user))
self.assert200(response)
rendered_reuses = self.get_context_variable('reuses')
self.assertEqual(len(rendered_reuses), len(reuses))
def test_my_org_reuses(self):
user = self.login()
member = Member(user=user, role='editor')
organization = OrganizationFactory(members=[member])
reuses = [ReuseFactory(owner=user) for _ in range(2)]
org_reuses = [ReuseFactory(organization=organization)
for _ in range(2)]
response = self.get(url_for('api.my_org_reuses'))
self.assert200(response)
self.assertEqual(len(response.json), len(reuses) + len(org_reuses))
def test_reuse_api_add_dataset_not_found(self):
'''It should return 404 when adding an unknown dataset to a reuse'''
self.login()
reuse = ReuseFactory(owner=self.user)
data = {'id': 'not-found', 'class': 'Dataset'}
url = url_for('api.reuse_add_dataset', reuse=reuse)
response = self.post(url, data)
self.assert404(response)
reuse.reload()
self.assertEqual(len(reuse.datasets), 0)
def test_reuse_api_add_dataset_not_found(self):
'''It should return 404 when adding an unknown dataset to a reuse'''
self.login()
reuse = ReuseFactory(owner=self.user)
data = {'id': 'not-found', 'class': 'Dataset'}
url = url_for('api.reuse_add_dataset', reuse=reuse)
response = self.post(url, data)
self.assert404(response)
reuse.reload()
self.assertEqual(len(reuse.datasets), 0)
def test_reuse_api_add_dataset_twice(self):
'''It should not add twice a dataset to a reuse from the API'''
self.login()
dataset = DatasetFactory()
reuse = ReuseFactory(owner=self.user, datasets=[dataset])
data = {'id': dataset.id, 'class': 'Dataset'}
url = url_for('api.reuse_add_dataset', reuse=reuse)
response = self.post(url, data)
self.assert200(response)
reuse.reload()
self.assertEqual(len(reuse.datasets), 1)
self.assertEqual(reuse.datasets[-1], dataset)
def test_reuse_api_add_dataset_twice(self, api):
'''It should not add twice a dataset to a reuse from the API'''
user = api.login()
dataset = DatasetFactory()
reuse = ReuseFactory(owner=user, datasets=[dataset])
data = {'id': dataset.id, 'class': 'Dataset'}
url = url_for('api.reuse_add_dataset', reuse=reuse)
response = api.post(url, data)
assert200(response)
reuse.reload()
assert len(reuse.datasets) == 1
assert reuse.datasets[-1] == dataset
def test_reuse_api_add_dataset_twice(self):
'''It should not add twice a dataset to a reuse from the API'''
self.login()
dataset = DatasetFactory()
reuse = ReuseFactory(owner=self.user, datasets=[dataset])
data = {'id': dataset.id, 'class': 'Dataset'}
url = url_for('api.reuse_add_dataset', reuse=reuse)
response = self.post(url, data)
self.assert200(response)
reuse.reload()
self.assertEqual(len(reuse.datasets), 1)
self.assertEqual(reuse.datasets[-1], dataset)
def test_render_home(self):
'''It should render the home page'''
for i in range(3):
org = OrganizationFactory()
DatasetFactory(organization=org)
ReuseFactory(organization=org)
current_site.settings.home_datasets = [
DatasetFactory() for _ in range(3)
]
current_site.settings.home_reuses = [ReuseFactory() for _ in range(3)]
response = self.get(url_for('site.home'))
self.assert200(response)
def test_owned_by_org_or_user(self):
user = UserFactory()
org = OrganizationFactory()
reuses = [ReuseFactory(owner=user), ReuseFactory(organization=org)]
excluded = [ReuseFactory(owner=UserFactory()),
ReuseFactory(organization=OrganizationFactory())]
result = Reuse.objects.owned_by(org, user)
self.assertEqual(len(result), 2)
for reuse in result:
self.assertIn(reuse, reuses)
for reuse in excluded:
self.assertNotIn(reuse, result)
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_purge_reuses(self):
reuse = ReuseFactory(title='test-reuse')
# Upload reuse's image
file = create_test_image()
user = AdminFactory()
self.login(user)
response = self.post(url_for('api.reuse_image', reuse=reuse),
{'file': (file, 'test.png')},
json=False)
self.assert200(response)
# Delete reuse
response = self.delete(url_for('api.reuse', reuse=reuse))
self.assert204(response)
user = UserFactory()
transfer = Transfer.objects.create(
owner=user,
recipient=user,
subject=reuse,
comment='comment',
)
tasks.purge_reuses()
assert Transfer.objects.filter(id=transfer.id).count() == 0
# Check reuse's image is deleted
self.assertEqual(list(storages.images.list_files()), [])
deleted_reuse = Reuse.objects(title='test-reuse').first()
self.assertIsNone(deleted_reuse)
def test_issues_for_user_with_closed(self):
owner = UserFactory()
dataset = DatasetFactory(owner=owner)
reuse = ReuseFactory(owner=owner)
open_issues = []
for i in range(3):
user = UserFactory()
message = Message(content=faker.sentence(), posted_by=user)
open_issues.append(
Issue.objects.create(subject=dataset,
user=user,
title=faker.sentence(),
discussion=[message]))
open_issues.append(
Issue.objects.create(subject=reuse,
user=user,
title=faker.sentence(),
discussion=[message]))
# Creating a closed issue that shouldn't show up in response.
user = UserFactory()
message = Message(content=faker.sentence(), posted_by=user)
Issue.objects.create(subject=dataset,
user=user,
title=faker.sentence(),
discussion=[message],
closed=datetime.now(),
closed_by=user)
issues = issues_for(owner, only_open=False)
self.assertEqual(len(issues), len(open_issues) + 1)
def test_reuse_api_list(self, api):
'''It should fetch a reuse list from the API'''
reuses = ReuseFactory.create_batch(3, visible=True)
response = api.get(url_for('api.reuses'))
assert200(response)
assert len(response.json['data']) == len(reuses)
def test_suggest_tags_api_with_unicode(self, api, autoindex):
'''It should suggest tags'''
with autoindex:
for i in range(3):
tags = [
faker.word(),
faker.word(), 'testé', 'testé-{0}'.format(i)
]
ReuseFactory(tags=tags, visible=True)
DatasetFactory(tags=tags, visible=True)
response = api.get(url_for('api.suggest_tags'),
qs={
'q': 'testé',
'size': '5'
})
assert200(response)
assert len(response.json) <= 5
assert len(response.json) > 1
assert response.json[0]['text'] == 'teste'
for suggestion in response.json:
assert 'text' in suggestion
assert 'score' in suggestion
assert suggestion['text'].startswith('teste')
def test_suggest_tags_api_with_unicode(self):
'''It should suggest tags'''
with self.autoindex():
for i in range(3):
tags = [
faker.word(),
faker.word(), 'testé', 'testé-{0}'.format(i)
]
ReuseFactory(tags=tags, visible=True)
DatasetFactory(tags=tags, visible=True)
response = self.get(url_for('api.suggest_tags'),
qs={
'q': 'testé',
'size': '5'
})
self.assert200(response)
self.assertLessEqual(len(response.json), 5)
self.assertGreater(len(response.json), 1)
self.assertEqual(response.json[0]['text'], 'teste')
for suggestion in response.json:
self.assertIn('text', suggestion)
self.assertIn('score', suggestion)
self.assertTrue(suggestion['text'].startswith('teste'))
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 = [
VisibleReuseFactory(organization=organization) for _ in range(2)
]
empty_reuses = [
ReuseFactory(organization=organization, datasets=[])
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),
len(reuses) + len(private_reuses) + len(empty_reuses))
rendered_private_reuses = [
reuse for reuse in rendered_reuses if reuse.private
]
self.assertEqual(len(rendered_private_reuses), len(private_reuses))
total_reuses = self.get_context_variable('total_reuses')
self.assertEqual(total_reuses,
len(reuses) + len(private_reuses) + len(empty_reuses))
def test_suggest_reuses_api_unicode(self, api, autoindex):
'''It should suggest reuses with special characters'''
with autoindex:
for i in range(4):
ReuseFactory(title='testé-{0}'.format(i) if i %
2 else faker.word(),
visible=True)
response = api.get(url_for('api.suggest_reuses'),
qs={
'q': '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 'title' in suggestion
assert 'score' in suggestion
assert 'image_url' in suggestion
assert suggestion['title'].startswith('test')
def test_suggest_reuses_api_unicode(self):
'''It should suggest reuses with special characters'''
with self.autoindex():
for i in range(4):
ReuseFactory(title='testé-{0}'.format(i) if i %
2 else faker.word(),
datasets=[DatasetFactory()])
response = self.get(url_for('api.suggest_reuses'),
qs={
'q': 'testé',
'size': '5'
})
self.assert200(response)
self.assertLessEqual(len(response.json), 5)
self.assertGreater(len(response.json), 1)
for suggestion in response.json:
self.assertIn('id', suggestion)
self.assertIn('slug', suggestion)
self.assertIn('title', suggestion)
self.assertIn('score', suggestion)
self.assertIn('image_url', suggestion)
self.assertTrue(suggestion['title'].startswith('test'))
def test_reuse_api_create(self):
'''It should create a reuse from the API'''
data = ReuseFactory.as_dict()
self.login()
response = self.post(url_for('api.reuses'), data)
self.assert201(response)
self.assertEqual(Reuse.objects.count(), 1)
reuse = Reuse.objects.first()
self.assertEqual(reuse.owner, self.user)
self.assertIsNone(reuse.organization)
def test_reuse_api_create_as_permissions(self):
"""It should create a reuse as organization from the API
only if user is member.
"""
self.login()
data = ReuseFactory.as_dict()
org = OrganizationFactory()
data['organization'] = str(org.id)
response = self.post(url_for('api.reuses'), data)
self.assert400(response)
self.assertEqual(Reuse.objects.count(), 0)
def test_delete_home_reuse(self):
'''Should pull home reuses on deletion'''
current_site.settings.home_reuses = ReuseFactory.create_batch(3)
current_site.save()
reuse = current_site.settings.home_reuses[1]
reuse.deleted = datetime.now()
reuse.save()
current_site.reload()
home_reuses = [r.id for r in current_site.settings.home_reuses]
self.assertEqual(len(home_reuses), 2)
self.assertNotIn(reuse.id, home_reuses)
def test_reuse_api_create_as_org(self):
'''It should create a reuse as organization from the API'''
self.login()
data = ReuseFactory.as_dict()
member = Member(user=self.user, role='editor')
org = OrganizationFactory(members=[member])
data['organization'] = str(org.id)
response = self.post(url_for('api.reuses'), data)
self.assert201(response)
self.assertEqual(Reuse.objects.count(), 1)
reuse = Reuse.objects.first()
self.assertIsNone(reuse.owner)
self.assertEqual(reuse.organization, org)
def reuses(self):
return ReuseFactory.create_batch(3)
def setUp(self):
self.login(AdminFactory())
self.reuse = ReuseFactory()
def test_send_on_delete(self):
reuse = ReuseFactory()
with assert_emit(Reuse.on_delete):
reuse.deleted = datetime.now()
reuse.save()
class ReuseBadgeAPITest(APITestCase):
@classmethod
def setUpClass(cls):
# Register at least two badges
Reuse.__badges__['test-1'] = 'Test 1'
Reuse.__badges__['test-2'] = 'Test 2'
cls.factory = badge_factory(Reuse)
def setUp(self):
self.login(AdminFactory())
self.reuse = ReuseFactory()
def test_list(self):
response = self.get(url_for('api.available_reuse_badges'))
self.assertStatus(response, 200)
self.assertEqual(len(response.json), len(Reuse.__badges__))
for kind, label in Reuse.__badges__.items():
self.assertIn(kind, response.json)
self.assertEqual(response.json[kind], label)
def test_create(self):
data = self.factory.as_dict()
with self.api_user():
response = self.post(
url_for('api.reuse_badges', reuse=self.reuse), data)
self.assert201(response)
self.reuse.reload()
self.assertEqual(len(self.reuse.badges), 1)
def test_create_same(self):
data = self.factory.as_dict()
with self.api_user():
self.post(
url_for('api.reuse_badges', reuse=self.reuse), data)
response = self.post(
url_for('api.reuse_badges', reuse=self.reuse), data)
self.assertStatus(response, 200)
self.reuse.reload()
self.assertEqual(len(self.reuse.badges), 1)
def test_create_2nd(self):
# Explicitely setting the kind to avoid collisions given the
# small number of choices for kinds.
kinds_keys = Reuse.__badges__.keys()
self.reuse.add_badge(kinds_keys[0])
data = self.factory.as_dict()
data['kind'] = kinds_keys[1]
with self.api_user():
response = self.post(
url_for('api.reuse_badges', reuse=self.reuse), data)
self.assert201(response)
self.reuse.reload()
self.assertEqual(len(self.reuse.badges), 2)
def test_delete(self):
badge = self.factory()
self.reuse.add_badge(badge.kind)
with self.api_user():
response = self.delete(
url_for('api.reuse_badge', reuse=self.reuse,
badge_kind=str(badge.kind)))
self.assertStatus(response, 204)
self.reuse.reload()
self.assertEqual(len(self.reuse.badges), 0)
def test_delete_404(self):
with self.api_user():
response = self.delete(
url_for('api.reuse_badge', reuse=self.reuse,
badge_kind=str(self.factory().kind)))
self.assert404(response)
