ramon
/
skillbox
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects 1 Releases 1 Wiki Activity

Update unit tests

This commit is contained in:
Ramon Wenger 2022-06-13 15:37:15 +02:00
parent af7dfad9c1
commit 22460fcf28
16 changed files with 86 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
server/assignments/tests/test_feedback.py
View File

@ -51,7 +51,7 @@ class SubmissionFeedbackTestCase(SkillboxTestCase):
}) })
def _fetch_assignment_student(self, user): def _fetch_assignment_student(self, user):
client = create_client(user) client = self.get_client(user)
query = ''' query = '''
query AssignmentWithSubmissions($id: ID!) { query AssignmentWithSubmissions($id: ID!) {
assignment(id: $id) { assignment(id: $id) {
@ -72,7 +72,7 @@ class SubmissionFeedbackTestCase(SkillboxTestCase):
}) })
def _fetch_assignment_teacher(self, user): def _fetch_assignment_teacher(self, user):
client = create_client(user) client = self.get_client(user)
query = ''' query = '''
query AssignmentWithSubmissions($id: ID!) { query AssignmentWithSubmissions($id: ID!) {
assignment(id: $id) { assignment(id: $id) {
@ -116,13 +116,13 @@ class SubmissionFeedbackTestCase(SkillboxTestCase):
def test_teacher_can_create_feedback(self): def test_teacher_can_create_feedback(self):
result = self._create_submission_feedback(self.teacher, False, 'Balalal', self.student_submission_id) result = self._create_submission_feedback(self.teacher, False, 'Balalal', self.student_submission_id)
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
self.assertIsNotNone( self.assertIsNotNone(
result.get('data').get('updateSubmissionFeedback').get('updatedSubmissionFeedback').get('id')) result.data.get('updateSubmissionFeedback').get('updatedSubmissionFeedback').get('id'))
def test_student_cannot_create_feedback(self): def test_student_cannot_create_feedback(self):
result = self._create_submission_feedback(self.student1, False, 'Balalal', self.student_submission_id) result = self._create_submission_feedback(self.student1, False, 'Balalal', self.student_submission_id)
self.assertIsNotNone(result.get('errors')) self.assertIsNotNone(result.errors)
def test_teacher_can_update_feedback(self): def test_teacher_can_update_feedback(self):
assignment = AssignmentFactory( assignment = AssignmentFactory(
@ -136,9 +136,9 @@ class SubmissionFeedbackTestCase(SkillboxTestCase):
result = self._create_submission_feedback(self.teacher, True, 'Some', submission_feedback_id) result = self._create_submission_feedback(self.teacher, True, 'Some', submission_feedback_id)
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
submission_feedback_response = result.get('data').get('updateSubmissionFeedback').get( submission_feedback_response = result.data.get('updateSubmissionFeedback').get(
'updatedSubmissionFeedback') 'updatedSubmissionFeedback')
self.assertTrue(submission_feedback_response.get('final')) self.assertTrue(submission_feedback_response.get('final'))
@ -156,19 +156,19 @@ class SubmissionFeedbackTestCase(SkillboxTestCase):
result = self._create_submission_feedback(self.teacher2, True, 'Some', submission_feedback_id) result = self._create_submission_feedback(self.teacher2, True, 'Some', submission_feedback_id)
self.assertIsNotNone(result.get('errors')) self.assertIsNotNone(result.errors)
def test_student_does_not_see_non_final_feedback(self): def test_student_does_not_see_non_final_feedback(self):
SubmissionFeedbackFactory(teacher=self.teacher, final=False, student_submission=self.student_submission) SubmissionFeedbackFactory(teacher=self.teacher, final=False, student_submission=self.student_submission)
result = self._fetch_assignment_student(self.student1) result = self._fetch_assignment_student(self.student1)
self.assertIsNone(result.get('data').get('submissionFeedback')) self.assertIsNone(result.data.get('submissionFeedback'))
def test_student_does_see_final_feedback(self): def test_student_does_see_final_feedback(self):
submission_feedback = SubmissionFeedbackFactory(teacher=self.teacher, final=True, submission_feedback = SubmissionFeedbackFactory(teacher=self.teacher, final=True,
student_submission=self.student_submission) student_submission=self.student_submission)
result = self._fetch_assignment_student(self.student1) result = self._fetch_assignment_student(self.student1)
self.assertEqual(result.get('data').get('assignment').get('submission').get('submissionFeedback') self.assertEqual(result.data.get('assignment').get('submission').get('submissionFeedback')
.get('text'), submission_feedback.text) .get('text'), submission_feedback.text)
def test_teacher_can_see_feedback_for_submission(self): def test_teacher_can_see_feedback_for_submission(self):
@ -178,7 +178,7 @@ class SubmissionFeedbackTestCase(SkillboxTestCase):
self.student_submission.save() self.student_submission.save()
result = self._fetch_assignment_teacher(self.teacher) result = self._fetch_assignment_teacher(self.teacher)
self.assertEqual(result.get('data').get('assignment').get('submissions')[0].get('submissionFeedback') self.assertEqual(result.data.get('assignment').get('submissions')[0].get('submissionFeedback')
.get('text'), submission_feedback.text) .get('text'), submission_feedback.text)
def test_rogue_teacher_cannot_see_feedback(self): def test_rogue_teacher_cannot_see_feedback(self):
@ -188,4 +188,4 @@ class SubmissionFeedbackTestCase(SkillboxTestCase):
self.student_submission.save() self.student_submission.save()
result = self._fetch_assignment_teacher(self.teacher2) result = self._fetch_assignment_teacher(self.teacher2)
self.assertIsNone(result.get('data').get('assignment').get('submissions')[0].get('submissionFeedback')) self.assertIsNone(result.data.get('assignment').get('submissions')[0].get('submissionFeedback'))

8
server/assignments/tests/test_read_only.py
View File

@ -32,7 +32,7 @@ class AssignmentReadOnlyTestCase(SkillboxTestCase):
} }
} }
result = self.get_client(self.student1).execute(UPDATE_ASSIGNMENT_MUTATION, variables=variables) result = self.get_client(self.student1).execute(UPDATE_ASSIGNMENT_MUTATION, variables=variables)
self.assertIsNotNone(result.get('errors')) self.assertIsNotNone(result.errors)
def test_share_assignment_fails(self): def test_share_assignment_fails(self):
variables = { variables = {
@ -46,7 +46,7 @@ class AssignmentReadOnlyTestCase(SkillboxTestCase):
} }
} }
result = self.get_client(self.student1).execute(UPDATE_ASSIGNMENT_MUTATION, variables=variables) result = self.get_client(self.student1).execute(UPDATE_ASSIGNMENT_MUTATION, variables=variables)
self.assertIsNotNone(result.get('errors')) self.assertIsNotNone(result.errors)
def test_edit_feedback_fails(self): def test_edit_feedback_fails(self):
student_submission = StudentSubmissionFactory(assignment=self.assignment, student=self.student1, student_submission = StudentSubmissionFactory(assignment=self.assignment, student=self.student1,
@ -62,7 +62,7 @@ class AssignmentReadOnlyTestCase(SkillboxTestCase):
} }
}) })
self.assertIsNotNone(result.get('errors')) self.assertIsNotNone(result.errors)
def test_share_feedback_fails(self): def test_share_feedback_fails(self):
@ -79,4 +79,4 @@ class AssignmentReadOnlyTestCase(SkillboxTestCase):
} }
}) })
self.assertIsNotNone(result.get('errors')) self.assertIsNotNone(result.errors)

