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

Clean up imports, reformat code 

Remove unnecessary method
This commit is contained in:
Ramon Wenger 2023-03-13 09:57:33 +01:00
parent ba1de78951
commit cc2b4e9809
6 changed files with 194 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -10,51 +10,54 @@
from graphql_relay import to_global_id from graphql_relay import to_global_id
from api.test_utils import create_client, DefaultUserTestCase from api.test_utils import create_client
from assignments.models import Assignment, StudentSubmission
from core.tests.base_test import SkillboxTestCase from core.tests.base_test import SkillboxTestCase
from users.factories import SchoolClassFactory from users.factories import SchoolClassFactory
from users.models import SchoolClassMember from users.models import SchoolClassMember
from .queries.mutations import UPDATE_SUBMISSION_FEEDBACK_MUTATION from .queries.mutations import UPDATE_SUBMISSION_FEEDBACK_MUTATION
from ..factories import AssignmentFactory, StudentSubmissionFactory, SubmissionFeedbackFactory from ..factories import (
AssignmentFactory,
StudentSubmissionFactory,
SubmissionFeedbackFactory,
)
class SubmissionFeedbackTestCase(SkillboxTestCase): class SubmissionFeedbackTestCase(SkillboxTestCase):
def setUp(self): def setUp(self):
self.createDefault() self.createDefault()
self.assignment = AssignmentFactory( self.assignment = AssignmentFactory(owner=self.teacher)
owner=self.teacher self.assignment_id = to_global_id("AssignmentNode", self.assignment.pk)
)
self.assignment_id = to_global_id('AssignmentNode', self.assignment.pk)
self.student_submission = StudentSubmissionFactory(assignment=self.assignment, student=self.student1, self.student_submission = StudentSubmissionFactory(
final=False) assignment=self.assignment, student=self.student1, final=False
self.student_submission_id = to_global_id('StudentSubmissionNode', self.student_submission.pk) )
self.student_submission_id = to_global_id(
"StudentSubmissionNode", self.student_submission.pk
)
school_class = SchoolClassFactory() school_class = SchoolClassFactory()
for user in [self.student1, self.teacher]: for user in [self.student1, self.teacher]:
SchoolClassMember.objects.create( SchoolClassMember.objects.create(user=user, school_class=school_class)
user=user,
school_class=school_class
)
user.set_selected_class(school_class) user.set_selected_class(school_class)
def _create_submission_feedback(self, user, final, text, student_submission_id): def _create_submission_feedback(self, user, final, text, student_submission_id):
return self.get_client(user).execute(UPDATE_SUBMISSION_FEEDBACK_MUTATION, variables={ return self.get_client(user).execute(
'input': { UPDATE_SUBMISSION_FEEDBACK_MUTATION,
"submissionFeedback": { variables={
"studentSubmission": student_submission_id, "input": {
"text": text, "submissionFeedback": {
"final": final "studentSubmission": student_submission_id,
"text": text,
"final": final,
}
} }
} },
}) )
def _fetch_assignment_student(self, user): def _fetch_assignment_student(self, user):
client = self.get_client(user) client = self.get_client(user)
query = ''' query = """
query AssignmentWithSubmissions($id: ID!) { query AssignmentWithSubmissions($id: ID!) {
assignment(id: $id) { assignment(id: $id) {
title title
@ -68,14 +71,12 @@ class SubmissionFeedbackTestCase(SkillboxTestCase):
} }
} }
} }
''' """
return client.execute(query, variables={ return client.execute(query, variables={"id": self.assignment_id})
'id': self.assignment_id
})
def _fetch_assignment_teacher(self, user): def _fetch_assignment_teacher(self, user):
client = self.get_client(user) client = self.get_client(user)
query = ''' query = """
query AssignmentWithSubmissions($id: ID!) { query AssignmentWithSubmissions($id: ID!) {
assignment(id: $id) { assignment(id: $id) {
title title
@ -89,14 +90,12 @@ class SubmissionFeedbackTestCase(SkillboxTestCase):
} }
} }
} }
''' """
return client.execute(query, variables={ return client.execute(query, variables={"id": self.assignment_id})
'id': self.assignment_id
})
def _fetch_submission_teacher(self, user): def _fetch_submission_teacher(self, user):
client = self.get_client(user) client = self.get_client(user)
query = ''' query = """
query StudentSubmission($id: ID!) { query StudentSubmission($id: ID!) {
studentSubmission(id: $id) { studentSubmission(id: $id) {
id id
@ -107,14 +106,12 @@ class SubmissionFeedbackTestCase(SkillboxTestCase):
} }
} }
} }
''' """
return client.execute(query, variables={ return client.execute(query, variables={"id": self.student_submission_id})
'id': self.student_submission_id
})
def _fetch_submission_feedback(self, user): def _fetch_submission_feedback(self, user):
client = create_client(user) client = create_client(user)
query = ''' query = """
query AssignmentWithSubmissions($id: ID!) { query AssignmentWithSubmissions($id: ID!) {
assignment(id: $id) { assignment(id: $id) {
title title
@ -128,96 +125,136 @@ class SubmissionFeedbackTestCase(SkillboxTestCase):
} }
} }
} }
''' """
return client.execute(query, variables={ return client.execute(query, variables={"id": self.assignment_id})
'id': self.assignment_id
})
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.errors) self.assertIsNone(result.errors)
self.assertIsNotNone( self.assertIsNotNone(
result.data.get('updateSubmissionFeedback').get('updatedSubmissionFeedback').get('id')) result.data.get("updateSubmissionFeedback")
.get("updatedSubmissionFeedback")
def test_student_cannot_create_feedback(self): .get("id")
result = self._create_submission_feedback(self.student1, False, 'Balalal', self.student_submission_id)
self.assertIsNotNone(result.errors)
self.assertEqual(len(result.errors), 1)
self.assertEqual(result.errors[0].get('message'), 'Missing permissions')
def test_teacher_can_update_feedback(self):
assignment = AssignmentFactory(
owner=self.teacher
) )
student_submission = StudentSubmissionFactory(assignment=assignment, student=self.student1, final=False) def test_student_cannot_create_feedback(self):
submission_feedback = SubmissionFeedbackFactory(teacher=self.teacher, final=False, result = self._create_submission_feedback(
student_submission=student_submission) self.student1, False, "Balalal", self.student_submission_id
submission_feedback_id = to_global_id('SubmissionFeedback', submission_feedback.pk) )
self.assertIsNotNone(result.errors)
self.assertEqual(len(result.errors), 1)
self.assertEqual(result.errors[0].get("message"), "Missing permissions")
result = self._create_submission_feedback(self.teacher, True, 'Some', submission_feedback_id) def test_teacher_can_update_feedback(self):
assignment = AssignmentFactory(owner=self.teacher)
student_submission = StudentSubmissionFactory(
assignment=assignment, student=self.student1, final=False
)
submission_feedback = SubmissionFeedbackFactory(
teacher=self.teacher, final=False, student_submission=student_submission
)
submission_feedback_id = to_global_id(
"SubmissionFeedback", submission_feedback.pk
)
result = self._create_submission_feedback(
self.teacher, True, "Some", submission_feedback_id
)
self.assertIsNone(result.errors) self.assertIsNone(result.errors)
submission_feedback_response = result.data.get('updateSubmissionFeedback').get( submission_feedback_response = result.data.get("updateSubmissionFeedback").get(
'updatedSubmissionFeedback') "updatedSubmissionFeedback"
self.assertTrue(submission_feedback_response.get('final'))
self.assertEqual(submission_feedback_response.get('text'), 'Some')
def test_external_teacher_cannot_update_feedback(self):
assignment = AssignmentFactory(
owner=self.teacher
) )
student_submission = StudentSubmissionFactory(assignment=assignment, student=self.student1, final=False) self.assertTrue(submission_feedback_response.get("final"))
submission_feedback = SubmissionFeedbackFactory(teacher=self.teacher, final=False, self.assertEqual(submission_feedback_response.get("text"), "Some")
student_submission=student_submission)
submission_feedback_id = to_global_id('SubmissionFeedback', submission_feedback.pk)
result = self._create_submission_feedback(self.teacher2, True, 'Some', submission_feedback_id) def test_external_teacher_cannot_update_feedback(self):
assignment = AssignmentFactory(owner=self.teacher)
student_submission = StudentSubmissionFactory(
assignment=assignment, student=self.student1, final=False
)
submission_feedback = SubmissionFeedbackFactory(
teacher=self.teacher, final=False, student_submission=student_submission
)
submission_feedback_id = to_global_id(
"SubmissionFeedback", submission_feedback.pk
)
result = self._create_submission_feedback(
self.teacher2, True, "Some", submission_feedback_id
)
self.assertIsNotNone(result.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.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(
student_submission=self.student_submission) teacher=self.teacher, final=True, student_submission=self.student_submission
)
result = self._fetch_assignment_student(self.student1) result = self._fetch_assignment_student(self.student1)
self.assertEqual(result.data.get('assignment').get('submission').get('submissionFeedback') self.assertEqual(
.get('text'), submission_feedback.text) result.data.get("assignment")
.get("submission")
.get("submissionFeedback")
.get("text"),
submission_feedback.text,
)
def test_teacher_can_see_feedback_for_submission(self): def test_teacher_can_see_feedback_for_submission(self):
submission_feedback = SubmissionFeedbackFactory(teacher=self.teacher, final=False, submission_feedback = SubmissionFeedbackFactory(
student_submission=self.student_submission) teacher=self.teacher,
final=False,
student_submission=self.student_submission,
)
self.student_submission.final = True self.student_submission.final = True
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.data.get('assignment').get('submissions')[0].get('submissionFeedback') self.assertEqual(
.get('text'), submission_feedback.text) result.data.get("assignment")
.get("submissions")[0]
.get("submissionFeedback")
.get("text"),
submission_feedback.text,
)
def test_external_teacher_cannot_see_assignment_with_feedback(self): def test_external_teacher_cannot_see_assignment_with_feedback(self):
SubmissionFeedbackFactory(teacher=self.teacher, final=False, SubmissionFeedbackFactory(
student_submission=self.student_submission) teacher=self.teacher,
final=False,
student_submission=self.student_submission,
)
self.student_submission.final = True self.student_submission.final = True
self.student_submission.save() self.student_submission.save()
result = self._fetch_assignment_teacher(self.teacher2) result = self._fetch_assignment_teacher(self.teacher2)
self.assertEqual(result.data.get('assignment').get('submissions'), []) self.assertEqual(result.data.get("assignment").get("submissions"), [])
def test_external_teacher_cannot_see_feedback(self): def test_external_teacher_cannot_see_feedback(self):
SubmissionFeedbackFactory(teacher=self.teacher, final=False, SubmissionFeedbackFactory(
student_submission=self.student_submission) teacher=self.teacher,
final=False,
student_submission=self.student_submission,
)
self.student_submission.final = True self.student_submission.final = True
self.student_submission.save() self.student_submission.save()
result = self._fetch_submission_teacher(self.teacher2) result = self._fetch_submission_teacher(self.teacher2)
self.assertIsNone(result.errors) self.assertIsNone(result.errors)
self.assertIsNone(result.data.get('studentSubmission')) self.assertIsNone(result.data.get("studentSubmission"))

45
server/assignments/tests/test_myassignments.py
View File

@ -1,35 +1,23 @@
from django.conf import settings
import json
from django.test import TestCase, RequestFactory
from graphene.test import Client
from api import schema
from api.schema import schema
from api.test_utils import DefaultUserTestCase, create_client from api.test_utils import DefaultUserTestCase, create_client
from assignments.factories import AssignmentFactory, StudentSubmissionFactory from assignments.factories import AssignmentFactory, StudentSubmissionFactory
from assignments.models import Assignment
from books.factories import ModuleFactory
from books.models import ContentBlock, Chapter
from core.factories import UserFactory
from users.models import User
from users.services import create_users
class MyAssignmentsTest(DefaultUserTestCase): class MyAssignmentsTest(DefaultUserTestCase):
def setUp(self): def setUp(self):
super(MyAssignmentsTest, self).setUp() super(MyAssignmentsTest, self).setUp()
self.assignment = AssignmentFactory( self.assignment = AssignmentFactory(owner=self.teacher)
owner=self.teacher
)
self.submission1 = StudentSubmissionFactory(student=self.student1, assignment=self.assignment) self.submission1 = StudentSubmissionFactory(
self.submission2 = StudentSubmissionFactory(student=self.student2, assignment=self.assignment) student=self.student1, assignment=self.assignment
)
self.submission2 = StudentSubmissionFactory(
student=self.student2, assignment=self.assignment
)
self.client = create_client(self.student1) self.client = create_client(self.student1)
def query_my_assignments(self): def query_my_assignments(self):
query = ''' query = """
query MyActivityQuery { query MyActivityQuery {
myActivity { myActivity {
edges { edges {
@ -138,20 +126,27 @@ class MyAssignmentsTest(DefaultUserTestCase):
} }
} }
''' """
result = self.client.execute(query) result = self.client.execute(query)
self.assertIsNone(result.get('errors')) self.assertIsNone(result.get("errors"))
return result return result
@staticmethod @staticmethod
def get_content(result): def get_content(result):
return result.get('data').get('myActivity').get('edges') return result.get("data").get("myActivity").get("edges")
def test_my_assignment_query(self): def test_my_assignment_query(self):
result = self.query_my_assignments() result = self.query_my_assignments()
contents = self.get_content(result) contents = self.get_content(result)
self.assertEqual(len(contents), 1) self.assertEqual(len(contents), 1)
self.assertEquals(contents[0].get('node').get('mySubmissions').get('edges')[0].get('node').get('text'), self.submission1.text) self.assertEquals(
contents[0]
.get("node")
.get("mySubmissions")
.get("edges")[0]
.get("node")
.get("text"),
self.submission1.text,
)

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

@ -3,9 +3,11 @@ from datetime import timedelta, date
from graphql_relay import to_global_id from graphql_relay import to_global_id
from assignments.factories import AssignmentFactory, StudentSubmissionFactory from assignments.factories import AssignmentFactory, StudentSubmissionFactory
from assignments.tests.queries.mutations import UPDATE_ASSIGNMENT_MUTATION, UPDATE_SUBMISSION_FEEDBACK_MUTATION from assignments.tests.queries.mutations import (
UPDATE_ASSIGNMENT_MUTATION,
UPDATE_SUBMISSION_FEEDBACK_MUTATION,
)
from core.tests.base_test import SkillboxTestCase from core.tests.base_test import SkillboxTestCase
from users.models import User
class AssignmentReadOnlyTestCase(SkillboxTestCase): class AssignmentReadOnlyTestCase(SkillboxTestCase):
@ -18,7 +20,7 @@ class AssignmentReadOnlyTestCase(SkillboxTestCase):
self.teacher.license_expiry_date = yesterday self.teacher.license_expiry_date = yesterday
self.teacher.save() self.teacher.save()
self.assignment = AssignmentFactory() self.assignment = AssignmentFactory()
self.assignment_id = to_global_id('AssignmentNode', self.assignment.id) self.assignment_id = to_global_id("AssignmentNode", self.assignment.id)
def test_edit_assignment_fails(self): def test_edit_assignment_fails(self):
variables = { variables = {
@ -27,11 +29,13 @@ class AssignmentReadOnlyTestCase(SkillboxTestCase):
"answer": "bla", "answer": "bla",
"document": "", "document": "",
"final": False, "final": False,
"id": self.assignment_id "id": self.assignment_id,
} }
} }
} }
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.errors) self.assertIsNotNone(result.errors)
def test_share_assignment_fails(self): def test_share_assignment_fails(self):
@ -41,42 +45,55 @@ class AssignmentReadOnlyTestCase(SkillboxTestCase):
"answer": "bla", "answer": "bla",
"document": "", "document": "",
"final": True, "final": True,
"id": self.assignment_id "id": self.assignment_id,
} }
} }
} }
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.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(
final=True) assignment=self.assignment, student=self.student1, final=True
student_submission_id = to_global_id('StudentSubmissionNode', student_submission.id) )
result = self.get_client(self.teacher).execute(UPDATE_SUBMISSION_FEEDBACK_MUTATION, variables={ student_submission_id = to_global_id(
'input': { "StudentSubmissionNode", student_submission.id
"submissionFeedback": { )
"studentSubmission": student_submission_id, result = self.get_client(self.teacher).execute(
"text": "Feedback", UPDATE_SUBMISSION_FEEDBACK_MUTATION,
"final": False variables={
"input": {
"submissionFeedback": {
"studentSubmission": student_submission_id,
"text": "Feedback",
"final": False,
}
} }
} },
}) )
self.assertIsNotNone(result.errors) self.assertIsNotNone(result.errors)
def test_share_feedback_fails(self): def test_share_feedback_fails(self):
student_submission = StudentSubmissionFactory(assignment=self.assignment, student=self.student1, student_submission = StudentSubmissionFactory(
final=True) assignment=self.assignment, student=self.student1, final=True
student_submission_id = to_global_id('StudentSubmissionNode', student_submission.id) )
result = self.get_client(self.teacher).execute(UPDATE_SUBMISSION_FEEDBACK_MUTATION, variables={ student_submission_id = to_global_id(
'input': { "StudentSubmissionNode", student_submission.id
"submissionFeedback": { )
"studentSubmission": student_submission_id, result = self.get_client(self.teacher).execute(
"text": "Feedback", UPDATE_SUBMISSION_FEEDBACK_MUTATION,
"final": True variables={
"input": {
"submissionFeedback": {
"studentSubmission": student_submission_id,
"text": "Feedback",
"final": True,
}
} }
} },
}) )
self.assertIsNotNone(result.errors) self.assertIsNotNone(result.errors)

4
server/books/models/chapter.py
View File

@ -2,7 +2,6 @@ import logging
from django.db import models from django.db import models
from wagtail.admin.panels import FieldPanel, TabbedInterface, ObjectList from wagtail.admin.panels import FieldPanel, TabbedInterface, ObjectList
from books.models.contentblock import ContentBlock
from core.wagtail_utils import StrictHierarchyPage, get_default_settings from core.wagtail_utils import StrictHierarchyPage, get_default_settings
from users.models import SchoolClass from users.models import SchoolClass
@ -39,9 +38,6 @@ class Chapter(StrictHierarchyPage, GraphqlNodeMixin):
SchoolClass, related_name="hidden_chapter_descriptions" SchoolClass, related_name="hidden_chapter_descriptions"
) )
def get_content_blocks(self):
return ContentBlock.objects.all().descendant_of(self)
def sync_title_visibility(self, school_class_template, school_class_to_sync): def sync_title_visibility(self, school_class_template, school_class_to_sync):
if ( if (
self.title_hidden_for.filter(id=school_class_template.id).exists() self.title_hidden_for.filter(id=school_class_template.id).exists()

2
server/books/tests/test_duplicate_contents.py
View File

@ -1,11 +1,9 @@
from django.test import TestCase from django.test import TestCase
from assignments.factories import AssignmentFactory
from assignments.models import Assignment from assignments.models import Assignment
from books.factories import BookFactory, ContentBlockFactory from books.factories import BookFactory, ContentBlockFactory
from books.models.contentblock import ContentBlock from books.models.contentblock import ContentBlock
from core.logger import get_logger from core.logger import get_logger
from surveys.factories import SurveyFactory
from surveys.models import Survey from surveys.models import Survey
from users.services import create_users from users.services import create_users

4
server/core/tests/test_core_hooks.py
View File

@ -1,15 +1,11 @@
import json import json
from django.test import TestCase from django.test import TestCase
from django.urls import reverse from django.urls import reverse
from wagtail.models import Page
from wagtail.test.utils import WagtailTestUtils from wagtail.test.utils import WagtailTestUtils
from wagtail.test.utils.form_data import rich_text
from assignments.factories import AssignmentFactory from assignments.factories import AssignmentFactory
from assignments.models import Assignment from assignments.models import Assignment
from books.blocks import AssignmentBlock, SurveyBlock from books.blocks import AssignmentBlock, SurveyBlock
from books.factories import BookFactory, ChapterFactory, ModuleFactory, TopicFactory from books.factories import BookFactory, ChapterFactory, ModuleFactory, TopicFactory
from books.models.book import Book
from books.models.chapter import Chapter
from books.models.contentblock import ContentBlock from books.models.contentblock import ContentBlock
from books.models.module import Module from books.models.module import Module
from books.models.topic import Topic from books.models.topic import Topic