def test_only_admin_can_refuse_membership(self, api):
user = api.login()
applicant = UserFactory()
membership_request = MembershipRequest(user=applicant, comment='test')
member = Member(user=user, role='editor')
organization = OrganizationFactory(
members=[member], requests=[membership_request])
data = {'comment': 'no'}
api_url = url_for(
'api.refuse_membership',
org=organization,
id=membership_request.id)
response = api.post(api_url, data)
assert403(response)
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_add_resource(self):
user = UserFactory()
dataset = DatasetFactory(owner=user)
resource = ResourceFactory()
expected_signals = post_save, Dataset.after_save, Dataset.on_update
with assert_emit(*expected_signals):
dataset.add_resource(ResourceFactory())
assert len(dataset.resources) == 1
with assert_emit(*expected_signals):
dataset.add_resource(resource)
assert len(dataset.resources) == 2
assert dataset.resources[0].id == resource.id
assert dataset.resources[0].dataset == dataset
def test_mark_as_deleted(self):
user = UserFactory()
other_user = UserFactory()
org = OrganizationFactory(editors=[user])
discussion = DiscussionFactory(
user=user,
subject=org,
discussion=[MessageDiscussionFactory(posted_by=user)])
user_follow_org = Follow.objects.create(follower=user, following=org)
user_followed = Follow.objects.create(follower=other_user,
following=user)
user.mark_as_deleted()
org.reload()
assert len(org.members) == 0
discussion.reload()
assert discussion.discussion[0].content == 'DELETED'
assert Follow.objects(id=user_follow_org.id).first() is None
assert Follow.objects(id=user_followed.id).first() is None
assert user.slug == 'deleted'
def test_quality_all(self):
user = UserFactory()
visitor = UserFactory()
dataset = DatasetFactory(owner=user, frequency='weekly',
tags=['foo', 'bar'], description='a' * 42)
dataset.add_resource(ResourceFactory(format='pdf'))
DiscussionFactory(
subject=dataset, user=visitor,
discussion=[MessageDiscussionFactory(posted_by=visitor)])
self.assertEqual(dataset.quality['score'], 0)
self.assertEqual(
sorted(dataset.quality.keys()),
[
'description_length',
'discussions',
'frequency',
'has_only_closed_formats',
'has_resources',
'has_unavailable_resources',
'has_untreated_discussions',
'score',
'tags_count',
'update_in'
])
def test_registered_provider_provide_values(self):
dt = datetime.now()
def fake_provider(user):
return [(dt, {'some': 'value'})]
actions.register_provider('fake', fake_provider)
user = UserFactory()
notifs = actions.get_notifications(user)
self.assertEqual(len(notifs), 1)
self.assertEqual(notifs[0]['type'], 'fake')
self.assertEqual(notifs[0]['details'], {'some': 'value'})
self.assertEqualDates(notifs[0]['created_on'], dt)
def test_revoke_token_with_bad_hint(self, client, oauth):
user = UserFactory()
token = OAuth2Token.objects.create(
client=oauth,
user=user,
access_token='access-token',
refresh_token='refresh-token',
)
response = client.post(url_for('oauth.revoke_token'), {
'token': token.access_token,
'token_type_hint': 'refresh_token',
}, headers=basic_header(oauth))
assert400(response)
assert OAuth2Token.objects(pk=token.pk).first() == token
def test_new_discussion_comment_mail(self):
owner = UserFactory()
poster = UserFactory()
commenter = UserFactory()
message = Message(content=faker.sentence(), posted_by=poster)
new_message = Message(content=faker.sentence(), posted_by=commenter)
discussion = Discussion.objects.create(
subject=DatasetFactory(owner=owner),
user=poster,
title=faker.sentence(),
discussion=[message, new_message])
with capture_mails() as mails:
notify_new_discussion_comment(discussion.id,
message=len(discussion.discussion) -
1)
# Should have sent one mail to the owner and the other participants
# and no mail to the commenter
expected_recipients = (owner.email, poster.email)
self.assertEqual(len(mails), len(expected_recipients))
for mail in mails:
self.assertIn(mail.recipients[0], expected_recipients)
self.assertNotIn(commenter.email, mail.recipients)
def test_notify_user_discussions(self):
owner = UserFactory()
dataset = DatasetFactory(owner=owner)
open_discussions = {}
for i in range(3):
user = UserFactory()
message = Message(content=faker.sentence(), posted_by=user)
discussion = Discussion.objects.create(
subject=dataset,
user=user,
title=faker.sentence(),
discussion=[message]
)
open_discussions[discussion.id] = discussion
# Creating a closed discussion that shouldn't show up in response.
user = UserFactory()
message = Message(content=faker.sentence(), posted_by=user)
discussion = Discussion.objects.create(
subject=dataset,
user=user,
title=faker.sentence(),
discussion=[message],
closed=datetime.now(),
closed_by=user
)
notifications = discussions_notifications(owner)
self.assertEqual(len(notifications), len(open_discussions))
for dt, details in notifications:
discussion = open_discussions[details['id']]
self.assertEqual(details['title'], discussion.title)
self.assertEqual(details['subject']['id'], discussion.subject.id)
self.assertEqual(details['subject']['type'], 'dataset')
def test_with_valid_user_self_json(self):
Ownable, OwnableForm = self.factory()
user = UserFactory()
login_user(user)
form = OwnableForm.from_json({'owner': str(user.id)})
self.assertEqual(form.owner.data, user)
form.validate()
self.assertEqual(form.errors, {})
ownable = Ownable()
form.populate_obj(ownable)
self.assertEqual(ownable.owner, user)
def test_auth_with_existing_remote_user(client, ldap):
UserFactory(email=EMAIL)
page_url = url_for('site.home')
response = client.get(page_url, headers={'REMOTE_USER': UID})
assert200(response)
assert User.objects.count() == 1
user = User.objects.first()
assert user.email == EMAIL
assert user.first_name == FIRST_NAME
assert user.last_name == LAST_NAME
assert user.active
def test_empty_values_logged(self):
Ownable, OwnableForm = self.factory()
user = UserFactory()
login_user(user)
form = OwnableForm()
self.assertEqual(form.owner.data, user)
self.assertIsNone(form.organization.data)
ownable = Ownable()
form.populate_obj(ownable)
self.assertEqual(ownable.owner, user)
self.assertIsNone(ownable.organization)
def test_list_discussions_for(self):
dataset = DatasetFactory()
discussions = []
for i in range(3):
user = UserFactory()
message = Message(content=faker.sentence(), posted_by=user)
discussion = Discussion.objects.create(
subject=dataset,
user=user,
title='test discussion {}'.format(i),
discussion=[message])
discussions.append(discussion)
user = UserFactory()
message = Message(content=faker.sentence(), posted_by=user)
Discussion.objects.create(subject=DatasetFactory(),
user=user,
title='test discussion {}'.format(i),
discussion=[message])
kwargs = {'for': str(dataset.id)}
response = self.get(url_for('api.discussions', **kwargs))
self.assert200(response)
self.assertEqual(len(response.json['data']), len(discussions))
def test_with_owner(self):
user = UserFactory()
dataset = DatasetFactory(owner=user)
d = dataset_to_rdf(dataset)
g = d.graph
self.assertIsInstance(d, RdfResource)
datasets = g.subjects(RDF.type, DCAT.Dataset)
users = g.subjects(RDF.type, FOAF.Person)
self.assertEqual(len(list(datasets)), 1)
self.assertEqual(len(list(users)), 1)
publisher = d.value(DCT.publisher)
self.assertEqual(publisher.value(RDF.type).identifier,
FOAF.Person)
def test_revoke_token(self, client, oauth, token_type):
user = UserFactory()
token = OAuth2Token.objects.create(
client=oauth,
user=user,
access_token='access-token',
refresh_token='refresh-token',
)
response = client.post(url_for('oauth.revoke_token'), {
'token': getattr(token, token_type),
},
headers=basic_header(oauth))
assert200(response)
assert OAuth2Token.objects(pk=token.pk).first() is None
def test_closed_issue_mail(self):
owner = UserFactory()
poster = UserFactory()
commenter = UserFactory()
message = Message(content=faker.sentence(), posted_by=poster)
second_message = Message(content=faker.sentence(), posted_by=commenter)
closing_message = Message(content=faker.sentence(), posted_by=owner)
issue = Issue.objects.create(
subject=DatasetFactory(owner=owner),
user=poster,
title=faker.sentence(),
discussion=[message, second_message, closing_message])
# issue = IssueFactory()
with capture_mails() as mails:
notify_issue_closed(issue, message=closing_message)
# Should have sent one mail to each participant
# and no mail to the closer
expected_recipients = (poster.email, commenter.email)
self.assertEqual(len(mails), len(expected_recipients))
for mail in mails:
self.assertIn(mail.recipients[0], expected_recipients)
self.assertNotIn(owner.email, mail.recipients)
def test_list_issues_closed_filter(self):
dataset = Dataset.objects.create(title='Test dataset')
open_issues = []
closed_issues = []
for i in range(2):
user = UserFactory()
message = Message(content=faker.sentence(), posted_by=user)
issue = Issue.objects.create(subject=dataset,
user=user,
title='test issue {}'.format(i),
discussion=[message])
open_issues.append(issue)
for i in range(3):
user = UserFactory()
message = Message(content=faker.sentence(), posted_by=user)
issue = Issue.objects.create(subject=dataset,
user=user,
title='test issue {}'.format(i),
discussion=[message],
closed=datetime.now(),
closed_by=user)
closed_issues.append(issue)
response = self.get(url_for('api.issues', closed=True))
self.assert200(response)
self.assertEqual(len(response.json['data']), len(closed_issues))
for issue in response.json['data']:
self.assertIsNotNone(issue['closed'])
response = self.get(url_for('api.issues', id=dataset.id, closed=False))
self.assert200(response)
self.assertEqual(len(response.json['data']), len(open_issues))
for issue in response.json['data']:
self.assertIsNone(issue['closed'])
def test_only_admin_can_update_member(self, api):
user = api.login()
updated_user = UserFactory()
organization = OrganizationFactory(members=[
Member(user=user, role='editor'),
Member(user=updated_user, role='editor')
])
api_url = url_for('api.member', org=organization, user=updated_user)
response = api.put(api_url, {'role': 'admin'})
assert403(response)
organization.reload()
assert organization.is_member(updated_user)
assert not organization.is_admin(updated_user)
def test_with_initial_owner_and_no_data_provided(self):
Ownable, OwnableForm = self.factory()
user = UserFactory()
ownable = Ownable(owner=user)
form = OwnableForm(MultiDict({}), obj=ownable)
self.assertEqual(form.owner.data, user)
login_user(user)
form.validate()
self.assertEqual(form.errors, {})
form.populate_obj(ownable)
self.assertEqual(ownable.owner, user)
self.assertIsNone(ownable.organization)
def test_bad_oauth_auth(self, api, oauth):
'''Should handle wrong OAuth header authentication'''
user = UserFactory()
OAuth2Token.objects.create(
client=oauth,
user=user,
access_token='access-token',
refresh_token='refresh-token',
)
response = api.post(url_for('api.fake'), headers={
'Authorization': ' '.join(['Bearer', 'not-my-token'])
})
assert401(response)
assert response.content_type == 'application/json'
def test_with_initial_and_not_member(self):
Ownable, OwnableForm = self.factory()
user = UserFactory()
org = OrganizationFactory(members=[Member(user=user, role='editor')])
neworg = OrganizationFactory()
ownable = Ownable(organization=org)
form = OwnableForm(MultiDict({'organization': str(neworg.id)}),
obj=ownable)
self.assertEqual(form.organization.data, neworg)
login_user(user)
form.validate()
self.assertIn('organization', form.errors)
self.assertEqual(len(form.errors['organization']), 1)
def test_community_resource(self):
user = UserFactory()
dataset = DatasetFactory(owner=user)
community_resource1 = CommunityResourceFactory()
community_resource1.dataset = dataset
community_resource1.save()
self.assertEqual(len(dataset.community_resources), 1)
community_resource2 = CommunityResourceFactory()
community_resource2.dataset = dataset
community_resource2.save()
self.assertEqual(len(dataset.community_resources), 2)
self.assertEqual(dataset.community_resources[1].id,
community_resource1.id)
self.assertEqual(dataset.community_resources[0].id,
community_resource2.id)
def test_recent_feed_owner(self):
owner = UserFactory()
DatasetFactory(owner=owner, 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, owner.fullname)
self.assertEqual(author.href,
self.full_url('users.show', user=owner.id))
def test_unfollow(self):
'''It should unfollow the user on DELETE'''
user = self.login()
to_follow = UserFactory()
Follow.objects.create(follower=user, following=to_follow)
response = self.delete(url_for('api.user_followers', id=to_follow.id))
self.assert200(response)
nb_followers = Follow.objects.followers(to_follow).count()
self.assertEqual(response.json['followers'], nb_followers)
self.assertEqual(Follow.objects.following(to_follow).count(), 0)
self.assertEqual(nb_followers, 0)
self.assertEqual(Follow.objects.following(user).count(), 0)
self.assertEqual(Follow.objects.followers(user).count(), 0)
def test_follow_user(self):
'''It should follow an user on POST'''
user = self.login()
to_follow = UserFactory()
response = self.post(url_for('api.user_followers', id=to_follow.id))
self.assert201(response)
nb_followers = Follow.objects.followers(to_follow).count()
self.assertEqual(response.json['followers'], nb_followers)
self.assertEqual(Follow.objects.following(to_follow).count(), 0)
self.assertEqual(nb_followers, 1)
self.assertIsInstance(Follow.objects.followers(to_follow).first(),
Follow)
self.assertEqual(Follow.objects.following(user).count(), 1)
self.assertEqual(Follow.objects.followers(user).count(), 0)
def test_all_fields(self):
user = UserFactory(website=faker.uri())
user_url = url_for('users.show_redirect', user=user.id, _external=True)
u = user_to_rdf(user)
g = u.graph
self.assertIsInstance(u, RdfResource)
self.assertEqual(len(list(g.subjects(RDF.type, FOAF.Person))), 1)
self.assertEqual(u.value(RDF.type).identifier, FOAF.Person)
self.assertIsInstance(u.identifier, URIRef)
self.assertEqual(u.identifier.toPython(), user_url)
self.assertEqual(u.value(FOAF.name), Literal(user.fullname))
self.assertEqual(u.value(RDFS.label), Literal(user.fullname))
self.assertEqual(
u.value(FOAF.homepage).identifier, URIRef(user.website))
def test_with_other_user_admin(self):
Ownable, OwnableForm = self.factory()
user = UserFactory()
admin = AdminFactory()
login_user(admin)
form = OwnableForm(MultiDict({'owner': str(user.id)}))
self.assertEqual(form.owner.data, user)
form.validate()
self.assertEqual(form.errors, {})
ownable = Ownable()
form.populate_obj(ownable)
self.assertEqual(ownable.owner, user)
def test_oauth_auth(self, api, oauth):
'''Should handle OAuth header authentication'''
user = UserFactory()
token = OAuth2Token.objects.create(
client=oauth,
user=user,
access_token='access-token',
refresh_token='refresh-token',
)
response = api.post(url_for('api.fake'), headers={
'Authorization': ' '.join(['Bearer', token.access_token])
})
assert200(response)
assert response.content_type == 'application/json'
assert response.json == {'success': True}
def test_refresh_token(self, client, oauth):
user = UserFactory()
token = OAuth2Token.objects.create(
client=oauth,
user=user,
access_token='access-token',
refresh_token='refresh-token',
)
response = client.post(url_for('oauth.token'), {
'grant_type': 'refresh_token',
'refresh_token': token.refresh_token,
}, headers=basic_header(oauth))
assert200(response)
assert response.content_type == 'application/json'
assert 'access_token' in response.json
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))
self.assertEqual(len(orgs), 1 + 1) # There is the site publisher
users = list(graph.subjects(RDF.type, FOAF.Person))
self.assertEqual(len(users), 1)
org_names = list(graph.objects(orgs[0], FOAF.name))
self.assertEqual(len(org_names), 1)
user_names = list(graph.objects(users[0], FOAF.name))
self.assertEqual(len(user_names), 1)