2
server/basicknowledge/tests/test_instrument_types_query.py
View File

@ -26,6 +26,6 @@ class InstrumentTypesQueryTestCase(SkillboxTestCase):
InstrumentFactory(new_type=second_type) InstrumentFactory(new_type=second_type)
def test_instrument_types_empty_not_returned(self): def test_instrument_types_empty_not_returned(self):
result = self.get_client().get_result(INSTRUMENT_TYPES_QUERY) result = self.get_client().execute(INSTRUMENT_TYPES_QUERY)
self.assertIsNone(result.errors) self.assertIsNone(result.errors)
self.assertEqual(len(result.data['instrumentTypes']), 2) self.assertEqual(len(result.data['instrumentTypes']), 2)

4
server/books/tests/test_404.py
View File

@ -27,7 +27,7 @@ class ContentBlockTestCase(SkillboxTestCase):
result = self.client.execute(TOPIC_QUERY, variables={ result = self.client.execute(TOPIC_QUERY, variables={
"slug": slug "slug": slug
}) })
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
topic = result.get('data').get('topic') topic = result.data.get('topic')
self.assertEqual(topic.get('__typename'), 'NotFound') self.assertEqual(topic.get('__typename'), 'NotFound')
self.assertEqual(topic.get('reason'), 'Not Found') self.assertEqual(topic.get('reason'), 'Not Found')

