canvasapi/tests/test_submission.py at e07b4d84212c7ca1266e551a05e988c8882ef46c · ucfopen/canvasapi · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
import unittest
import uuid

import requests_mock

from canvasapi import Canvas
from canvasapi.file import File
from canvasapi.peer_review import PeerReview
from canvasapi.submission import GroupedSubmission, Submission
from tests import settings
from tests.util import cleanup_file, register_uris
from unittest.mock import patch


@requests_mock.Mocker()
class TestSubmission(unittest.TestCase):
    def setUp(self):
        self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)

        with requests_mock.Mocker() as m:
            register_uris(
                {
                    "course": ["get_by_id", "get_assignment_by_id"],
                    "section": ["get_by_id"],
                    "submission": ["get_by_id_course"],
                },
                m,
            )

            self.course = self.canvas.get_course(1)
            self.assignment = self.course.get_assignment(1)
            self.submission = self.assignment.get_submission(1)

    # __init__()
    def test__init__attachments(self, m):
        register_uris({"submission": ["get_by_id_with_attachments"]}, m)

        submission = self.assignment.get_submission(1)

        self.assertTrue(hasattr(submission, "attachments"))
        self.assertIsInstance(submission.attachments, list)
        self.assertEqual(len(submission.attachments), 1)
        self.assertIsInstance(submission.attachments[0], File)
        self.assertTrue(hasattr(submission.attachments[0], "id"))
        self.assertEqual(submission.attachments[0].id, 123)

    # __str__()
    def test__str__(self, m):
        string = str(self.submission)
        self.assertIsInstance(string, str)

    # create_submission_peer_review()
    def test_create_submission_peer_review(self, m):
        register_uris({"submission": ["create_submission_peer_review"]}, m)

        created_peer_review = self.submission.create_submission_peer_review(1)

        self.assertIsInstance(created_peer_review, PeerReview)
        self.assertEqual(created_peer_review.user_id, 7)

    # delete_submission_peer_review()
    def test_delete_submission_peer_review(self, m):
        register_uris({"submission": ["delete_submission_peer_review"]}, m)

        deleted_peer_review = self.submission.delete_submission_peer_review(1)

        self.assertIsInstance(deleted_peer_review, PeerReview)
        self.assertEqual(deleted_peer_review.user_id, 7)

    # edit()
    def test_edit(self, m):
        register_uris({"submission": ["edit"]}, m)

        self.assertFalse(hasattr(self.submission, "excused"))

        self.submission.edit(submission={"excuse": True})

        self.assertIsInstance(self.submission, Submission)
        self.assertTrue(hasattr(self.submission, "excused"))
        self.assertTrue(self.submission.excused)

    # get_submission_peer_reviews()
    def test_get_submission_peer_reviews(self, m):
        register_uris({"submission": ["list_submission_peer_reviews"]}, m)

        submission_peer_reviews = self.submission.get_submission_peer_reviews()
        submission_peer_review_list = [
            peer_review for peer_review in submission_peer_reviews
        ]

        self.assertEqual(len(submission_peer_review_list), 2)
        self.assertIsInstance(submission_peer_review_list[0], PeerReview)

    # mark_read()
    def test_mark_read(self, m):
        register_uris({"course": ["mark_submission_as_read"]}, m)

        marked_read = self.submission.mark_read()
        self.assertTrue(marked_read)

    # mark_unread()
    def test_mark_unread(self, m):
        register_uris({"course": ["mark_submission_as_unread"]}, m)

        marked_unread = self.submission.mark_unread()
        self.assertTrue(marked_unread)

    # upload_comment()
    def test_upload_comment(self, m):
        register_uris(
            {"submission": ["upload_comment", "upload_comment_final", "edit"]}, m
        )

        filename = "testfile_submission_{}".format(uuid.uuid4().hex)
        text_comment = "Here is my file comment"

        try:
            with open(filename, "w+") as file:
                with patch.object(self.submission, 'edit') as mock_edit:
                    response = self.submission.upload_comment(file, text_comment=text_comment)

                    self.assertTrue(response[0])
                    self.assertIsInstance(response[1], dict)
                    self.assertIn("url", response[1])

                    # Verify if the edit method was called with the correct arguments
                    mock_edit.assert_called_once()
                    _, kwargs = mock_edit.call_args
                    self.assertIn("comment", kwargs)
                    self.assertIn("text_comment", kwargs["comment"])
                    self.assertEqual(kwargs["comment"]["text_comment"], text_comment)

        finally:
            cleanup_file(filename)


class TestGroupedSubmission(unittest.TestCase):
    def setUp(self):
        self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)

        self.grouped_submission = GroupedSubmission(
            self.canvas._Canvas__requester,
            {
                "user_id": 1,
                "submissions": [
                    {
                        "id": 1,
                        "assignment_id": 1,
                        "user_id": 1,
                        "html_url": "https://example.com/courses/1/assignments/1/submissions/1",
                        "submission_type": "online_upload",
                    }
                ],
            },
        )

    # __init__()
    def test__init__no_submission_key(self):
        grouped_submission = GroupedSubmission(
            self.canvas._Canvas__requester, {"user_id": 1}
        )

        self.assertIsInstance(grouped_submission, GroupedSubmission)
        self.assertTrue(hasattr(grouped_submission, "submissions"))
        self.assertIsInstance(grouped_submission.submissions, list)
        self.assertEqual(len(grouped_submission.submissions), 0)

    # __str__()
    def test__str__(self):
        string = str(self.grouped_submission)
        self.assertIsInstance(string, str)
        self.assertEqual(string, "1 submission(s) for User #1")