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" }