4
server/books/tests/test_content_blocks.py
View File

@ -36,8 +36,8 @@ class ContentBlockTestCase(SkillboxTestCase):
result = self.client.execute(CONTENT_BLOCK_QUERY, variables={ result = self.client.execute(CONTENT_BLOCK_QUERY, variables={
"slug": self.slug "slug": self.slug
}) })
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
module = result.get('data').get('module') module = result.data.get('module')
content_block = module['chapters'][0]['contentBlocks'][0] content_block = module['chapters'][0]['contentBlocks'][0]
self.assertEqual(content_block['title'], 'Title') self.assertEqual(content_block['title'], 'Title')
self.assertIsNotNone(content_block['type']) self.assertIsNotNone(content_block['type'])

16
server/books/tests/test_own_content_blocks.py
View File

@ -45,18 +45,18 @@ class OwnContentTestCase(SkillboxTestCase):
} }
} }
""" """
result = self.client.execute(chapterQuery, variables={ result = self.get_client().execute(chapterQuery, variables={
"id": self.chapter_id "id": self.chapter_id
}) })
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
self.assertEqual(len(result.get('data').get('chapter').get('contentBlocks')), 1) self.assertEqual(len(result.data.get('chapter').get('contentBlocks')), 1)
custom_content_block = ContentBlock(title='own', slug='own', user_created=True, owner=self.user) custom_content_block = ContentBlock(title='own', slug='own', user_created=True, owner=self.user)
self.chapter.specific.add_child(instance=custom_content_block) self.chapter.specific.add_child(instance=custom_content_block)
result = self.client.execute(chapterQuery, variables={ result = self.client.execute(chapterQuery, variables={
"id": self.chapter_id "id": self.chapter_id
}) })
self.assertEqual(len(result.get('data').get('chapter').get('contentBlocks')), 2) self.assertEqual(len(result.data.get('chapter').get('contentBlocks')), 2)
for school_class in self.user.school_classes.all(): for school_class in self.user.school_classes.all():
custom_content_block.visible_for.add(school_class) custom_content_block.visible_for.add(school_class)
@ -64,7 +64,7 @@ class OwnContentTestCase(SkillboxTestCase):
result = self.client.execute(chapterQuery, variables={ result = self.client.execute(chapterQuery, variables={
"id": self.chapter_id "id": self.chapter_id
}) })
self.assertEqual(len(result.get('data').get('chapter').get('contentBlocks')), 2) self.assertEqual(len(result.data.get('chapter').get('contentBlocks')), 2)
def test_mutate_own_content_block(self): def test_mutate_own_content_block(self):
query = """ query = """
@ -76,7 +76,7 @@ class OwnContentTestCase(SkillboxTestCase):
} }
""" """
res = self.get_client().get_result(query, variables={'id': self.content_block_id}) res = self.get_client().execute(query, variables={'id': self.content_block_id})
self.assertIsNone(res.errors) self.assertIsNone(res.errors)
self.assertEqual(res.data['contentBlock']['title'], 'bla') self.assertEqual(res.data['contentBlock']['title'], 'bla')
@ -112,7 +112,7 @@ class OwnContentTestCase(SkillboxTestCase):
} }
} }
mutation_result = self.get_client().get_result(mutation, variables=variables) mutation_result = self.get_client().execute(mutation, variables=variables)
self.assertIsNone(mutation_result.errors) self.assertIsNone(mutation_result.errors)
content_block = mutation_result.data['mutateContentBlock']['contentBlock'] content_block = mutation_result.data['mutateContentBlock']['contentBlock']
self.assertEqual(content_block['title'], 'new title') self.assertEqual(content_block['title'], 'new title')
@ -137,7 +137,7 @@ class OwnContentTestCase(SkillboxTestCase):
} }
} }
} }
list_mutation_result = self.get_client().get_result(mutation, variables=other_variables) list_mutation_result = self.get_client().execute(mutation, variables=other_variables)
self.assertIsNone(list_mutation_result.errors) self.assertIsNone(list_mutation_result.errors)
content_block = list_mutation_result.data['mutateContentBlock']['contentBlock'] content_block = list_mutation_result.data['mutateContentBlock']['contentBlock']
self.assertEqual(content_block['title'], 'title for list content') self.assertEqual(content_block['title'], 'title for list content')

