def test_search_filter(self):
AnalysisFrameworkFactory.create(title='one')
af2 = AnalysisFrameworkFactory.create(title='two')
af3 = AnalysisFrameworkFactory.create(title='twoo')
obtained = self.filter_class(data=dict(search='tw')).qs
expected = [af2, af3]
self.assertQuerySetIdEqual(expected, obtained)
def test_analysis_framework_list(self):
query = '''
query MyQuery {
analysisFrameworks (ordering: "id") {
page
pageSize
totalCount
results {
id
title
description
isPrivate
}
}
}
'''
user = UserFactory.create()
private_af = AnalysisFrameworkFactory.create(is_private=True)
normal_af = AnalysisFrameworkFactory.create()
member_af = AnalysisFrameworkFactory.create()
member_af.add_member(user)
# Without login
self.query_check(query, assert_for_error=True)
# With login
self.force_login(user)
content = self.query_check(query)
results = content['data']['analysisFrameworks']['results']
self.assertEqual(content['data']['analysisFrameworks']['totalCount'],
2)
self.assertIdEqual(results[0]['id'], normal_af.id)
self.assertIdEqual(results[1]['id'], member_af.id)
self.assertNotIn(str(private_af.id),
[d['id']
for d in results]) # Can't see private project.
project = ProjectFactory.create(analysis_framework=private_af)
# It shouldn't list private AF after adding to a project.
content = self.query_check(query)
results = content['data']['analysisFrameworks']['results']
self.assertEqual(content['data']['analysisFrameworks']['totalCount'],
2)
self.assertNotIn(str(private_af.id),
[d['id']
for d in results]) # Can't see private project.
project.add_member(user)
# It should list private AF after user is member of the project.
content = self.query_check(query)
results = content['data']['analysisFrameworks']['results']
self.assertEqual(content['data']['analysisFrameworks']['totalCount'],
3)
self.assertIn(str(private_af.id),
[d['id']
for d in results]) # Can see private project now.
def test_analysis_framework(self):
query = '''
query MyQuery ($id: ID!) {
analysisFramework(id: $id) {
id
currentUserRole
description
isPrivate
title
}
}
'''
user = UserFactory.create()
private_af = AnalysisFrameworkFactory.create(is_private=True)
normal_af = AnalysisFrameworkFactory.create()
member_af = AnalysisFrameworkFactory.create()
member_af.add_member(user)
# Without login
self.query_check(query,
assert_for_error=True,
variables={'id': normal_af.pk})
# With login
self.force_login(user)
# Should work for normal AF
response = self.query_check(query,
variables={'id': normal_af.pk
})['data']['analysisFramework']
self.assertIdEqual(response['id'], normal_af.id, response)
self.assertEqual(response['isPrivate'], False, response)
# Should work for member AF
response = self.query_check(query,
variables={'id': member_af.pk
})['data']['analysisFramework']
self.assertIdEqual(response['id'], member_af.id, response)
self.assertEqual(response['isPrivate'], False, response)
# Shouldn't work for non-member private AF
response = self.query_check(query,
variables={'id': private_af.pk
})['data']['analysisFramework']
self.assertEqual(response, None, response)
# Shouldn't work for non-member private AF even if there is a project attached
project = ProjectFactory.create(analysis_framework=private_af)
response = self.query_check(query,
variables={'id': private_af.pk
})['data']['analysisFramework']
self.assertEqual(response, None, response)
# Should work for member private AF
project.add_member(user)
response = self.query_check(query,
variables={'id': private_af.pk
})['data']['analysisFramework']
self.assertIdEqual(response['id'], private_af.id, response)
self.assertEqual(response['isPrivate'], True, response)
def test_change_other_fields(self):
private_framework = AnalysisFrameworkFactory.create(is_private=True)
public_framework = AnalysisFrameworkFactory.create(is_private=False)
user = self.user
private_framework.add_member(
user, private_framework.get_or_create_owner_role())
public_framework.add_member(
user, public_framework.get_or_create_owner_role())
self.force_login(user)
# private framework update
self.input = dict(
title='new title updated',
isPrivate=private_framework.is_private,
)
response = self.query(
self.update_mutation,
input_data=self.input,
variables={'id': private_framework.id},
)
private_framework.refresh_from_db()
content = response.json()
self.assertNotEqual(
content['data']['analysisFramework']['analysisFrameworkUpdate'],
None, content)
self.assertTrue(
content['data']['analysisFramework']['analysisFrameworkUpdate']
['ok'], content)
self.assertEqual(private_framework.title, self.input['title'])
# public framework update
self.input = dict(
title='public title updated',
isPrivate=public_framework.is_private,
)
response = self.query(
self.update_mutation,
input_data=self.input,
variables={'id': public_framework.id},
)
public_framework.refresh_from_db()
content = response.json()
self.assertNotEqual(
content['data']['analysisFramework']['analysisFrameworkUpdate'],
None, content)
self.assertTrue(
content['data']['analysisFramework']['analysisFrameworkUpdate']
['ok'], content)
self.assertEqual(public_framework.title, self.input['title'])
def test_change_is_private_field(self):
"""Even the owner should be unable to change privacy"""
private_framework = AnalysisFrameworkFactory.create(is_private=True)
public_framework = AnalysisFrameworkFactory.create(is_private=False)
user = self.user
private_framework.add_member(
user, private_framework.get_or_create_owner_role())
public_framework.add_member(
user, public_framework.get_or_create_owner_role())
content = self._change_framework_privacy(public_framework, user)
self.assertIsNotNone(content['errors'][0]['message'])
self.assertIn('permission', content['errors'][0]['message'])
content = self._change_framework_privacy(private_framework, user)
self.assertIsNotNone(content['errors'][0]['message'])
self.assertIn('permission', content['errors'][0]['message'])
def test_entry_dropped_excerpt_migrations(self):
def _get_excerpt_snapshot():
return list(Entry.objects.order_by('id').values_list('excerpt', 'dropped_excerpt', 'excerpt_modified'))
migration_file = importlib.import_module('entry.migrations.0036_entry_excerpt_modified')
af = AnalysisFrameworkFactory.create()
project = ProjectFactory.create(analysis_framework=af)
lead = LeadFactory.create(project=project)
# Create entry before data migrate
EntryFactory.create(lead=lead, excerpt='', dropped_excerpt='')
EntryFactory.create(lead=lead, excerpt='sample-1', dropped_excerpt='')
EntryFactory.create(lead=lead, excerpt='sample-2', dropped_excerpt='sample-2-updated')
EntryFactory.create(lead=lead, excerpt='sample-3', dropped_excerpt='sample-3')
old_excerpt_snaphost = _get_excerpt_snapshot()
# Apply the migration logic
migration_file._update_entry_excerpt(Entry)
new_excerpt_snaphost = _get_excerpt_snapshot()
assert Entry.objects.count() == 4
assert Entry.objects.filter(dropped_excerpt='').count() == 1
assert Entry.objects.filter(excerpt_modified=True).count() == 1
assert Entry.objects.filter(dropped_excerpt=models.F('excerpt')).count() == 3
assert Entry.objects.exclude(dropped_excerpt=models.F('excerpt')).count() == 1
assert new_excerpt_snaphost != old_excerpt_snaphost
assert new_excerpt_snaphost == [
('', '', False),
('sample-1', 'sample-1', False),
('sample-2', 'sample-2-updated', True),
('sample-3', 'sample-3', False),
]
def test_project_query_has_assesment_af(self):
query = '''
query MyQuery {
projects(ordering: "id") {
results {
id
hasAnalysisFramework
hasAssessmentTemplate
}
}
}
'''
user = UserFactory.create()
analysis_framework = AnalysisFrameworkFactory.create()
assessment_template = AssessmentTemplateFactory.create()
project1 = ProjectFactory.create(
analysis_framework=analysis_framework,
assessment_template=assessment_template)
project2 = ProjectFactory.create(
analysis_framework=analysis_framework, )
project3 = ProjectFactory.create(
assessment_template=assessment_template)
self.force_login(user)
projects = self.query_check(query)['data']['projects']['results']
for index, (_id, has_af, has_ary_template) in enumerate([
(project1.pk, True, True),
(project2.pk, True, False),
(project3.pk, False, True),
]):
self.assertIdEqual(projects[index]['id'], _id, projects)
self.assertEqual(projects[index]['hasAnalysisFramework'], has_af,
projects)
self.assertEqual(projects[index]['hasAssessmentTemplate'],
has_ary_template, projects)
def test_analysis_pillars_entries_query(self):
query = '''
query MyQuery ($projectId: ID!, $analysisPillarId: ID!) {
project(id: $projectId) {
analysisPillar (id: $analysisPillarId) {
id
title
entries {
totalCount
results {
id
}
}
}
}
}
'''
now = datetime.datetime.now()
member_user = UserFactory.create()
non_member_user = UserFactory.create()
af = AnalysisFrameworkFactory.create()
project = ProjectFactory.create(analysis_framework=af)
another_project = ProjectFactory.create(analysis_framework=af)
project.add_member(member_user, role=self.project_role_reader_non_confidential)
analysis = AnalysisFactory.create(project=project, team_lead=member_user, end_date=now)
analysis_pillar = AnalysisPillarFactory.create(analysis=analysis, assignee=member_user)
def _query_check(**kwargs):
return self.query_check(
query,
variables={'projectId': project.id, 'analysisPillarId': analysis_pillar.pk},
**kwargs,
)
# -- Without login
_query_check(assert_for_error=True)
# --- With login
self.force_login(non_member_user)
content = _query_check()
self.assertEqual(content['data']['project']['analysisPillar'], None, content)
self.force_login(member_user)
content = _query_check()
self.assertEqual(content['data']['project']['analysisPillar']['entries']['totalCount'], 0, content)
self.assertEqual(len(content['data']['project']['analysisPillar']['entries']['results']), 0, content)
# Let's add some entries
lead_published_on = now - datetime.timedelta(days=1) # To fit within analysis end_date
EntryFactory.create_batch(10, lead=LeadFactory.create(project=project, published_on=lead_published_on))
EntryFactory.create_batch(8, lead=LeadFactory.create(project=another_project, published_on=lead_published_on))
content = _query_check()
self.assertEqual(content['data']['project']['analysisPillar']['entries']['totalCount'], 10, content)
self.assertEqual(len(content['data']['project']['analysisPillar']['entries']['results']), 10, content)
def test_leads_status(self):
query = '''
query MyQuery ($id: ID!) {
project(id: $id) {
leads(ordering: ASC_ID) {
results {
id
title
status
}
}
}
}
'''
user = UserFactory.create()
project = ProjectFactory.create(
analysis_framework=AnalysisFrameworkFactory.create())
project.add_member(user)
lead1, _ = LeadFactory.create_batch(2, project=project)
def _query_check():
return self.query_check(query, variables={'id': project.id})
self.force_login(user)
content = _query_check()['data']['project']['leads']['results']
self.assertEqual(len(content), 2, content)
self.assertEqual(
set([lead['status'] for lead in content]),
{self.genum(Lead.Status.NOT_TAGGED)},
content,
)
# Add entry to lead1
entry1 = EntryFactory.create(lead=lead1)
content = _query_check()['data']['project']['leads']['results']
self.assertEqual(len(content), 2, content)
self.assertEqual(content[0]['status'],
self.genum(Lead.Status.IN_PROGRESS), content)
self.assertEqual(content[1]['status'],
self.genum(Lead.Status.NOT_TAGGED), content)
# Update lead1 status to TAGGED
lead1.status = Lead.Status.TAGGED
lead1.save(update_fields=['status'])
content = _query_check()['data']['project']['leads']['results']
self.assertEqual(len(content), 2, content)
self.assertEqual(content[0]['status'], self.genum(Lead.Status.TAGGED),
content)
self.assertEqual(content[1]['status'],
self.genum(Lead.Status.NOT_TAGGED), content)
# Now update entry1
entry1.save()
content = _query_check()['data']['project']['leads']['results']
self.assertEqual(len(content), 2, content)
self.assertEqual(content[0]['status'],
self.genum(Lead.Status.IN_PROGRESS), content)
self.assertEqual(content[1]['status'],
self.genum(Lead.Status.NOT_TAGGED), content)
def test_analysis_framework_filter(self):
af1, af2, af3 = AnalysisFrameworkFactory.create_batch(3)
p1 = ProjectFactory.create(analysis_framework=af1)
p2 = ProjectFactory.create(analysis_framework=af2)
ProjectFactory.create(analysis_framework=af3)
obtained = self.filter_class(data=dict(
analysis_frameworks=[af1.id, af2.id])).qs
expected = [p2, p1]
self.assertQuerySetIdEqual(expected, obtained)
def test_public_analysis_framework(self):
query = '''
query MyQuery {
publicAnalysisFrameworks (ordering: "id") {
page
pageSize
totalCount
results {
id
title
}
}
}
'''
AnalysisFrameworkFactory.create_batch(4, is_private=False)
AnalysisFrameworkFactory.create_batch(5, is_private=True)
content = self.query_check(query)
self.assertEqual(
content['data']['publicAnalysisFrameworks']['totalCount'], 4,
content)
def test_project_stat_recent(self):
query = '''
query MyQuery {
recentProjects {
id
status
title
isPrivate
description
currentUserRole
}
}
'''
user = UserFactory.create()
analysis_framework = AnalysisFrameworkFactory.create()
public_project1, public_project2, public_project3, public_project4 = ProjectFactory.create_batch(
4)
public_project1.add_member(user)
public_project2.add_member(user)
public_project3.add_member(user)
lead1 = LeadFactory.create(project=public_project1, created_by=user)
LeadFactory.create(project=public_project2, created_by=user)
EntryFactory.create(lead=lead1,
controlled=False,
created_by=user,
project=public_project1,
analysis_framework=analysis_framework)
LeadFactory.create(project=public_project3, created_by=user)
LeadFactory.create(project=public_project4, created_by=user)
# -- Without login
self.query_check(query, assert_for_error=True)
# -- With login
self.force_login(user)
content = self.query_check(query)
self.assertEqual(len(content['data']['recentProjects']), 3, content)
self.assertEqual(content['data']['recentProjects'][0]['id'],
str(public_project3.pk), content)
self.assertEqual(content['data']['recentProjects'][1]['id'],
str(public_project1.pk), content)
self.assertEqual(content['data']['recentProjects'][2]['id'],
str(public_project2.pk), content)
def setUp(self):
super().setUp()
self.qa_member_user = UserFactory.create()
self.member_user = UserFactory.create()
self.readonly_member_user = UserFactory.create()
self.non_member_user = UserFactory.create()
self.af = AnalysisFrameworkFactory.create()
self.project = ProjectFactory.create(analysis_framework=self.af)
self.lead = LeadFactory.create(project=self.project)
self.entry = EntryFactory.create(lead=self.lead)
# Add member to project
self.project.add_member(self.readonly_member_user,
role=self.project_role_reader_non_confidential)
self.project.add_member(self.member_user,
role=self.project_role_member)
self.project.add_member(self.qa_member_user,
role=self.project_role_member,
badges=[ProjectMembership.BadgeType.QA])
def setUp(self):
super().setUp()
self.af = AnalysisFrameworkFactory.create()
self.project = ProjectFactory.create(analysis_framework=self.af)
# User with role
self.non_member_user = UserFactory.create()
self.readonly_member_user = UserFactory.create()
self.member_user = UserFactory.create()
self.project.add_member(self.readonly_member_user,
role=self.project_role_reader_non_confidential)
self.project.add_member(self.member_user,
role=self.project_role_member)
self.lead = LeadFactory.create(project=self.project)
self.widget1 = WidgetFactory.create(analysis_framework=self.af)
self.widget2 = WidgetFactory.create(analysis_framework=self.af)
self.widget3 = WidgetFactory.create(analysis_framework=self.af)
# Files
self.other_file = FileFactory.create()
self.our_file = FileFactory.create(created_by=self.member_user)
self.dummy_data = dict({})
def test_test_entry_review_verify_control_migrations(self):
migration_file = importlib.import_module('entry.migrations.0031_entry-migrate-verify-to-review-comment')
# 3 normal users + Additional non-active user
user1, user2, user3, _ = UserFactory.create_batch(4)
af = AnalysisFrameworkFactory.create()
project = ProjectFactory.create(analysis_framework=af)
lead = LeadFactory.create(project=project)
# Create entry before data migrate
EntryFactory.create(lead=lead, controlled=True, controlled_changed_by=user1)
EntryFactory.create(lead=lead, controlled=True, controlled_changed_by=user2)
EntryFactory.create(lead=lead, controlled=False, controlled_changed_by=user3)
EntryFactory.create(lead=lead, controlled=True, controlled_changed_by=None)
EntryFactory.create(lead=lead, controlled=False, controlled_changed_by=None)
# Apply the migration logic
migration_file.migrate_entry_controlled_to_review_comment_(Entry, EntryReviewComment)
assert Entry.objects.count() == 5
# 2 verified review comment are created and 1 unverified review comment is created
assert EntryReviewComment.objects.count() == 3
# Related review comment are created by user last action on entry.
assert set(EntryReviewComment.objects.values_list('created_by_id', flat=True)) == set([user1.pk, user2.pk, user3.pk])
assert EntryReviewComment.objects.filter(comment_type=EntryReviewComment.CommentType.VERIFY).count() == 2
assert EntryReviewComment.objects.filter(comment_type=EntryReviewComment.CommentType.UNVERIFY).count() == 1
assert set(
EntryReviewComment.objects.filter(
comment_type=EntryReviewComment.CommentType.VERIFY,
).values_list('created_by_id', flat=True)
) == set([user1.pk, user2.pk])
assert set(
EntryReviewComment.objects.filter(
comment_type=EntryReviewComment.CommentType.UNVERIFY,
).values_list('created_by_id', flat=True)
) == set([user3.pk])
# All controlled, controlled_changed_by should be reset.
assert Entry.objects.filter(controlled=True).count() == 0
assert Entry.objects.filter(controlled_changed_by__isnull=False).count() == 0
def test_create_assignment_create_on_entry_review_comment(
self, get_user_mocked_func):
af = AnalysisFrameworkFactory.create()
project = ProjectFactory.create(analysis_framework=af)
user1, user2 = UserFactory.create_batch(2)
get_user_mocked_func.return_value = user2
entry = EntryFactory.create(lead=LeadFactory.create(project=project))
old_assignment_count = Assignment.objects.count()
entry_review_comment = EntryReviewCommentFactory.create(
entry=entry, entry_comment=None, created_by=user1)
new_assignment_count = Assignment.objects.count()
self.assertEqual(old_assignment_count, new_assignment_count)
entry_review_comment.mentioned_users.add(user1)
new_assignment_count = Assignment.objects.count()
self.assertEqual(old_assignment_count + 1, new_assignment_count)
# try to change the assigne for the entry_review_comment and test for the change in assignment
entry_review_comment.mentioned_users.remove(user1)
entry_review_comment.mentioned_users.add(user2)
self.assertEqual(old_assignment_count + 1, new_assignment_count)
assignment = Assignment.objects.get(
entry_review_comment__id=entry_review_comment.id)
self.assertEqual(assignment.created_for,
user2) # should represent the new user2
# try to add another user and remove both from assignee
entry_review_comment.mentioned_users.add(user1)
new_assignment_count = Assignment.objects.count()
self.assertEqual(old_assignment_count + 2, new_assignment_count)
# try to get the assignment for user
entry_review_comment.mentioned_users.add(user1, user2)
assignment = Assignment.get_for(user1)
assert assignment.count() == 1 # for only the user
assert get_user_mocked_func.called
def test_recent_analysis_framework(self):
# NOTE: This test includes the recent_analysis_framework based on project and source
query = '''
query MyQuery {
projectExploreStats {
topActiveFrameworks {
analysisFrameworkId
analysisFrameworkTitle
projectCount
sourceCount
}
}
}
'''
# lets create some analysis_framework
analysis_framework1 = AnalysisFrameworkFactory.create()
analysis_framework2 = AnalysisFrameworkFactory.create()
analysis_framework3 = AnalysisFrameworkFactory.create()
analysis_framework4 = AnalysisFrameworkFactory.create()
analysis_framework5 = AnalysisFrameworkFactory.create()
analysis_framework6 = AnalysisFrameworkFactory.create()
project1 = ProjectFactory.create(
analysis_framework=analysis_framework1)
project2 = ProjectFactory.create(
analysis_framework=analysis_framework2)
project3 = ProjectFactory.create(
analysis_framework=analysis_framework1)
project4 = ProjectFactory.create(
analysis_framework=analysis_framework3)
project5 = ProjectFactory.create(
analysis_framework=analysis_framework4)
project6 = ProjectFactory.create(
analysis_framework=analysis_framework3)
project7 = ProjectFactory.create(
analysis_framework=analysis_framework1)
project8 = ProjectFactory.create(
analysis_framework=analysis_framework5)
project9 = ProjectFactory.create(
analysis_framework=analysis_framework6)
# some lead for the project
LeadFactory.create_batch(15, project=project1)
LeadFactory.create_batch(13, project=project2)
LeadFactory.create_batch(20, project=project3)
LeadFactory.create_batch(20, project=project4)
LeadFactory.create_batch(20, project=project5)
LeadFactory.create_batch(30, project=project6)
LeadFactory.create_batch(30, project=project7)
LeadFactory.create_batch(30, project=project8)
LeadFactory.create_batch(30, project=project9)
content = self.query_check(query)
self.assertEqual(
len(content['data']['projectExploreStats']['topActiveFrameworks']),
5, content)
self.assertEqual(
content['data']['projectExploreStats']['topActiveFrameworks'][0]
['analysisFrameworkId'], str(analysis_framework1.id))
self.assertEqual(
content['data']['projectExploreStats']['topActiveFrameworks'][0]
['projectCount'], 3)
self.assertEqual(
content['data']['projectExploreStats']['topActiveFrameworks'][0]
['sourceCount'], 65)
self.assertEqual(
content['data']['projectExploreStats']['topActiveFrameworks'][1]
['analysisFrameworkId'], str(analysis_framework3.id))
self.assertEqual(
content['data']['projectExploreStats']['topActiveFrameworks'][1]
['projectCount'], 2)
self.assertEqual(
content['data']['projectExploreStats']['topActiveFrameworks'][2]
['analysisFrameworkId'], str(analysis_framework5.id))
self.assertEqual(
content['data']['projectExploreStats']['topActiveFrameworks'][3]
['analysisFrameworkId'], str(analysis_framework6.id))
self.assertEqual(
content['data']['projectExploreStats']['topActiveFrameworks'][4]
['analysisFrameworkId'], str(analysis_framework4.id))
def test_project_create_mutation(self):
query = '''
mutation MyMutation($input: ProjectCreateInputType!) {
__typename
projectCreate(data: $input) {
ok
errors
result {
id
title
analysisFramework {
id
isPrivate
}
description
startDate
endDate
isPrivate
hasPubliclyViewableLeads
isVisualizationEnabled
organizations {
id
organization {
id
title
}
organizationType
organizationTypeDisplay
}
status
}
}
}
'''
user = UserFactory.create()
af = AnalysisFrameworkFactory.create()
private_project_feature = FeatureFactory.create(key=Feature.FeatureKey.PRIVATE_PROJECT)
private_af = AnalysisFrameworkFactory.create(is_private=True)
private_af_w_membership = AnalysisFrameworkFactory.create(is_private=True)
private_af_w_membership.add_member(user)
org1 = OrganizationFactory.create()
minput = dict(
title='Project 1',
analysisFramework=str(private_af.id),
description='Project description 101',
startDate='2020-01-01',
endDate='2021-01-01',
status=self.genum(Project.Status.ACTIVE),
isPrivate=True,
hasPubliclyViewableLeads=False,
isVisualizationEnabled=False,
organizations=[
dict(
organization=str(org1.pk),
organizationType=self.genum(ProjectOrganization.Type.LEAD_ORGANIZATION),
),
],
)
def _query_check(**kwargs):
return self.query_check(
query,
minput=minput,
**kwargs,
)
# ---------- Without login
_query_check(assert_for_error=True)
# ---------- With login
self.force_login(user)
# ----------------- Some Invalid input
response = _query_check(okay=False)
# invalid [private AF with memership] + public project
minput['analysisFramework'] = str(private_af_w_membership.pk)
minput['isPrivate'] = False
response = _query_check(okay=False)
# invalid [private AF with memership] + private project + without feature permission
minput['isPrivate'] = True
response = _query_check(okay=False)
# invalid [private AF with memership] + private project + with feature permission
private_project_feature.users.add(user)
response = _query_check(okay=True)['data']['projectCreate']
self.assertMatchSnapshot(response, 'private-af-private-project-success')
# Valid [public AF] + private project
minput['analysisFramework'] = str(af.pk)
minput['isPrivate'] = True
response = _query_check(okay=True)['data']['projectCreate']
self.assertMatchSnapshot(response, 'public-af-private-project-success')
# Valid [public AF] + private project
minput['analysisFramework'] = str(af.pk)
minput['isPrivate'] = False
response = _query_check(okay=True)['data']['projectCreate']
self.assertMatchSnapshot(response, 'public-af-public-project-success')
def test_analysis_framework_detail_query(self):
query = '''
query MyQuery ($id: ID!) {
analysisFramework(id: $id) {
id
currentUserRole
description
isPrivate
title
allowedPermissions
secondaryTagging {
id
key
title
widgetId
order
properties
version
}
primaryTagging {
id
title
order
tooltip
widgets {
id
key
title
version
widgetId
order
properties
}
}
members {
id
joinedAt
addedBy {
id
displayName
}
member {
id
displayName
}
role {
id
title
}
}
visibleProjects {
id
title
}
}
}
'''
user = UserFactory.create()
another_user = UserFactory.create()
af = AnalysisFrameworkFactory.create()
af.add_member(another_user)
project = ProjectFactory.create(analysis_framework=af,
is_private=False)
private_project = ProjectFactory.create(analysis_framework=af,
is_private=True)
def _query_check(**kwargs):
return self.query_check(query, variables={'id': af.pk}, **kwargs)
# Without login
_query_check(assert_for_error=True)
# With login
self.force_login(user)
# Should work for normal AF
response = _query_check()['data']['analysisFramework']
self.assertEqual(len(response['secondaryTagging']), 0, response)
self.assertEqual(len(response['primaryTagging']), 0, response)
self.assertEqual(len(response['visibleProjects']), 1, response)
self.assertListIds(response['visibleProjects'], [project], response)
# lets add member to the private_project
private_project.add_member(user)
response = _query_check()['data']['analysisFramework']
self.assertEqual(len(response['visibleProjects']), 2, response)
self.assertListIds(response['visibleProjects'],
[project, private_project], response)
# Let's add some widgets and sections
sequence = factory.Sequence(lambda n: n)
rsequence = factory.Sequence(lambda n: 20 - n)
# Primary Tagging
for order, widget_count, tooltip, _sequence in (
(3, 2, 'Some tooltip info 101', sequence),
(1, 3, 'Some tooltip info 102', rsequence),
(2, 4, 'Some tooltip info 103', sequence),
):
section = SectionFactory.create(analysis_framework=af,
order=order,
tooltip=tooltip)
WidgetFactory.create_batch(widget_count,
analysis_framework=af,
section=section,
order=_sequence)
WidgetFactory.reset_sequence()
# Secondary Tagging
WidgetFactory.create_batch(4, analysis_framework=af, order=rsequence)
# Let's save/compare snapshot (without membership)
response = _query_check()
self.assertMatchSnapshot(response, 'without-membership')
# Let's save/compare snapshot (with membership)
af.add_member(user)
response = _query_check()
self.assertMatchSnapshot(response, 'with-membership')
def test_review_comments_project_scope_query(self):
"""
Include permission check
"""
query = '''
query MyQuery ($projectId: ID! $reviewId: ID!) {
project(id: $projectId) {
reviewComment(id: $reviewId) {
commentType
createdAt
createdBy {
id
firstName
}
id
mentionedUsers {
displayName
displayPictureUrl
}
textHistory {
createdAt
id
text
}
}
}
}
'''
user = UserFactory.create()
analysis_framework = AnalysisFrameworkFactory.create()
project = ProjectFactory.create(analysis_framework=analysis_framework)
lead = LeadFactory.create(project=project)
conf_lead = LeadFactory.create(
project=project, confidentiality=Lead.Confidentiality.CONFIDENTIAL)
entry = EntryFactory.create(project=project,
analysis_framework=analysis_framework,
lead=lead)
conf_entry = EntryFactory.create(project=project,
analysis_framework=analysis_framework,
lead=conf_lead)
review_comment = EntryReviewCommentFactory.create(entry=entry,
created_by=user)
conf_review_comment = EntryReviewCommentFactory.create(
entry=conf_entry, created_by=user)
review_text1, review_text2 = EntryReviewCommentTextFactory.create_batch(
2, comment=review_comment)
review_text_conf1, review_text_conf2 = EntryReviewCommentTextFactory.create_batch(
2, comment=conf_review_comment)
def _query_check(review_comment, **kwargs):
return self.query_check(query,
variables={
'projectId': project.id,
'reviewId': review_comment.id
},
**kwargs)
# Without login
_query_check(review_comment, assert_for_error=True)
_query_check(conf_review_comment, assert_for_error=True)
# With login
self.force_login(user)
# -- Without membership
content = _query_check(review_comment)
self.assertEqual(content['data']['project']['reviewComment'], None,
content)
# -- Without membership (confidential only)
current_membership = project.add_member(
user, role=self.project_role_reader_non_confidential)
content = _query_check(review_comment)
self.assertNotEqual(content['data']['project']['reviewComment'], None,
content)
self.assertEqual(
len(content['data']['project']['reviewComment']['textHistory']), 2,
content)
self.assertListIds(
content['data']['project']['reviewComment']['textHistory'],
[review_text1, review_text2], content)
content = _query_check(conf_review_comment)
self.assertEqual(content['data']['project']['reviewComment'], None,
content)
# -- With membership (non-confidential only)
current_membership.delete()
project.add_member(user, role=self.project_role_reader)
content = _query_check(review_comment)
self.assertNotEqual(content['data']['project']['reviewComment'], None,
content)
content = _query_check(conf_review_comment)
self.assertNotEqual(content['data']['project']['reviewComment'], None,
content)
self.assertEqual(
len(content['data']['project']['reviewComment']['textHistory']), 2,
content)
self.assertListIds(
content['data']['project']['reviewComment']['textHistory'],
[review_text_conf1, review_text_conf2], content)
def test_review_comments_query(self):
query = '''
query MyQuery ($projectId: ID! $entryId: ID!) {
project(id: $projectId) {
entry (id: $entryId) {
id
verifiedBy {
displayName
id
}
controlled
controlledChangedBy {
id
displayName
}
reviewCommentsCount
}
reviewComments (entry: $entryId, ordering: DESC_ID) {
totalCount
results {
id
text
commentType
createdAt
mentionedUsers {
displayName
id
}
}
}
}
}
'''
user = UserFactory.create()
user2, user3 = UserFactory.create_batch(2)
analysis_framework = AnalysisFrameworkFactory.create()
project = ProjectFactory.create(analysis_framework=analysis_framework)
lead = LeadFactory.create(project=project)
entry = EntryFactory.create(project=project,
analysis_framework=analysis_framework,
lead=lead,
controlled=True,
controlled_changed_by=user2,
verified_by=[user2, user3])
entry1 = EntryFactory.create(
project=project,
analysis_framework=analysis_framework,
lead=lead,
)
review_comment1, review_comment2 = EntryReviewCommentFactory.create_batch(
2, entry=entry, created_by=user)
EntryReviewCommentFactory.create(entry=entry1, created_by=user)
review_text1 = EntryReviewCommentTextFactory.create(
comment=review_comment1)
# -- Without login
self.query_check(query,
assert_for_error=True,
variables={
'projectId': project.id,
'entryId': entry.id
})
# -- With login
self.force_login(user)
# --- non-member user
content = self.query_check(query,
variables={
'projectId': project.id,
'entryId': entry.id
})
self.assertEqual(content['data']['project']['entry'], None, content)
# --- add-member in project
project.add_member(user)
content = self.query_check(query,
variables={
'projectId': project.id,
'entryId': entry.id
})
self.assertEqual(
content['data']['project']['entry']['reviewCommentsCount'], 2,
content)
self.assertEqual(
content['data']['project']['reviewComments']['totalCount'], 2,
content)
self.assertListIds(
content['data']['project']['reviewComments']['results'],
[review_comment1, review_comment2], content)
self.assertEqual(
content['data']['project']['reviewComments']['results'][1]['text'],
review_text1.text, content)
# add another review_text for same review_comment
review_text2 = EntryReviewCommentTextFactory.create(
comment=review_comment1)
content = self.query_check(query,
variables={
'projectId': project.id,
'entryId': entry.id
})
self.assertEqual(
content['data']['project']['entry']['reviewCommentsCount'], 2,
content)
self.assertEqual(
content['data']['project']['reviewComments']['results'][1]['text'],
review_text2.text, # here latest text should be present
content)
# lets check for the contolled in entry
self.assertEqual(content['data']['project']['entry']['controlled'],
True, content)
self.assertEqual(
content['data']['project']['entry']['controlledChangedBy']['id'],
str(user2.id), content)
self.assertEqual(
len(content['data']['project']['entry']['verifiedBy']), 2, content)
# lets query for another entry
content = self.query_check(query,
variables={
'projectId': project.id,
'entryId': entry1.id
})
self.assertEqual(
content['data']['project']['entry']['reviewCommentsCount'], 1,
content)
self.assertEqual(
content['data']['project']['reviewComments']['totalCount'], 1,
content)
def test_project_update_mutation(self):
query = '''
mutation MyMutation($projectId: ID!, $input: ProjectUpdateInputType!) {
__typename
project(id: $projectId) {
projectUpdate(data: $input) {
ok
errors
result {
id
title
analysisFramework {
id
isPrivate
}
description
startDate
endDate
isPrivate
hasPubliclyViewableLeads
isVisualizationEnabled
organizations {
id
organization {
id
title
}
organizationType
organizationTypeDisplay
}
status
}
}
}
}
'''
user = UserFactory.create()
normal_user = UserFactory.create()
another_user = UserFactory.create()
af = AnalysisFrameworkFactory.create()
private_af = AnalysisFrameworkFactory.create(is_private=True)
private_af_2 = AnalysisFrameworkFactory.create(is_private=True)
private_af_w_membership = AnalysisFrameworkFactory.create(is_private=True)
private_af_w_membership.add_member(user)
public_project = ProjectFactory.create(title='Public Project 101', analysis_framework=af)
private_project = ProjectFactory.create(title='Private Project 101', analysis_framework=private_af, is_private=True)
public_project.add_member(user, role=self.project_role_owner)
private_project.add_member(user, role=self.project_role_owner)
public_project.add_member(normal_user)
org1 = OrganizationFactory.create()
public_minput = dict(
title=public_project.title,
analysisFramework=str(public_project.analysis_framework.id),
isPrivate=False,
organizations=[
dict(
organization=str(org1.pk),
organizationType=self.genum(ProjectOrganization.Type.LEAD_ORGANIZATION),
),
],
)
private_minput = dict(
title=private_project.title,
analysisFramework=str(private_project.analysis_framework.id),
isPrivate=True,
organizations=[
dict(
organization=str(org1.pk),
organizationType=self.genum(ProjectOrganization.Type.LEAD_ORGANIZATION),
),
],
)
def _query_check(project, minput, **kwargs):
return self.query_check(
query,
minput=minput,
mnested=['project'],
variables={'projectId': str(project.pk)},
**kwargs,
)
def _public_query_check(**kwargs):
return _query_check(public_project, public_minput, **kwargs)
def _private_query_check(**kwargs):
return _query_check(private_project, private_minput, **kwargs)
# ---------- Without login
_public_query_check(assert_for_error=True)
_private_query_check(assert_for_error=True)
# ---------- With login (non member)
self.force_login(another_user)
_public_query_check(assert_for_error=True)
_private_query_check(assert_for_error=True)
# ---------- With login (member with low access)
self.force_login(normal_user)
_public_query_check(assert_for_error=True)
_private_query_check(assert_for_error=True)
# ---------- With login (member with high access)
self.force_login(user)
_public_query_check(okay=True)
_private_query_check(okay=True)
# WITH ACCESS
# ----- isPrivate attribute
# [changing private status) [public project]
public_minput['isPrivate'] = True
self.assertMatchSnapshot(_public_query_check(okay=False), 'public-project:is-private-change-error')
public_minput['isPrivate'] = False
# [changing private status) [public project]
private_minput['isPrivate'] = False
self.assertMatchSnapshot(_private_query_check(okay=False), 'private-project:is-private-change-error')
private_minput['isPrivate'] = True
# ----- AF attribute
# [changing private status) [public project]
public_minput['analysisFramework'] = str(private_af.id)
self.assertMatchSnapshot(_public_query_check(okay=False), 'public-project:private-af')
public_minput['analysisFramework'] = str(private_af_w_membership.id)
self.assertMatchSnapshot(_public_query_check(okay=False), 'public-project:private-af-with-membership')
public_minput['analysisFramework'] = str(public_project.analysis_framework_id)
# [changing private status) [private project]
private_minput['analysisFramework'] = str(private_af_2.id)
self.assertMatchSnapshot(_private_query_check(okay=False), 'private-project:private-af')
private_minput['analysisFramework'] = str(private_af_w_membership.id)
_private_query_check(okay=True)
private_minput['analysisFramework'] = str(private_project.analysis_framework_id)
def test_project_region_action_mutation(self):
query = '''
mutation MyMutation ($projectId: ID!, $regionsToAdd: [ID!], $regionsToRemove: [ID!]) {
project(id: $projectId) {
projectRegionBulk(regionsToAdd: $regionsToAdd, regionsToRemove: $regionsToRemove) {
result {
id
title
}
deletedResult {
id
title
}
}
}
}
'''
user = UserFactory.create()
normal_user = UserFactory.create()
another_user = UserFactory.create()
af = AnalysisFrameworkFactory.create()
project = ProjectFactory.create(title='Project 101', analysis_framework=af)
project.add_member(user, role=self.project_role_owner)
project.add_member(normal_user)
region_public = RegionFactory.create(title='public-region')
region_private = RegionFactory.create(title='private-region', public=False)
region_private_owner = RegionFactory.create(title='private-region-owner', public=False, created_by=user)
# Region with project membership
# -- Normal
region_private_with_membership = RegionFactory.create(title='private-region-with-membership', public=False)
another_project_for_membership = ProjectFactory.create()
another_project_for_membership.regions.add(region_private_with_membership)
another_project_for_membership.add_member(user, role=self.project_role_admin)
# -- Admin
region_private_with_membership_admin = RegionFactory.create(title='private-region-with-membership', public=False)
another_project_for_membership_admin = ProjectFactory.create()
another_project_for_membership_admin.regions.add(region_private_with_membership_admin)
another_project_for_membership_admin.add_member(user, role=self.project_role_admin)
def _query_check(add, remove, **kwargs):
return self.query_check(
query,
mnested=['project'],
variables={
'projectId': str(project.pk),
'regionsToAdd': add,
'regionsToRemove': remove,
},
**kwargs,
)
# ---------- Without login
_query_check([], [], assert_for_error=True)
# ---------- With login (non member)
self.force_login(another_user)
_query_check([], [], assert_for_error=True)
# ---------- With login (member + low access)
self.force_login(normal_user)
_query_check([], [], assert_for_error=True)
# ---------- With login (member with high access)
self.force_login(user)
# Simple checkup
response = _query_check([], [])
self.assertEqual(response['data']['project']['projectRegionBulk'], {
'deletedResult': [],
'result': [],
})
# Add
response = _query_check(
[
str(region_public.pk),
str(region_private.pk),
str(region_private_owner.pk),
str(region_private_with_membership.pk),
],
[],
)
self.assertEqual(response['data']['project']['projectRegionBulk'], {
'deletedResult': [],
'result': [
dict(id=str(region_public.pk), title=region_public.title),
dict(id=str(region_private_owner.pk), title=region_private_owner.title),
dict(id=str(region_private_with_membership.pk), title=region_private_with_membership.title),
],
})
self.assertEqual(
list(project.regions.values_list('id', flat=True).order_by('id')),
[
region_public.pk,
region_private_owner.pk,
region_private_with_membership.pk,
]
)
# Delete
response = _query_check(
[],
[
str(region_public.pk),
str(region_private.pk),
str(region_private_owner.pk),
str(region_private_with_membership.pk),
],
)
self.assertEqual(response['data']['project']['projectRegionBulk'], {
'deletedResult': [
dict(id=str(region_public.pk), title=region_public.title),
dict(id=str(region_private_owner.pk), title=region_private_owner.title),
dict(id=str(region_private_with_membership.pk), title=region_private_with_membership.title),
],
'result': [],
})
self.assertEqual(list(project.regions.values_list('id', flat=True).order_by('id')), [])
def test_projects_viz_node(self):
query = '''
query MyQuery ($id: ID!) {
project(id: $id) {
vizData {
dataUrl
modifiedAt
publicShare
publicUrl
status
}
title
isVisualizationAvailable
isVisualizationEnabled
}
}
'''
af = AnalysisFrameworkFactory.create()
member_user = UserFactory.create() # with confidential access
non_confidential_user = UserFactory.create()
non_member_user = UserFactory.create()
project = ProjectFactory.create(analysis_framework=af)
project.add_member(member_user, role=self.project_role_member)
project.add_member(non_confidential_user,
role=self.project_role_reader_non_confidential)
def _query_check(**kwargs):
return self.query_check(query,
variables={'id': project.pk},
**kwargs)
# -- Without login
_query_check(assert_for_error=True)
# -- With login
# Before enabling viz.
# --- non-member user
self.force_login(non_member_user)
content = _query_check()
self.assertEqual(content['data']['project']['vizData'], None, content)
self.assertEqual(content['data']['project']['isVisualizationEnabled'],
False, content)
self.assertEqual(
content['data']['project']['isVisualizationAvailable'], False,
content)
# --- member user
self.force_login(member_user)
content = _query_check()
self.assertEqual(content['data']['project']['vizData'], None, content)
self.assertEqual(content['data']['project']['isVisualizationEnabled'],
False, content)
self.assertEqual(
content['data']['project']['isVisualizationAvailable'], False,
content)
# Only enabling project viz settings (not configuring AF).
project.is_visualization_enabled = True
project.save(update_fields=('is_visualization_enabled', ))
# --- non-member user
self.force_login(non_member_user)
content = _query_check()
self.assertEqual(content['data']['project']['vizData'], None, content)
self.assertEqual(content['data']['project']['isVisualizationEnabled'],
True, content)
self.assertEqual(
content['data']['project']['isVisualizationAvailable'], False,
content)
# --- member user
self.force_login(member_user)
content = _query_check()
self.assertEqual(content['data']['project']['vizData'], None, content)
self.assertEqual(content['data']['project']['isVisualizationEnabled'],
True, content)
self.assertEqual(
content['data']['project']['isVisualizationAvailable'], False,
content)
# Configure/Enable viz.
TestProjectGeneralMutation.set_project_viz_configuration(project)
# --- non-member project
self.force_login(non_member_user)
content = _query_check()
self.assertEqual(content['data']['project']['vizData'], None, content)
self.assertEqual(content['data']['project']['isVisualizationEnabled'],
True, content)
self.assertEqual(
content['data']['project']['isVisualizationAvailable'], True,
content)
# --- member project
self.force_login(member_user)
content = _query_check()
self.assertNotEqual(content['data']['project']['vizData'], None,
content)
self.assertEqual(content['data']['project']['isVisualizationEnabled'],
True, content)
self.assertEqual(
content['data']['project']['isVisualizationAvailable'], True,
content)
self.assertEqual(
content['data']['project']['vizData'],
{
'dataUrl': '',
'modifiedAt': self.now_datetime_str,
'publicShare': False,
'publicUrl': None,
'status': self.genum(ProjectStats.Status.PENDING),
},
content,
)
# Enable public share/url
project_stats = project.project_stats.update_public_share_configuration(
ProjectStats.Action.ON)
content = _query_check()
self.assertNotEqual(content['data']['project']['vizData'], None,
content)
self.assertEqual(content['data']['project']['isVisualizationEnabled'],
True, content)
self.assertEqual(
content['data']['project']['isVisualizationAvailable'], True,
content)
self.assertEqual(
content['data']['project']['vizData'],
{
'dataUrl': '',
'modifiedAt': self.now_datetime_str,
'publicShare': True,
'publicUrl':
'http://testserver' + project_stats.get_public_url(),
'status': self.genum(ProjectStats.Status.PENDING),
},
content,
)
def test_projects_viz_configuration_update(self):
query = '''
mutation MyMutation($id: ID!, $input: ProjectVizConfigurationInputType!) {
project(id: $id) {
projectVizConfigurationUpdate(data: $input) {
ok
errors
result {
dataUrl
modifiedAt
publicShare
publicUrl
status
}
}
}
}
'''
normal_user = UserFactory.create()
admin_user = UserFactory.create()
member_user = UserFactory.create()
af = AnalysisFrameworkFactory.create()
project = ProjectFactory.create(analysis_framework=af)
self.set_project_viz_configuration(project)
project.add_member(admin_user, role=self.project_role_admin)
project.add_member(member_user, role=self.project_role_member)
minput = dict(action=None)
def _query_check(**kwargs):
return self.query_check(
query,
minput=minput,
mnested=['project'],
variables={'id': project.id},
**kwargs,
)
Action = ProjectStats.Action
_generate_project_viz_stats(project.pk)
# Check permission for token generation
for action in [Action.NEW, Action.OFF, Action.NEW, Action.ON]:
for user, assertLogic in [
(normal_user, self.assert_403),
(member_user, self.assert_403),
(admin_user, self.assert_200),
]:
self.force_login(user)
current_stats = project.project_stats
minput['action'] = self.genum(action)
if assertLogic == self.assert_200:
content = _query_check(okay=True)
else:
_query_check(assert_for_error=True)
continue
response = content['data']['project']['projectVizConfigurationUpdate']['result']
if assertLogic == self.assert_200:
if action == 'new':
assert response['publicUrl'] != current_stats.token
# Logout and check if response is okay
self.client.logout()
rest_response = self.client.get(f"{response['publicUrl']}?format=json")
self.assert_200(rest_response)
elif action == 'on':
assert (
response['publicUrl'] is not None
) or (
response['publicUrl'] == current_stats.token
)
# Logout and check if response is not okay
self.client.logout()
rest_response = self.client.get(f"{response['publicUrl']}?format=json")
self.assert_200(rest_response)
elif action == 'off':
assert (
response['publicUrl'] is not None
) or (
response['publicUrl'] == current_stats.token
)
# Logout and check if response is not okay
self.client.logout()
rest_response = self.client.get(f"{response['publicUrl']}?format=json")
self.assert_403(rest_response)
def test_leads_entries_query(self):
query = '''
query MyQuery ($id: ID!, $leadId: ID!) {
project(id: $id) {
analysisFramework {
id
}
lead(id: $leadId) {
id
entriesCount {
total
controlled
}
entries {
id
}
}
}
}
'''
af, af_new = AnalysisFrameworkFactory.create_batch(2)
user = UserFactory.create()
project = ProjectFactory.create(analysis_framework=af)
project.add_member(user, role=self.project_role_member)
lead = LeadFactory.create(project=project)
controlled_entries = EntryFactory.create_batch(2,
lead=lead,
controlled=True)
not_controlled_entries = EntryFactory.create_batch(3,
lead=lead,
controlled=False)
def _query_check():
return self.query_check(query,
variables={
'id': project.id,
'leadId': lead.id
})
# -- With login
self.force_login(user)
response = _query_check()
self.assertIdEqual(
response['data']['project']['analysisFramework']['id'], af.pk)
content = response['data']['project']['lead']
self.assertIdEqual(content['id'], lead.pk, content)
self.assertEqual(content['entriesCount']['total'], 5, content)
self.assertEqual(content['entriesCount']['controlled'], 2, content)
self.assertListIds(content['entries'],
[*controlled_entries, *not_controlled_entries],
content)
# Now change AF
project.analysis_framework = af_new
project.save(update_fields=('analysis_framework', ))
new_controlled_entries = EntryFactory.create_batch(4,
lead=lead,
controlled=True)
new_not_controlled_entries = EntryFactory.create_batch(
2, lead=lead, controlled=False)
response = _query_check()
self.assertIdEqual(
response['data']['project']['analysisFramework']['id'], af_new.pk)
content = response['data']['project']['lead']
self.assertIdEqual(content['id'], lead.pk, content)
self.assertEqual(content['entriesCount']['total'], 6, content)
self.assertEqual(content['entriesCount']['controlled'], 4, content)
self.assertListIds(
content['entries'],
[*new_controlled_entries, *new_not_controlled_entries], content)
def test_user_filters(self):
query = '''
query UserQuery($membersExcludeFramework: ID, $membersExcludeProject: ID, $search: String) {
users(
membersExcludeFramework: $membersExcludeFramework,
membersExcludeProject: $membersExcludeProject,
search: $search
) {
results {
organization
lastName
language
isActive
id
firstName
displayPictureUrl
displayName
}
page
pageSize
}
}
'''
project1, project2 = ProjectFactory.create_batch(2)
af1, af2 = AnalysisFrameworkFactory.create_batch(2)
user = UserFactory.create(first_name='Normal Guy')
user1, user2, user3 = UserFactory.create_batch(3)
project1.add_member(user1)
project1.add_member(user2)
project2.add_member(user2)
project2.add_member(user)
af1.add_member(user1)
af1.add_member(user2)
af1.add_member(user)
af2.add_member(user2)
def _query_check(filters, **kwargs):
return self.query_check(query, variables=filters, **kwargs)
# Without authentication -----
content = _query_check({}, assert_for_error=True)
# With authentication -----
self.force_login(user)
# Without any filters
for name, filters, count, users in (
('no-filter', dict(), 4, [user, user1, user2, user3]),
('exclude-project-1', dict(membersExcludeProject=project1.pk), 2,
[user, user3]),
('exclude-project-2', dict(membersExcludeProject=project2.pk), 2,
[user1, user3]),
('exclude-af-1', dict(membersExcludeFramework=af1.pk), 1, [user3]),
('exclude-af-2', dict(membersExcludeFramework=af2.pk), 3,
[user, user1, user3]),
('search', dict(search='Guy'), 1, [user]),
):
content = _query_check(filters)['data']['users']['results']
self.assertEqual(len(content), count, (name, content))
self.assertListIds(content, users, (name, content))
def test_snapshot(self):
query = '''
query MyQuery {
projectExploreStats {
totalProjects
totalUsers
leadsAddedWeekly
dailyAverageLeadsTaggedPerProject
generatedExportsMonthly
topActiveProjects {
projectId
projectTitle
analysisFrameworkId
analysisFrameworkTitle
}
calculatedAt
}
}
'''
def _cache_clear():
cache.delete(
CacheKey.PROJECT_EXPLORE_STATS_LOADER_KEY) # Delete cache
user = UserFactory.create()
# -- With login
self.force_login(user)
_cache_clear()
previous_content = content = self.query_check(query)
self.assertMatchSnapshot(content, 'no-data')
UserFactory.create_batch(3, is_active=False) # Some Inactive users
analysis_framework = AnalysisFrameworkFactory.create()
projects = ProjectFactory.create_batch(3)
projects_with_af = ProjectFactory.create_batch(
3, analysis_framework=analysis_framework)
# This shouldn't show in top projects but leads/entries count should
private_project = ProjectFactory.create(
title='Private Project',
is_private=True,
analysis_framework=analysis_framework)
now = timezone.now()
# Generate project cache
_generate_project_stats_cache()
content = self.query_check(query)
self.assertEqual(content, previous_content) # Test for cache
_cache_clear()
previous_content = content = self.query_check(
query) # Pull latest data
self.assertMatchSnapshot(content, 'only-project')
self.update_obj(LeadFactory.create(project=projects[0]),
created_at=now + relativedelta(weeks=-1))
self.update_obj(LeadFactory.create(project=projects[0]),
created_at=now + relativedelta(weeks=-1))
self.update_obj(LeadFactory.create(project=projects[1]),
created_at=now + relativedelta(weeks=-2))
self.update_obj(LeadFactory.create(project=projects[1]),
created_at=now + relativedelta(weeks=-1))
self.update_obj(LeadFactory.create(project=projects[1]),
created_at=now + relativedelta(weeks=-1))
self.update_obj(LeadFactory.create(project=projects[2]),
created_at=now + relativedelta(weeks=-2))
lead0_1 = self.update_obj(
LeadFactory.create(project=projects_with_af[0]),
created_at=now + relativedelta(weeks=-1))
lead1_1 = self.update_obj(
LeadFactory.create(project=projects_with_af[1]),
created_at=now + relativedelta(weeks=-2))
lead1_2 = self.update_obj(
LeadFactory.create(project=projects_with_af[1]),
created_at=now + relativedelta(weeks=-1))
plead1_1 = self.update_obj(LeadFactory.create(project=private_project),
created_at=now + relativedelta(weeks=-2))
plead1_2 = self.update_obj(LeadFactory.create(project=private_project),
created_at=now + relativedelta(weeks=-1))
self.update_obj(LeadFactory.create(project=projects_with_af[1]),
created_at=now + relativedelta(weeks=-1))
self.update_obj(LeadFactory.create(project=projects_with_af[2]),
created_at=now + relativedelta(weeks=-3))
self.update_obj(EntryFactory.create(lead=lead0_1),
created_at=now + relativedelta(weeks=-1))
self.update_obj(EntryFactory.create(lead=lead1_1),
created_at=now + relativedelta(weeks=-1))
self.update_obj(EntryFactory.create(lead=lead1_2),
created_at=now + relativedelta(weeks=-1))
self.update_obj(EntryFactory.create(lead=plead1_1),
created_at=now + relativedelta(weeks=-1))
self.update_obj(EntryFactory.create(lead=plead1_2),
created_at=now + relativedelta(weeks=-1))
# Generate project cache
_generate_project_stats_cache()
self.update_obj(ExportFactory.create(project=projects_with_af[0],
exported_by=user),
exported_at=now + relativedelta(months=-1))
self.update_obj(ExportFactory.create(project=projects_with_af[0],
exported_by=user),
exported_at=now + relativedelta(months=-1))
self.update_obj(ExportFactory.create(project=projects_with_af[0],
exported_by=user),
exported_at=now + relativedelta(months=-2))
self.update_obj(ExportFactory.create(project=projects_with_af[1],
exported_by=user),
exported_at=now + relativedelta(months=-2))
self.update_obj(ExportFactory.create(project=projects_with_af[2],
exported_by=user),
exported_at=now + relativedelta(months=-3))
self.update_obj(ExportFactory.create(project=private_project,
exported_by=user),
exported_at=now + relativedelta(months=-1))
content = self.query_check(query)
self.assertEqual(content, previous_content) # Test for cache
_cache_clear()
previous_content = content = self.query_check(
query) # Pull latest data
self.assertMatchSnapshot(content, 'with-data')
def test_project_query(self):
"""
Test private + non-private project behaviour
"""
query = '''
query MyQuery ($id: ID!) {
project(id: $id) {
id
title
currentUserRole
startDate
status
isVisualizationEnabled
isPrivate
endDate
description
data
stats {
entriesActivity {
count
date
}
numberOfLeads
numberOfLeadsNotTagged
numberOfLeadsInProgress
numberOfLeadsTagged
numberOfEntries
numberOfEntriesVerified
numberOfEntriesControlled
numberOfUsers
leadsActivity {
count
date
}
}
membershipPending
isRejected
regions {
id
title
}
}
}
'''
user = UserFactory.create()
analysis_framework = AnalysisFrameworkFactory.create()
public_project, public_project2, public_project3, public_project4 = ProjectFactory.create_batch(
4, analysis_framework=analysis_framework)
now = timezone.now()
lead1_1 = self.update_obj(LeadFactory.create(project=public_project),
created_at=now + relativedelta(months=-1))
lead1_2 = self.update_obj(LeadFactory.create(project=public_project),
created_at=now + relativedelta(months=-2))
lead1_3 = self.update_obj(LeadFactory.create(project=public_project),
created_at=now + relativedelta(months=-2))
lead1_4 = self.update_obj(LeadFactory.create(project=public_project),
created_at=now + relativedelta(months=-1))
self.update_obj(LeadFactory.create(project=public_project),
created_at=now + relativedelta(months=-1))
data = [
{
"lead": lead1_1,
"controlled": False,
"months": -1,
},
{
"lead": lead1_1,
"controlled": False,
"months": -3,
},
{
"lead": lead1_2,
"controlled": True,
"months": -3,
},
{
"lead": lead1_2,
"controlled": False,
"months": -2,
},
{
"lead": lead1_2,
"controlled": True,
"months": -2,
},
{
"lead": lead1_3,
"controlled": True,
"months": -3,
},
{
"lead": lead1_3,
"controlled": True,
"months": -3,
},
]
now = timezone.now()
for item in data:
self.update_obj(
EntryFactory.create(lead=item['lead'],
controlled=item['controlled'],
project=public_project,
analysis_framework=analysis_framework),
created_at=now + relativedelta(months=item['months']))
EntryFactory.create(lead=lead1_3,
project=public_project,
controlled=True,
analysis_framework=analysis_framework)
EntryFactory.create(lead=lead1_4,
project=public_project,
controlled=True,
analysis_framework=analysis_framework)
lead2 = LeadFactory.create(project=public_project2)
lead3 = LeadFactory.create(project=public_project3)
EntryFactory.create(lead=lead2,
project=public_project2,
controlled=False,
analysis_framework=analysis_framework)
EntryFactory.create(lead=lead3,
project=public_project3,
controlled=False,
analysis_framework=analysis_framework)
user2, user3, request_user, non_member_user = UserFactory.create_batch(
4)
public_project = ProjectFactory.create(
analysis_framework=analysis_framework)
private_project = ProjectFactory.create(
is_private=True, analysis_framework=analysis_framework)
ProjectJoinRequestFactory.create(project=public_project,
requested_by=request_user,
status='pending',
role=self.project_role_admin)
# create projectJoinRequest(status='rejected')
ProjectJoinRequestFactory.create(project=public_project4,
requested_by=request_user,
status='rejected',
role=self.project_role_admin)
# add some project member
public_project.add_member(user)
public_project.add_member(user2)
public_project.add_member(user3)
# add some lead for the project
lead = LeadFactory.create(project=public_project)
lead2 = LeadFactory.create(project=public_project)
LeadFactory.create_batch(3, project=public_project)
LeadFactory.create(project=private_project)
# add some entry for the project
EntryFactory.create_batch(4,
project=public_project,
analysis_framework=analysis_framework,
lead=lead)
entry2_1 = EntryFactory.create(project=public_project,
analysis_framework=analysis_framework,
lead=lead2,
controlled=True)
entry2_2 = EntryFactory.create(project=public_project,
analysis_framework=analysis_framework,
lead=lead2)
EntryFactory.create(project=private_project,
analysis_framework=analysis_framework,
lead=lead)
# Verify entries
entry2_1.verified_by.add(user)
entry2_1.verified_by.add(user3)
entry2_2.verified_by.add(user)
# NOTE: Right noe only IN_PROGRESS status is set automatically
# Control one lead
lead2.status = Lead.Status.TAGGED
lead2.save(update_fields=('status', ))
# lets add some regions to project
region1, region2, region3 = RegionFactory.create_batch(3)
public_project.regions.add(region1)
public_project.regions.add(region2)
private_project.regions.add(region3)
# Generate project cache
_generate_project_stats_cache()
# -- Without login
self.query_check(query,
assert_for_error=True,
variables={'id': public_project.id})
self.query_check(query,
assert_for_error=True,
variables={'id': private_project.id})
# -- With login
self.force_login(user)
# --- non-member user
content = self.query_check(query, variables={'id': public_project.id})
self.assertNotEqual(content['data']['project'], None, content)
content = self.query_check(query, variables={'id': private_project.id})
self.assertEqual(content['data']['project'], None, content)
# login with non_member
self.force_login(non_member_user)
content = self.query_check(query, variables={'id': public_project.id})
self.assertNotEqual(content['data']['project'], None, content)
self.assertEqual(content['data']['project']['membershipPending'],
False)
# login with request_user
self.force_login(request_user)
content = self.query_check(query, variables={'id': public_project4.id})
self.assertNotEqual(content['data']['project'], None, content)
self.assertEqual(content['data']['project']['isRejected'], True)
# --- member user
# ---- (public-project)
self.force_login(user)
content = self.query_check(query, variables={'id': public_project.id})
self.assertNotEqual(content['data']['project'], None, content)
self.assertEqual(content['data']['project']['stats']['numberOfLeads'],
5, content)
self.assertEqual(
content['data']['project']['stats']['numberOfLeadsNotTagged'], 3,
content)
self.assertEqual(
content['data']['project']['stats']['numberOfLeadsInProgress'], 1,
content)
self.assertEqual(
content['data']['project']['stats']['numberOfLeadsTagged'], 1,
content)
self.assertEqual(
content['data']['project']['stats']['numberOfEntries'], 6, content)
self.assertEqual(
content['data']['project']['stats']['numberOfEntriesVerified'], 2,
content)
self.assertEqual(
content['data']['project']['stats']['numberOfEntriesControlled'],
1, content)
self.assertEqual(content['data']['project']['stats']['numberOfUsers'],
3, content)
self.assertEqual(
len(content['data']['project']['stats']['leadsActivity']), 1,
content)
self.assertEqual(
len(content['data']['project']['stats']['entriesActivity']), 1,
content)
self.assertEqual(len(content['data']['project']['regions']), 2,
content)
self.assertListIds(content['data']['project']['regions'],
[region1, region2], content)
# login with request user
self.force_login(request_user)
content = self.query_check(query, variables={'id': public_project.id})
self.assertNotEqual(content['data']['project'], None, content)
self.assertEqual(content['data']['project']['membershipPending'], True)
# ---- (private-project)
self.force_login(user)
private_project.add_member(user)
content = self.query_check(query, variables={'id': private_project.id})
self.assertNotEqual(content['data']['project'], None, content)
self.assertEqual(len(content['data']['project']['regions']), 1,
content)
self.assertListIds(content['data']['project']['regions'], [region3],
content)
def test_public_projects(self):
query = '''
query MyQuery {
publicProjects (ordering: "id") {
page
pageSize
totalCount
results {
id
title
description
createdAt
analysisFrameworkTitle
organizationsTitle
regionsTitle
numberOfEntries
numberOfLeads
numberOfUsers
}
}
}
'''
# Lets create some analysis_framework(private + publice)
public_analysis_framework = AnalysisFrameworkFactory.create(
is_private=False, title='Public Analysis Framework Title')
private_analysis_framework = AnalysisFrameworkFactory.create(
title='Private Analysis Framework Title', is_private=True)
# lets create some regions(private + public)
public_region = RegionFactory.create(public=True,
title='Public Region')
private_region = RegionFactory.create(public=False,
title='Private Region')
public_project1 = ProjectFactory.create(
analysis_framework=public_analysis_framework,
regions=[public_region])
public_project2 = ProjectFactory.create(
analysis_framework=public_analysis_framework,
regions=[private_region])
public_project3 = ProjectFactory.create(
analysis_framework=private_analysis_framework,
regions=[public_region])
public_project4 = ProjectFactory.create(
analysis_framework=private_analysis_framework,
regions=[public_region])
private_project = ProjectFactory.create(is_private=True)
content = self.query_check(query)
self.assertEqual(content['data']['publicProjects']['totalCount'], 4,
content)
self.assertListIds(content['data']['publicProjects']['results'], [
public_project1, public_project2, public_project3, public_project4
], content)
# some checks for analysis_framework private and public
self.assertEqual(
content['data']['publicProjects']['results'][0]
['analysisFrameworkTitle'], 'Public Analysis Framework Title',
content)
self.assertEqual(
content['data']['publicProjects']['results'][2]
['analysisFrameworkTitle'], None, content)
# some check for regions private and public
self.assertEqual(
content['data']['publicProjects']['results'][2]['regionsTitle'],
'Public Region', content)
self.assertEqual(
content['data']['publicProjects']['results'][1]['regionsTitle'],
None, content)
# make sure private projects are not visible here
self.assertNotListIds(content['data']['publicProjects']['results'],
[private_project], content)