def test_quality_has_treated_discussions(self):
user = UserFactory()
visitor = UserFactory()
dataset = DatasetFactory(description='', owner=user)
DiscussionFactory(
subject=dataset,
user=visitor,
discussion=[MessageDiscussionFactory(posted_by=user)] +
MessageDiscussionFactory.build_batch(2, posted_by=visitor))
self.assertEqual(dataset.quality['discussions'], 1)
self.assertFalse(dataset.quality['has_untreated_discussions'])
self.assertEqual(dataset.quality['score'], 2)
def test_discussions_csv_content_filled(self):
organization = OrganizationFactory()
dataset = DatasetFactory(organization=organization)
user = UserFactory(first_name='John', last_name='Snow')
discussion = DiscussionFactory(subject=dataset, user=user)
response = self.get(
url_for('organizations.discussions_csv', org=organization))
self.assert200(response)
headers, data = response.data.decode('utf-8').strip().split('\r\n')
expected = '"{discussion.id}";"{discussion.user}"'
assert_starts_with(data, expected.format(discussion=discussion))
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 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_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_or_no_formats', 'has_resources',
'has_unavailable_resources', 'has_untreated_discussions', 'score',
'tags_count', 'update_in'
])
def generate_fixtures(source):
'''Build sample fixture data (users, datasets, reuses) from local or remote file.'''
if source.startswith('http'):
json_fixtures = requests.get(source).json()
else:
with open(source) as f:
json_fixtures = json.load(f)
with click.progressbar(json_fixtures) as bar:
for fixture in bar:
user = UserFactory()
if not fixture['organization']:
dataset = DatasetFactory(**fixture['dataset'], owner=user)
else:
org = Organization.objects(
id=fixture['organization']['id']).first()
if not org:
org = OrganizationFactory(**fixture['organization'],
members=[Member(user=user)])
dataset = DatasetFactory(**fixture['dataset'],
organization=org)
for resource in fixture['resources']:
res = ResourceFactory(**resource)
dataset.add_resource(res)
for reuse in fixture['reuses']:
ReuseFactory(**reuse, datasets=[dataset], owner=user)
for community in fixture['community_resources']:
CommunityResourceFactory(**community,
dataset=dataset,
owner=user)
for discussion in fixture['discussions']:
messages = discussion.pop('discussion')
DiscussionFactory(**discussion,
subject=dataset,
user=user,
discussion=[
MessageDiscussionFactory(**message,
posted_by=user)
for message in messages
])
def test_delete(self):
'''It should delete the connected user'''
user = self.login()
self.assertIsNone(user.deleted)
other_user = UserFactory()
members = [Member(user=user), Member(user=other_user)]
organization = OrganizationFactory(members=members)
disc_msg_content = faker.sentence()
disc_msg = DiscMsg(content=disc_msg_content, posted_by=user)
other_disc_msg_content = faker.sentence()
other_disc_msg = DiscMsg(content=other_disc_msg_content,
posted_by=other_user)
discussion = DiscussionFactory(user=user,
discussion=[disc_msg, other_disc_msg])
issue_msg_content = faker.sentence()
issue_msg = IssueMsg(content=issue_msg_content, posted_by=user)
other_issue_msg_content = faker.sentence()
other_issue_msg = IssueMsg(content=other_issue_msg_content,
posted_by=other_user)
issue = IssueFactory(user=user,
discussion=[issue_msg, other_issue_msg])
dataset = DatasetFactory(owner=user)
reuse = ReuseFactory(owner=user)
resource = CommunityResourceFactory(owner=user)
activity = UserCreatedDataset.objects().create(actor=user,
related_to=dataset)
following = Follow.objects().create(follower=user,
following=other_user)
followed = Follow.objects().create(follower=other_user, following=user)
with capture_mails() as mails:
response = self.delete(url_for('api.me'))
self.assertEqual(len(mails), 1)
self.assertEqual(mails[0].send_to, set([user.email]))
self.assertEqual(mails[0].subject, _('Account deletion'))
self.assert204(response)
user.reload()
organization.reload()
discussion.reload()
issue.reload()
dataset.reload()
reuse.reload()
resource.reload()
activity.reload()
# The following are deleted
with self.assertRaises(Follow.DoesNotExist):
following.reload()
# The followers are deleted
with self.assertRaises(Follow.DoesNotExist):
followed.reload()
# The personal data of the user are anonymized
self.assertEqual(user.email, '{}@deleted'.format(user.id))
self.assertEqual(user.password, None)
self.assertEqual(user.active, False)
self.assertEqual(user.first_name, 'DELETED')
self.assertEqual(user.last_name, 'DELETED')
self.assertFalse(bool(user.avatar))
self.assertEqual(user.avatar_url, None)
self.assertEqual(user.website, None)
self.assertEqual(user.about, None)
# The user is marked as deleted
self.assertIsNotNone(user.deleted)
# The user is removed from his organizations
self.assertEqual(len(organization.members), 1)
self.assertEqual(organization.members[0].user.id, other_user.id)
# The discussions are kept but the messages are anonymized
self.assertEqual(len(discussion.discussion), 2)
self.assertEqual(discussion.discussion[0].content, 'DELETED')
self.assertEqual(discussion.discussion[1].content,
other_disc_msg_content)
# The issues are kept and the messages are not anonymized
self.assertEqual(len(issue.discussion), 2)
self.assertEqual(issue.discussion[0].content, issue_msg_content)
self.assertEqual(issue.discussion[1].content, other_issue_msg_content)
# The datasets are unchanged
self.assertEqual(dataset.owner, user)
# The reuses are unchanged
self.assertEqual(reuse.owner, user)
# The community resources are unchanged
self.assertEqual(resource.owner, user)
# The activities are unchanged
self.assertEqual(activity.actor, user)
def generate_datasets(count, organization=None):
for _ in range(0, count):
dataset = VisibleDatasetFactory(organization=organization)
DiscussionFactory(subject=dataset)