14
server/books/tests/test_snapshots.py
View File

@ -260,7 +260,7 @@ class CreateSnapshotTestCase(SkillboxTestCase):
} }
}) })
self.assertIsNone(result.errors) self.assertIsNone(result.errors)
snapshot_id = result['data']['createSnapshot']['snapshot']['id'] snapshot_id = result.data['createSnapshot']['snapshot']['id']
result = self.client.execute(APPLY_SNAPSHOT_MUTATION, variables={ result = self.client.execute(APPLY_SNAPSHOT_MUTATION, variables={
'input': { 'input': {
@ -274,7 +274,7 @@ class CreateSnapshotTestCase(SkillboxTestCase):
'slug': self.module.slug 'slug': self.module.slug
}) })
self.assertIsNone(result.errors) self.assertIsNone(result.errors)
module = result['data']['module'] module = result.data['module']
chapter1, chapter2 = module['chapters'] chapter1, chapter2 = module['chapters']
visible, hidden, custom, custom_hidden = chapter1['contentBlocks'] visible, hidden, custom, custom_hidden = chapter1['contentBlocks']
self.assertTrue(self.skillbox_class.name not in [sc['name'] for sc in visible['hiddenFor']]) self.assertTrue(self.skillbox_class.name not in [sc['name'] for sc in visible['hiddenFor']])
@ -287,7 +287,7 @@ class CreateSnapshotTestCase(SkillboxTestCase):
'slug': self.module.slug 'slug': self.module.slug
}) })
self.assertIsNone(result.errors) self.assertIsNone(result.errors)
chapter = result['data']['module']['chapters'][0] chapter = result.data['module']['chapters'][0]
self.assertEqual(len(chapter['contentBlocks']), 4) self.assertEqual(len(chapter['contentBlocks']), 4)
result = self.graphene_client.execute(CREATE_SNAPSHOT_MUTATION, variables={ result = self.graphene_client.execute(CREATE_SNAPSHOT_MUTATION, variables={
@ -297,7 +297,7 @@ class CreateSnapshotTestCase(SkillboxTestCase):
} }
}) })
self.assertIsNone(result.errors) self.assertIsNone(result.errors)
snapshot_id = result['data']['createSnapshot']['snapshot']['id'] snapshot_id = result.data['createSnapshot']['snapshot']['id']
teacher2 = User.objects.get(username='teacher2') teacher2 = User.objects.get(username='teacher2')
teacher2_client = self.get_client(user=teacher2) teacher2_client = self.get_client(user=teacher2)
@ -313,7 +313,7 @@ class CreateSnapshotTestCase(SkillboxTestCase):
'slug': self.module.slug 'slug': self.module.slug
}) })
self.assertIsNone(result.errors) self.assertIsNone(result.errors)
chapter = result['data']['module']['chapters'][0] chapter = result.data['module']['chapters'][0]
self.assertEqual(len(chapter['contentBlocks']), 4) self.assertEqual(len(chapter['contentBlocks']), 4)
def test_snapshot_chapter_visibility_after_apply(self): def test_snapshot_chapter_visibility_after_apply(self):
@ -335,7 +335,7 @@ class CreateSnapshotTestCase(SkillboxTestCase):
'slug': self.module.slug 'slug': self.module.slug
}) })
self.assertIsNone(a_result.errors) self.assertIsNone(a_result.errors)
a_chapter = a_result['data']['module']['chapters'][0] a_chapter = a_result.data['module']['chapters'][0]
self.assertEqual(self.second_class_name in map(lambda x: x['name'], a_chapter['titleHiddenFor']), hidden) self.assertEqual(self.second_class_name in map(lambda x: x['name'], a_chapter['titleHiddenFor']), hidden)
self.assertEqual(self.second_class_name in map(lambda x: x['name'], a_chapter['descriptionHiddenFor']), self.assertEqual(self.second_class_name in map(lambda x: x['name'], a_chapter['descriptionHiddenFor']),
hidden) hidden)
@ -349,7 +349,7 @@ class CreateSnapshotTestCase(SkillboxTestCase):
} }
}) })
self.assertIsNone(result.errors) self.assertIsNone(result.errors)
snapshot = result['data']['createSnapshot']['snapshot'] snapshot = result.data['createSnapshot']['snapshot']
snapshot_id = snapshot['id'] snapshot_id = snapshot['id']
chapter = snapshot['chapters'][0] chapter = snapshot['chapters'][0]
self.assertEqual(chapter['titleHidden'], False) self.assertEqual(chapter['titleHidden'], False)

