def test_filter_users(self):
ue = create_user_with_role(MONITORING_EXPERT_EDITOR)
ur = create_user_with_role(MONITORING_EXPERT_REVIEWER)
ua = create_user_with_role(ADMIN)
ui = create_user_with_role(IT_HEAD)
roles = ['admin', 'editor']
response = self.query(
self.users_q,
variables={"roles": roles},
)
content = response.json()
print(content)
self.assertResponseNoErrors(response)
self.assertEqual(
sorted([
int(each['id']) for each in content['data']['users']['results']
]), sorted([ue.id, ua.id]))
roles = ['reviewer', 'editor']
response = self.query(
self.users_q,
variables={"roles": roles},
)
content = response.json()
self.assertResponseNoErrors(response)
self.assertEqual(
sorted([
int(each['id']) for each in content['data']['users']['results']
]), sorted([ur.id, ue.id]))
def test_fetch_reviews_to_be_reviewed(self):
e1 = create_user_with_role(MONITORING_EXPERT_EDITOR)
e2 = create_user_with_role(MONITORING_EXPERT_EDITOR)
entry = EntryFactory.create(created_by=e1)
entry.reviewers.set([e1, e2])
entry2 = EntryFactory.create(created_by=e1)
entry2.reviewers.set([e2])
self.assertEqual(entry.reviewers.count(), 2)
self.force_login(e1)
response = self.query(self.reviewer_q)
content = json.loads(response.content)
self.assertResponseNoErrors(response)
self.assertEqual(content['data']['me']['email'], e1.email)
self.assertIn(entry, e1.review_entries.all())
self.assertEqual(content['data']['me']['reviewEntries']['totalCount'],
1)
self.assertEqual(
content['data']['me']['reviewEntries']['results'][0]['id'],
str(entry.id))
self.force_login(e2)
response = self.query(self.reviewer_q)
content = json.loads(response.content)
self.assertResponseNoErrors(response)
self.assertIn(entry2, e2.review_entries.all())
self.assertEqual(content['data']['me']['reviewEntries']['totalCount'],
2)
self.assertListEqual([
int(each['id'])
for each in content['data']['me']['reviewEntries']['results']
], [entry.id, entry2.id])
def test_entry_can_be_updated_by(self):
editor2 = create_user_with_role(MONITORING_EXPERT_EDITOR)
self.assertFalse(self.entry.can_be_updated_by(editor2))
reviwer = create_user_with_role(MONITORING_EXPERT_REVIEWER)
self.assertFalse(self.entry.can_be_updated_by(reviwer))
admin = create_user_with_role(ADMIN)
self.assertTrue(self.entry.can_be_updated_by(admin))
def test_invalid_guest_entry_create(self):
guest = create_user_with_role(role=GUEST)
self.force_login(guest)
response = self.query(self.mutation, input_data=self.input)
content = json.loads(response.content)
self.assertIn(PERMISSION_DENIED_MESSAGE,
content['errors'][0]['message'])
def setUp(self):
self.reviewer = create_user_with_role(MONITORING_EXPERT_REVIEWER)
self.group = ResourceGroupFactory.create(created_by=self.reviewer)
self.countries = CountryFactory.create_batch(3)
self.mutation = '''
mutation CreateResource($input: ResourceCreateInputType!) {
createResource(resource: $input) {
ok
resource {
name
}
errors {
field
messages
}
}
}
'''
self.input = {
'name': 'name',
'url': 'http://example.com',
'group': self.group.id,
'countries': [each.id for each in self.countries]
}
self.force_login(self.reviewer)
def setUp(self) -> None:
self.country1 = CountryFactory.create()
self.country2, self.country3 = CountryFactory.create_batch(2)
self.country_q = '''
query MyQuery {
country(id: %s) {
operatingContacts {
results {
id
}
}
contacts {
results {
id
}
}
}
}
'''
self.contact1 = ContactFactory.create(country=self.country1)
self.contact1.countries_of_operation.set(
[self.country2, self.country3])
self.contact2 = ContactFactory.create(country=self.country2)
self.contact2.countries_of_operation.set(
[self.country1, self.country3])
self.force_login(create_user_with_role(MONITORING_EXPERT_EDITOR))
def test_invalid_reviewer_entry_create(self):
reviewer = create_user_with_role(role=MONITORING_EXPERT_REVIEWER)
self.force_login(reviewer)
response = self.query(self.mutation, input_data=self.input)
content = json.loads(response.content)
self.assertIn(PERMISSION_DENIED_MESSAGE,
content['errors'][0]['message'])
def test_invalid_contact_delete_by_guest(self) -> None:
guest = create_user_with_role(GUEST)
self.force_login(guest)
response = self.query(self.mutation, variables=self.variables)
content = json.loads(response.content)
self.assertIn(PERMISSION_DENIED_MESSAGE,
content['errors'][0]['message'])
def test_valid_entry_update_by_admins(self):
admin = create_user_with_role(ADMIN)
self.force_login(admin)
response = self.query(self.mutation, input_data=self.input)
content = json.loads(response.content)
self.assertResponseNoErrors(response)
self.assertTrue(content['data']['updateEntry']['ok'], content)
def test_invalid_delete_by_reviewer(self):
reviewer = create_user_with_role(role=MONITORING_EXPERT_REVIEWER)
self.force_login(reviewer)
response = self.query(self.mutation, variables=self.variables)
content = json.loads(response.content)
self.assertIn(PERMISSION_DENIED_MESSAGE,
content['errors'][0]['message'])
def test_invalid_organization_kind_update_by_guest(self) -> None:
guest = create_user_with_role(GUEST)
self.force_login(guest)
response = self.query(
self.mutation,
input_data=self.input
)
content = json.loads(response.content)
self.assertIn(PERMISSION_DENIED_MESSAGE, content['errors'][0]['message'])
def test_valid_entry_delete_by_admins(self):
admin = create_user_with_role(ADMIN)
self.force_login(admin)
response = self.query(self.mutation, variables=self.variables)
content = json.loads(response.content)
self.assertResponseNoErrors(response)
self.assertTrue(content['data']['deleteEntry']['ok'], content)
self.assertEqual(content['data']['deleteEntry']['entry']['url'],
self.entry.url)
def setUp(self) -> None:
countries = CountryFactory.create_batch(2)
self.mutation = '''mutation CreateEvent($input: EventCreateInputType!) {
createEvent(event: $input) {
errors {
field
messages
}
event {
disasterType {
name
}
disasterCategory {
name
}
disasterSubCategory {
name
}
disasterSubType {
name
}
startDate
endDate
name
eventType
violence {
name
}
triggerSubType {
name
}
trigger {
name
}
violenceSubType {
name
}
countries {
name
}
}
ok
}
}'''
self.input = {
"crisis": CrisisFactory().id,
"name": "Event1",
"eventType": "DISASTER",
"glideNumber": "glide number",
"disasterCategory": DisasterCategoryFactory().id,
"countries": [each.id for each in countries]
}
editor = create_user_with_role(MONITORING_EXPERT_EDITOR)
self.force_login(editor)
def setUp(self) -> None:
self.editor = create_user_with_role(MONITORING_EXPERT_EDITOR)
self.event = EventFactory.create()
self.mutation = """
mutation CreateEntry($input: EntryCreateInputType!) {
createEntry(entry: $input) {
ok
errors {
field
messages
arrayErrors {
key
objectErrors {
field
messages
arrayErrors {
key
objectErrors {
field
messages
}
}
}
}
}
entry {
id
document
figures {
results {
id
}
totalCount
}
}
}
}
"""
self.input = {
"url": "https://yoko-onos-blog.com",
"articleTitle": "title 1",
"source": "source 1",
"publisher": "publisher 1",
"publishDate": "2020-09-09",
"tags": ["2020", "grid2020", "south", "asia"],
"sourceMethodology": "method",
"sourceExcerpt": "excerpt one",
"sourceBreakdown": "break down",
"idmcAnalysis": "analysis one",
"methodology": "methoddddd",
"reviewers": [],
"event": self.event.id,
}
self.force_login(self.editor)
def test_valid_contact_delete(self) -> None:
reviewer = create_user_with_role(MONITORING_EXPERT_REVIEWER)
self.force_login(reviewer)
response = self.query(self.mutation, variables=self.variables)
content = json.loads(response.content)
self.assertResponseNoErrors(response)
self.assertTrue(content['data']['deleteContact']['ok'], content)
self.assertEqual(content['data']['deleteContact']['contact']['id'],
self.variables['id'])
def test_valid_delete_crisis_by_different_monitoring_expert(self):
editor2 = create_user_with_role(MONITORING_EXPERT_EDITOR)
self.force_login(editor2)
response = self.query(
self.mutation,
variables=self.variables
)
content = json.loads(response.content)
self.assertResponseNoErrors(response)
self.assertTrue(content['data']['deleteCrisis']['ok'], content)
self.assertIsNotNone(content['data']['deleteCrisis']['crisis']['name'])
def test_invalid_figure_create_by_non_creator_entry(self):
creator2 = create_user_with_role(MONITORING_EXPERT_EDITOR)
self.force_login(creator2)
response = self.query(self.mutation, input_data=self.input)
content = json.loads(response.content)
self.assertResponseNoErrors(response)
self.assertFalse(content['data']['createFigure']['ok'], content)
self.assertIn('non_field_errors', [
each['field'] for each in content['data']['createFigure']['errors']
])
self.assertIn('You cannot create a figure into',
json.dumps(content['data']['createFigure']['errors']))
def test_invalid_entry_delete_by_non_owner(self):
editor2 = create_user_with_role(role=MONITORING_EXPERT_EDITOR)
self.force_login(editor2)
response = self.query(self.mutation, variables=self.variables)
content = json.loads(response.content)
self.assertResponseNoErrors(response)
self.assertFalse(content['data']['deleteEntry']['ok'], content)
self.assertIn('non_field_errors', [
each['field'] for each in content['data']['deleteEntry']['errors']
])
self.assertIn('You cannot delete this entry',
json.dumps(content['data']['deleteEntry']['errors']))
def test_valid_update_crisis_by_different_user(self):
reviewer = create_user_with_role(MONITORING_EXPERT_REVIEWER)
self.force_login(reviewer)
response = self.query(
self.mutation,
input_data=self.input
)
content = json.loads(response.content)
self.assertResponseNoErrors(response)
self.assertTrue(content['data']['updateCrisis']['ok'], content)
self.assertEqual(content['data']['updateCrisis']['crisis']['name'],
self.input['name'])
def test_invalid_create_different_users_resource_group(self):
reviewer2 = create_user_with_role(MONITORING_EXPERT_REVIEWER)
self.force_login(reviewer2)
response = self.query(self.mutation, input_data=self.input)
content = json.loads(response.content)
self.assertResponseNoErrors(response)
self.assertFalse(content['data']['createResource']['ok'], content)
self.assertIn('group', [
each['field']
for each in content['data']['createResource']['errors']
])
def test_valid_create_resource_group(self):
old = ResourceGroup.objects.count()
reviewer = create_user_with_role(MONITORING_EXPERT_REVIEWER)
self.force_login(reviewer)
response = self.query(self.mutation, input_data=self.input)
content = json.loads(response.content)
self.assertResponseNoErrors(response)
self.assertTrue(content['data']['createResourceGroup']['ok'], content)
self.assertEqual(
content['data']['createResourceGroup']['resourceGroup']['name'],
self.input['name'])
self.assertEqual(old + 1, ResourceGroup.objects.count())
def test_valid_contact_update(self) -> None:
reviewer = create_user_with_role(MONITORING_EXPERT_REVIEWER)
self.force_login(reviewer)
response = self.query(self.mutation, input_data=self.input)
content = json.loads(response.content)
self.assertResponseNoErrors(response)
self.assertTrue(content['data']['updateContact']['ok'], content)
self.assertEqual(
content['data']['updateContact']['contact']['firstName'],
self.input['firstName'])
self.assertEqual(
content['data']['updateContact']['contact']['lastName'],
self.contact.last_name)
def test_valid_organization_kind_creation(self) -> None:
reviewer = create_user_with_role(MONITORING_EXPERT_REVIEWER)
self.force_login(reviewer)
response = self.query(
self.mutation,
input_data=self.input
)
content = json.loads(response.content)
self.assertResponseNoErrors(response)
self.assertTrue(content['data']['createOrganizationKind']['ok'], content)
self.assertIsNotNone(content['data']['createOrganizationKind']['organizationKind']['id'])
self.assertEqual(content['data']['createOrganizationKind']['organizationKind']['title'],
self.input['title'])
def setUp(self) -> None:
countries = CountryFactory.create_batch(2)
self.mutation = '''mutation UpdateEvent($input: EventUpdateInputType!) {
updateEvent(event: $input) {
errors {
field
messages
}
event {
startDate
endDate
name
eventType
violence {
name
}
triggerSubType {
name
}
trigger {
name
}
violenceSubType {
name
}
countries {
name
}
}
ok
}
}'''
self.input = {
"id": EventFactory.create().id,
"countries": [each.id for each in countries],
"endDate": "2020-10-29",
"eventNarrative": "",
"eventType": "CONFLICT",
"name": "xyz",
"startDate": "2020-10-20",
"violence": ViolenceFactory.create().id,
}
editor = create_user_with_role(MONITORING_EXPERT_EDITOR)
self.force_login(editor)
def test_valid_contact_creation(self) -> None:
reviewer = create_user_with_role(MONITORING_EXPERT_REVIEWER)
self.force_login(reviewer)
response = self.query(self.mutation, input_data=self.input)
content = json.loads(response.content)
self.assertResponseNoErrors(response)
self.assertTrue(content['data']['createContact']['ok'], content)
self.assertEqual(
content['data']['createContact']['contact']['firstName'],
self.input['firstName'])
self.assertEqual(
content['data']['createContact']['contact']['organization']['id'],
self.input['organization'])
self.assertEqual(
len(content['data']['createContact']['contact']
['countriesOfOperation']),
len(self.input['countriesOfOperation']))
def setUp(self) -> None:
self.factory = RequestFactory()
self.event = EventFactory.create()
self.data = {
"url": "https://yoko-onos-blog.com",
"article_title": "title 1",
"source": "source 1",
"publisher": "publisher 1",
"publish_date": "2020-09-09",
"tags": ["2020", "grid2020", "south", "asia"],
"source_methodology": "method",
"source_excerpt": "excerpt one",
"source_breakdown": "break down",
"idmc_analysis": "analysis one",
"methodology": "methoddddd",
"event": self.event.id,
}
self.request = self.factory.get('/graphql')
self.request.user = self.user = create_user_with_role(MONITORING_EXPERT_EDITOR)
def setUp(self) -> None:
self.editor = create_user_with_role(MONITORING_EXPERT_EDITOR)
self.entry = EntryFactory.create(created_by=self.editor)
self.mutation = """
mutation UpdateEntry($input: EntryUpdateInputType!) {
updateEntry(entry: $input) {
ok
errors {
field
messages
}
entry {
id
url
}
}
}
"""
self.input = {
"id": self.entry.id,
"publisher": "updated-publisher",
}
def setUp(self) -> None:
self.editor = create_user_with_role(MONITORING_EXPERT_EDITOR)
self.crisis = CrisisFactory.create(
created_by=self.editor
)
self.mutation = """
mutation DeleteCrisis($id: ID!) {
deleteCrisis(id: $id) {
ok
errors {
field
messages
}
crisis {
name
}
}
}
"""
self.variables = {
"id": self.crisis.id,
}
def setUp(self) -> None:
self.mutation = '''mutation DeleteEvent($id: ID!) {
deleteEvent(id: $id) {
errors {
field
messages
}
event {
id
startDate
endDate
name
eventType
violence {
name
}
triggerSubType {
name
}
trigger {
name
}
violenceSubType {
name
}
countries {
name
}
}
ok
}
}'''
self.event = EventFactory.create()
self.variables = {
"id": self.event.id,
}
editor = create_user_with_role(MONITORING_EXPERT_EDITOR)
self.force_login(editor)
def setUp(self) -> None:
self.editor = create_user_with_role(MONITORING_EXPERT_EDITOR)
self.crisis = CrisisFactory.create(
created_by=self.editor
)
self.mutation = """
mutation UpdateCrisis($input: CrisisUpdateInputType!) {
updateCrisis(crisis: $input) {
ok
errors {
field
messages
}
crisis {
name
}
}
}
"""
self.input = {
"id": self.crisis.id,
"name": "New Name"
}
