def test_project_allowed_permissions(self):
query = '''
query MyQuery {
projects {
results {
id
allowedPermissions
}
}
}
'''
project1, project2 = ProjectFactory.create_batch(2)
user = UserFactory.create()
project1.add_member(user, badges=[])
project2.add_member(user, badges=[ProjectMembership.BadgeType.QA])
self.force_login(user)
content_projects = self.query_check(
query)['data']['projects']['results']
QA_PERMISSION = self.genum(PP.Permission.CAN_QUALITY_CONTROL)
content_projects_permissions = {
int(pdata['id']): pdata['allowedPermissions']
for pdata in content_projects
}
self.assertEqual(len(content_projects), 2, content_projects)
self.assertNotIn(QA_PERMISSION,
content_projects_permissions[project1.pk],
content_projects)
self.assertIn(QA_PERMISSION, content_projects_permissions[project2.pk],
content_projects)
def test_status_filter(self):
p1, p2 = ProjectFactory.create_batch(2, status=Project.Status.ACTIVE)
p3 = ProjectFactory.create(status=Project.Status.INACTIVE)
obtained = self.filter_class(data=dict(
status=Project.Status.ACTIVE.value)).qs
expected = [p1, p2]
self.assertQuerySetIdEqual(expected, obtained)
obtained = self.filter_class(data=dict(
status=Project.Status.INACTIVE.value)).qs
expected = [p3]
self.assertQuerySetIdEqual(expected, obtained)
def test_organization_filter(self):
org1, org2, org3 = OrganizationFactory.create_batch(3)
p1, p2, p3 = ProjectFactory.create_batch(3)
p1.organizations.set([org2, org1])
p2.organizations.set([org2, org3])
p3.organizations.add(org1)
obtained = self.filter_class(data=dict(
organizations=[org3.pk, org2.pk])).qs
expected = [p2, p1]
self.assertQuerySetIdEqual(expected, obtained)
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 test_project_join_reason_length(self):
user = UserFactory.create()
project1, project2 = ProjectFactory.create_batch(2)
reason = fuzzy.FuzzyText(length=49).fuzz()
minput = dict(project=project1.id, reason=reason)
self.force_login(user)
# Invalid
content = self.query_check(self.project_join_mutation, minput=minput, okay=False)
self.assertEqual(len(content['data']['joinProject']['errors']), 1, content)
# Invalid
minput['reason'] = fuzzy.FuzzyText(length=501).fuzz()
content = self.query_check(self.project_join_mutation, minput=minput, okay=False)
self.assertEqual(len(content['data']['joinProject']['errors']), 1, content)
# Valid (Project 1) max=500
minput['reason'] = fuzzy.FuzzyText(length=500).fuzz()
content = self.query_check(self.project_join_mutation, minput=minput, okay=True)
self.assertEqual(content['data']['joinProject']['errors'], None, content)
# Valid (Project 2) min=50
minput['reason'] = fuzzy.FuzzyText(length=50).fuzz()
minput['project'] = project2.pk
content = self.query_check(self.project_join_mutation, minput=minput, okay=True)
self.assertEqual(content['data']['joinProject']['errors'], None, content)
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_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_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))