4
server/portfolio/tests/test_project_mutations.py
View File

@ -87,7 +87,7 @@ mutation UpdateProjectMutation($input: UpdateProjectInput!){
'title': 'BAD! THIS IS BAD!' 'title': 'BAD! THIS IS BAD!'
} }
} }
result = self.get_client(self.student2).get_result(mutation, variables={ result = self.get_client(self.student2).execute(mutation, variables={
'input': input 'input': input
}) })
self.assertIsNotNone(result.errors) self.assertIsNotNone(result.errors)
@ -115,7 +115,7 @@ mutation UpdateProjectMutation($input: UpdateProjectInput!){
'title': 'Good! THIS IS good!' 'title': 'Good! THIS IS good!'
} }
} }
result = self.get_client(self.student).get_result(mutation, variables={ result = self.get_client(self.student).execute(mutation, variables={
'input': input 'input': input
}) })
self.assertIsNone(result.errors) self.assertIsNone(result.errors)

24
server/portfolio/tests/test_project_query.py
View File

@ -17,7 +17,7 @@ query ProjectQuery($id: ID!) {
class ProjectQueryTestCase(SkillboxTestCase): class ProjectQueryTestCase(SkillboxTestCase):
def _test_direct_project_access(self, user: User, should_have_access: bool): def _test_direct_project_access(self, user: User, should_have_access: bool):
result = self.get_client(user).get_result(project_query, variables={ result = self.get_client(user).execute(project_query, variables={
'id': self.project1.graphql_id 'id': self.project1.graphql_id
}) })
self.assertIsNone(result.errors) self.assertIsNone(result.errors)
@ -57,22 +57,22 @@ class ProjectQueryTestCase(SkillboxTestCase):
result = self.get_client(self.student1).execute(self.query) result = self.get_client(self.student1).execute(self.query)
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
self.assertEqual(result.get('data').get('projects')[0].get('title'), self.project1.title) self.assertEqual(result.data.get('projects')[0].get('title'), self.project1.title)
def test_should_not_see_other_projects(self): def test_should_not_see_other_projects(self):
self.assertEqual(Project.objects.count(), 1) self.assertEqual(Project.objects.count(), 1)
result = self.get_client(self.student2).execute(self.query) result = self.get_client(self.student2).execute(self.query)
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
self.assertEqual(len(result.get('data').get('projects')), 0) self.assertEqual(len(result.data.get('projects')), 0)
def test_teacher_should_not_see_unfinished_projects(self): def test_teacher_should_not_see_unfinished_projects(self):
result = self.get_client().execute(self.query) result = self.get_client().execute(self.query)
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
self.assertEqual(len(result.get('data').get('projects')), 0) self.assertEqual(len(result.data.get('projects')), 0)
def test_teacher_should_only_see_finished_projects(self): def test_teacher_should_only_see_finished_projects(self):
self.project1.final = True self.project1.final = True
@ -81,8 +81,8 @@ class ProjectQueryTestCase(SkillboxTestCase):
result = self.get_client().execute(self.query) result = self.get_client().execute(self.query)
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
self.assertEqual(result.get('data').get('projects')[0].get('title'), self.assertEqual(result.data.get('projects')[0].get('title'),
self.project1.title) self.project1.title)
def test_other_teacher_should_not_see_projects(self): def test_other_teacher_should_not_see_projects(self):
@ -92,8 +92,8 @@ class ProjectQueryTestCase(SkillboxTestCase):
result = self.get_client(self.teacher2).execute(self.query) result = self.get_client(self.teacher2).execute(self.query)
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
self.assertEqual(len(result.get('data').get('projects')), 0) self.assertEqual(len(result.data.get('projects')), 0)
def test_direct_project_access(self): def test_direct_project_access(self):
# student can access own project directly # student can access own project directly
@ -128,7 +128,7 @@ query ProjectQuery($id: ID!) {
} }
} }
""" """
result = self.get_client(self.student1).get_result(query, variables={ result = self.get_client(self.student1).execute(query, variables={
'id': self.project1.graphql_id 'id': self.project1.graphql_id
}) })
self.assertEqual(result.data['project']['student']['email'], self.student1.email) self.assertEqual(result.data['project']['student']['email'], self.student1.email)

11
server/rooms/tests/test_comments.py
View File

@ -33,7 +33,7 @@ mutation AddComment($input: AddCommentInput!) {
'comment': self.text 'comment': self.text
} }
}) })
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
self.assertEqual(room_entry.comments.count(), 1) self.assertEqual(room_entry.comments.count(), 1)
comment = room_entry.comments.first() comment = room_entry.comments.first()
self.assertEqual(comment.text, self.text) self.assertEqual(comment.text, self.text)
@ -53,8 +53,8 @@ query CommentsQuery($id: ID!) {
} }
""" """
result = self.get_client().execute(query, variables={"id": self.room_entry_id}) result = self.get_client().execute(query, variables={"id": self.room_entry_id})
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
comment_node = result.get('data').get('roomEntry').get('comments')[0] comment_node = result.data.get('roomEntry').get('comments')[0]
self.assertEqual(comment_node['text'], self.text) self.assertEqual(comment_node['text'], self.text)
def test_get_comment_for_other_user(self): def test_get_comment_for_other_user(self):
@ -70,6 +70,5 @@ query CommentsQuery($id: ID!) {
""" """
result = self.get_client(self.student_second_class).execute(query, variables={"id": self.room_entry_id}) result = self.get_client(self.student_second_class).execute(query, variables={"id": self.room_entry_id})
gql_result = GQLResult(result) self.assertIsNone(result.errors)
self.assertIsNone(gql_result.errors) self.assertIsNone(result.data.get('roomEntry'))
self.assertIsNone(gql_result.data.get('roomEntry'))

5
server/rooms/tests/test_new_room_mutation.py
View File

@ -55,7 +55,7 @@ class NewRoomMutationTestCase(SkillboxTestCase):
self.assertEqual(Room.objects.count(), 0) self.assertEqual(Room.objects.count(), 0)
title = 'some title' title = 'some title'
appearance = 'blue' appearance = 'blue'
res = self.get_client().execute(self.mutation, variables={ result = self.get_client().execute(self.mutation, variables={
'input': { 'input': {
'room': { 'room': {
'title': title, 'title': title,
@ -64,7 +64,6 @@ class NewRoomMutationTestCase(SkillboxTestCase):
} }
} }
}) })
result = GQLResult(res)
self.assertIsNone(result.errors) self.assertIsNone(result.errors)
room = GQLRoom(result.data.get('addRoom').get('room')) room = GQLRoom(result.data.get('addRoom').get('room'))
self.assertEqual(room.title, title) self.assertEqual(room.title, title)
@ -75,7 +74,7 @@ class NewRoomMutationTestCase(SkillboxTestCase):
def test_create_new_room_for_other_school_class(self): def test_create_new_room_for_other_school_class(self):
self.assertEqual(Room.objects.count(), 0) self.assertEqual(Room.objects.count(), 0)
result = self.get_client(self.teacher2).get_result(self.mutation, variables={ result = self.get_client(self.teacher2).execute(self.mutation, variables={
'input': { 'input': {
'room': { 'room': {
'title': 'BIG NO NO!', 'title': 'BIG NO NO!',

2
server/rooms/tests/test_room_entry_mutations.py
View File

@ -175,7 +175,7 @@ mutation AddRoomEntry($input: AddRoomEntryInput!){
'room': self.room.graphql_id 'room': self.room.graphql_id
} }
result = self.get_client(self.yet_another_user).get_result(mutation, variables={ result = self.get_client(self.yet_another_user).execute(mutation, variables={
'input': { 'input': {
'roomEntry': room_entry 'roomEntry': room_entry
} }

12
server/rooms/tests/test_room_visibility_mutation.py
View File

@ -30,41 +30,37 @@ query RoomQuery ($slug: String!) {
""" """
def test_restricted_query(self): def test_restricted_query(self):
res = self.get_client().execute(self.query, variables={ result = self.get_client().execute(self.query, variables={
'slug': self.room.slug 'slug': self.room.slug
}) })
result = GQLResult(res)
self.assertIsNone(result.errors) self.assertIsNone(result.errors)
self.assertFalse(result.data.get('room').get('restricted')) self.assertFalse(result.data.get('room').get('restricted'))
def test_successful_mutation(self): def test_successful_mutation(self):
res = self.get_client().execute(self.mutation, variables={ result = self.get_client().execute(self.mutation, variables={
'input': { 'input': {
'id': self.room_id, 'id': self.room_id,
'restricted': True 'restricted': True
} }
}) })
result = GQLResult(res)
self.assertIsNone(result.errors) self.assertIsNone(result.errors)
self.assertEqual(result.data.get('updateRoomVisibility').get('room').get('restricted'), True) self.assertEqual(result.data.get('updateRoomVisibility').get('room').get('restricted'), True)
def test_permission_denied(self): def test_permission_denied(self):
res = self.get_client(self.student1).execute(self.mutation, variables={ result = self.get_client(self.student1).execute(self.mutation, variables={
'input': { 'input': {
'id': self.room_id, 'id': self.room_id,
'restricted': True 'restricted': True
} }
}) })
result = GQLResult(res)
self.assertIsNotNone(result.errors) self.assertIsNotNone(result.errors)
res = self.get_client(self.teacher2).execute(self.mutation, variables={ result = self.get_client(self.teacher2).execute(self.mutation, variables={
'input': { 'input': {
'id': self.room_id, 'id': self.room_id,
'restricted': True 'restricted': True
} }
}) })
result = GQLResult(res)
self.assertIsNotNone(result.errors) self.assertIsNotNone(result.errors)

3
server/rooms/tests/test_room_visibility_query.py
View File

@ -34,10 +34,9 @@ query RoomQuery ($slug: String!) {
""" """
def _test_room(self, user, length, restricted=True): def _test_room(self, user, length, restricted=True):
res = self.get_client(user).execute(self.query, variables={ result = self.get_client(user).execute(self.query, variables={
'slug': self.room.slug 'slug': self.room.slug
}) })
result = GQLResult(res)
self.assertIsNone(result.errors) self.assertIsNone(result.errors)
room = GQLRoom(result.data.get('room')) room = GQLRoom(result.data.get('room'))
self.assertEqual(room.restricted, restricted) self.assertEqual(room.restricted, restricted)

18
server/users/tests/test_school_classes.py
View File

@ -62,13 +62,13 @@ class ModifySchoolClassTest(SkillboxTestCase):
'name': class_name 'name': class_name
} }
}) })
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
school_class = get_object(SchoolClass, id) school_class = get_object(SchoolClass, id)
self.assertEqual(school_class.name, class_name) self.assertEqual(school_class.name, class_name)
def test_update_school_class_not_in_class_fails(self): def test_update_school_class_not_in_class_fails(self):
client = Client(schema=schema) client = self.get_client()
teacher = TeacherFactory(username='conan') teacher = TeacherFactory(username='conan')
context = Context(user=teacher) context = Context(user=teacher)
school_class = SchoolClass.objects.get(name='skillbox') school_class = SchoolClass.objects.get(name='skillbox')
@ -81,7 +81,7 @@ class ModifySchoolClassTest(SkillboxTestCase):
} }
} }
result = client.execute(UPDATE_SCHOOL_CLASS_MUTATION, variables=variables, context=context) result = client.execute(UPDATE_SCHOOL_CLASS_MUTATION, variables=variables, context=context)
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
def test_update_school_class_fail(self): def test_update_school_class_fail(self):
class_name = 'Nanana' class_name = 'Nanana'
@ -96,7 +96,7 @@ class ModifySchoolClassTest(SkillboxTestCase):
'name': class_name 'name': class_name
} }
}) })
self.assertIsNotNone(result.get('errors')) self.assertIsNotNone(result.errors)
def test_create_school_class(self): def test_create_school_class(self):
self.assertEqual(SchoolClass.objects.count(), 2) self.assertEqual(SchoolClass.objects.count(), 2)
@ -107,8 +107,8 @@ class ModifySchoolClassTest(SkillboxTestCase):
'name': class_name 'name': class_name
} }
}) })
self.assertIsNone(query_result.get('errors')) self.assertIsNone(query_result.errors)
result = query_result.get('data').get('createSchoolClass').get('result') result = query_result.data.get('createSchoolClass').get('result')
self.assertEqual(result.get('__typename'), 'SchoolClassNode') self.assertEqual(result.get('__typename'), 'SchoolClassNode')
id = result.get('id') id = result.get('id')
self.assertEqual(SchoolClass.objects.count(), 3) self.assertEqual(SchoolClass.objects.count(), 3)
@ -129,8 +129,8 @@ class ModifySchoolClassTest(SkillboxTestCase):
'name': class_name 'name': class_name
} }
}) })
self.assertIsNone(query_result.get('errors')) self.assertIsNone(query_result.errors)
result = query_result.get('data').get('createSchoolClass').get('result') result = query_result.data.get('createSchoolClass').get('result')
self.assertEqual(result.get('__typename'), 'DuplicateName') self.assertEqual(result.get('__typename'), 'DuplicateName')
reason = result.get('reason') reason = result.get('reason')
self.assertEqual(reason, 'Dieser Name wird bereits verwendet.') self.assertEqual(reason, 'Dieser Name wird bereits verwendet.')
@ -144,4 +144,4 @@ class ModifySchoolClassTest(SkillboxTestCase):
'name': 'No School' 'name': 'No School'
} }
}) })
self.assertIsNotNone(result.get('errors')) self.assertIsNotNone(result.errors)

28
server/users/tests/test_usersettings.py
View File

@ -50,17 +50,17 @@ class UserSettingTests(SkillboxTestCase):
def test_selects_first_class_on_first_call(self): def test_selects_first_class_on_first_call(self):
result = self.make_query() result = self.make_query()
first_class = self.user.school_classes.first() first_class = self.user.school_classes.first()
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
self.assertEqual(result.get('data').get('me').get('selectedClass').get('name'), first_class.name) self.assertEqual(result.data.get('me').get('selectedClass').get('name'), first_class.name)
self.assertFalse(result.get('data').get('me').get('selectedClass').get('readOnly')) self.assertFalse(result.data.get('me').get('selectedClass').get('readOnly'))
def test_returns_selected_class(self): def test_returns_selected_class(self):
selected_class = self.user.school_classes.all()[1] selected_class = self.user.school_classes.all()[1]
setting = UserSetting.objects.create(user=self.user, selected_class=selected_class) setting = UserSetting.objects.create(user=self.user, selected_class=selected_class)
setting.save() setting.save()
result = self.make_query() result = self.make_query()
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
self.assertEqual(result.get('data').get('me').get('selectedClass').get('name'), self.assertEqual(result.data.get('me').get('selectedClass').get('name'),
selected_class.name) selected_class.name)
def test_user_can_select_class(self): def test_user_can_select_class(self):
@ -70,19 +70,19 @@ class UserSettingTests(SkillboxTestCase):
selected_class = self.user.school_classes.all()[1] selected_class = self.user.school_classes.all()[1]
mutation_result = self.make_mutation(selected_class.pk) mutation_result = self.make_mutation(selected_class.pk)
self.assertIsNone(mutation_result.get('errors')) self.assertIsNone(mutation_result.errors)
query_result = self.make_query() query_result = self.make_query()
self.assertIsNone(query_result.get('errors')) self.assertIsNone(query_result.errors)
self.assertEqual(query_result.get('data').get('me').get('selectedClass').get('name'), self.assertEqual(query_result.data.get('me').get('selectedClass').get('name'),
selected_class.name) selected_class.name)
def test_user_can_select_class_even_no_settings_exist(self): def test_user_can_select_class_even_no_settings_exist(self):
selected_class = self.user.school_classes.all()[1] selected_class = self.user.school_classes.all()[1]
mutation_result = self.make_mutation(selected_class.pk) mutation_result = self.make_mutation(selected_class.pk)
self.assertIsNone(mutation_result.get('errors')) self.assertIsNone(mutation_result.errors)
query_result = self.make_query() query_result = self.make_query()
self.assertIsNone(query_result.get('errors')) self.assertIsNone(query_result.errors)
self.assertEqual(query_result.get('data').get('me').get('selectedClass').get('name'), self.assertEqual(query_result.data.get('me').get('selectedClass').get('name'),
selected_class.name) selected_class.name)
@ -93,7 +93,7 @@ class UserSettingTests(SkillboxTestCase):
setting.save() setting.save()
mutation_result = self.make_mutation(self.class3.pk) mutation_result = self.make_mutation(self.class3.pk)
self.assertIsNotNone(mutation_result.get('errors')) self.assertIsNotNone(mutation_result.errors)
def test_inactive_class_as_selected_class(self): def test_inactive_class_as_selected_class(self):
selected_class = self.class2 selected_class = self.class2
@ -106,6 +106,6 @@ class UserSettingTests(SkillboxTestCase):
setting.save() setting.save()
result = self.make_query() result = self.make_query()
self.assertIsNone(result.get('errors')) self.assertIsNone(result.errors)
self.assertTrue(result.get('data').get('me').get('selectedClass').get('readOnly')) self.assertTrue(result.data.get('me').get('selectedClass').get('readOnly'))