From a71a12da6ba64c94d373800a3eae4a66feef58bd Mon Sep 17 00:00:00 2001 From: Brendan Kailukaitis Date: Tue, 13 Apr 2021 15:44:55 -0400 Subject: [PATCH 1/7] Formatting changes --- .gitignore | 1 + canvasapi/assignment.py | 65 ++++++++++++++++++++++++++++++++ tests/test_assignment.py | 80 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 146 insertions(+) diff --git a/.gitignore b/.gitignore index 109ce105..10cacd75 100644 --- a/.gitignore +++ b/.gitignore @@ -22,3 +22,4 @@ venv/ setup.sh .python-version .*.swp +.idea* diff --git a/canvasapi/assignment.py b/canvasapi/assignment.py index 4b015668..761a619a 100644 --- a/canvasapi/assignment.py +++ b/canvasapi/assignment.py @@ -22,6 +22,71 @@ def __init__(self, requester, attributes): def __str__(self): return "{} ({})".format(self.name, self.id) + def bulk_submit(self, submission, files=None, **kwargs): + """ + Makes a submission of multiple files for an assigment. + + :calls: `POST /api/v1/courses/:course_id/assignments/:assignment_id/submissions \ + `_ + + :param submission: The attributes of the submission. + :type submission: dict + :param files: A list of files to upload with the submission. (Optional, + defaults to `None`. Submission type must be `online_upload`) + :type files: a list of files or str + + :rtype: :class:`canvasapi.submission.Submission` + """ + if isinstance(submission, dict) and "submission_type" in submission: + kwargs["submission"] = submission + else: + raise RequiredFieldMissing( + "Dictionary with key 'submission_type' is required." + ) + + if files: + if submission.get("submission_type") != "online_upload": + raise ValueError( + "To upload files, 'submission['submission_type']' must be 'online_upload'." + ) + file_ids = self.bulk_upload(files, **kwargs) + kwargs["submission"]["file_ids"] = file_ids + + response = self._requester.request( + "POST", + "courses/{}/assignments/{}/submissions".format(self.course_id, self.id), + _kwargs=combine_kwargs(**kwargs), + ) + response_json = response.json() + response_json.update(course_id=self.course_id) + + return Submission(self._requester, response_json) + + def bulk_upload(self, files: list[FileOrPathLike], user="self", **kwargs): + """ + Upload multiples files to a submission. + + :param files: A list of files or path of files to upload + :type files: list of FileLike + param user: The object or ID of the related user, or 'self' for the + current user. Defaults to 'self'. + :type user: :class:`canvasapi.user.User`, int, or str + + :returns: A list of file ids corresponding to files uploaded \ + to the assigment. + :rtype: list + """ + file_ids = [] + for file in files: + upload_response = self.upload_to_submission(file, user, **kwargs) + + if upload_response[0]: + file_ids.append(upload_response[1]["id"]) + else: + raise CanvasException("File upload failed.") + + return file_ids + def create_override(self, **kwargs): """ Create an override for this assignment. diff --git a/tests/test_assignment.py b/tests/test_assignment.py index b86314b6..3263d8da 100644 --- a/tests/test_assignment.py +++ b/tests/test_assignment.py @@ -256,6 +256,86 @@ def test_submit_file_upload_failure(self, m): finally: cleanup_file(filename) + # bulk_submit() + def test_bulk_submit(self, m): + register_uris({"assignment": ["submit"]}, m) + + sub_type = "online_upload" + sub_dict = {"submission_type": sub_type} + submission = self.assignment.bulk_submit(sub_dict) + + self.assertIsInstance(submission, Submission) + self.assertTrue(hasattr(submission, "submission_type")) + self.assertEqual(submission.submission_type, sub_type) + + def test_bulk_submit_fail(self, m): + with self.assertRaises(RequiredFieldMissing): + self.assignment.bulk_submit({}) + + def test_bulk_submit_file(self, m): + register_uris({"assignment": ["submit", "upload", "upload_final"]}, m) + + filename = "testfile_assignment_{}".format(uuid.uuid4().hex) + + try: + with open(filename, "w+") as file: + sub_type = "online_upload" + sub_dict = {"submission_type": sub_type} + submission = self.assignment.bulk_submit(sub_dict, file) + + self.assertIsInstance(submission, Submission) + self.assertTrue(hasattr(submission, "submission_type")) + self.assertEqual(submission.submission_type, sub_type) + finally: + cleanup_file(filename) + + def test_bulk_submit_multiple_files(self, m): + register_uris({"assignment": ["submit", "upload", "upload_final"]}, m) + + filename_one = "testfile_assignment_{}".format(uuid.uuid4().hex) + filename_two = "testfile_assignment_{}".format(uuid.uuid4().hex) + + try: + with open(filename_one, "w+") as f1, open(filename_two, "w+") as f2: + files = [f1, f2] + + sub_type = "online_upload" + sub_dict = {"submission_type": sub_type} + submission = self.assignment.bulk_submit(sub_dict, files) + + self.assertIsInstance(submission, Submission) + self.assertTrue(hasattr(submission, "submission_type")) + self.assertEqual(submission.submission_type, sub_type) + finally: + cleanup_file(filename_one) + cleanup_file(filename_two) + + def test_bulk_submit_wrong_type(self, m): + filename = "testfile_assignment_{}".format(uuid.uuid4().hex) + sub_type = "online_text_entry" + sub_dict = {"submission_type": sub_type} + + with self.assertRaises(ValueError): + self.assignment.bulk_submit(sub_dict, filename) + + def test_bulk_submit_upload_failure(self, m): + register_uris({"assignment": ["submit", "upload", "upload_fail"]}, m) + + filename_one = "testfile_assignment_{}".format(uuid.uuid4().hex) + filename_two = "testfile_assignment_{}".format(uuid.uuid4().hex) + + try: + with open(filename_one, "w+") as f1, open(filename_two, "w+") as f2: + files = [f1, f2] + + sub_type = "online_upload" + sub_dict = {"submission_type": sub_type} + with self.assertRaises(CanvasException): + self.assignment.bulk_submit(sub_dict, files) + finally: + cleanup_file(filename_one) + cleanup_file(filename_two) + # __str__() def test__str__(self, m): string = str(self.assignment) From c8b87f2ed343c7b5ff84ecf5d9ec28400e4cad33 Mon Sep 17 00:00:00 2001 From: Brendan Kailukaitis Date: Tue, 13 Apr 2021 22:18:51 -0400 Subject: [PATCH 2/7] Organized test cases for bulk_submit --- tests/test_assignment.py | 160 +++++++++++++++++++-------------------- 1 file changed, 80 insertions(+), 80 deletions(-) diff --git a/tests/test_assignment.py b/tests/test_assignment.py index 3263d8da..afd97e6a 100644 --- a/tests/test_assignment.py +++ b/tests/test_assignment.py @@ -41,6 +41,86 @@ def test__init__overrides(self, m): self.assertEqual(len(assignment.overrides), 1) self.assertIsInstance(assignment.overrides[0], AssignmentOverride) + # bulk_submit() + def test_bulk_submit(self, m): + register_uris({"assignment": ["submit"]}, m) + + sub_type = "online_upload" + sub_dict = {"submission_type": sub_type} + submission = self.assignment.bulk_submit(sub_dict) + + self.assertIsInstance(submission, Submission) + self.assertTrue(hasattr(submission, "submission_type")) + self.assertEqual(submission.submission_type, sub_type) + + def test_bulk_submit_fail(self, m): + with self.assertRaises(RequiredFieldMissing): + self.assignment.bulk_submit({}) + + def test_bulk_submit_file(self, m): + register_uris({"assignment": ["submit", "upload", "upload_final"]}, m) + + filename = "testfile_assignment_{}".format(uuid.uuid4().hex) + + try: + with open(filename, "w+") as file: + sub_type = "online_upload" + sub_dict = {"submission_type": sub_type} + submission = self.assignment.bulk_submit(sub_dict, file) + + self.assertIsInstance(submission, Submission) + self.assertTrue(hasattr(submission, "submission_type")) + self.assertEqual(submission.submission_type, sub_type) + finally: + cleanup_file(filename) + + def test_bulk_submit_multiple_files(self, m): + register_uris({"assignment": ["submit", "upload", "upload_final"]}, m) + + filename_one = "testfile_assignment_{}".format(uuid.uuid4().hex) + filename_two = "testfile_assignment_{}".format(uuid.uuid4().hex) + + try: + with open(filename_one, "w+") as f1, open(filename_two, "w+") as f2: + files = [f1, f2] + + sub_type = "online_upload" + sub_dict = {"submission_type": sub_type} + submission = self.assignment.bulk_submit(sub_dict, files) + + self.assertIsInstance(submission, Submission) + self.assertTrue(hasattr(submission, "submission_type")) + self.assertEqual(submission.submission_type, sub_type) + finally: + cleanup_file(filename_one) + cleanup_file(filename_two) + + def test_bulk_submit_wrong_type(self, m): + filename = "testfile_assignment_{}".format(uuid.uuid4().hex) + sub_type = "online_text_entry" + sub_dict = {"submission_type": sub_type} + + with self.assertRaises(ValueError): + self.assignment.bulk_submit(sub_dict, filename) + + def test_bulk_submit_upload_failure(self, m): + register_uris({"assignment": ["submit", "upload", "upload_fail"]}, m) + + filename_one = "testfile_assignment_{}".format(uuid.uuid4().hex) + filename_two = "testfile_assignment_{}".format(uuid.uuid4().hex) + + try: + with open(filename_one, "w+") as f1, open(filename_two, "w+") as f2: + files = [f1, f2] + + sub_type = "online_upload" + sub_dict = {"submission_type": sub_type} + with self.assertRaises(CanvasException): + self.assignment.bulk_submit(sub_dict, files) + finally: + cleanup_file(filename_one) + cleanup_file(filename_two) + # create_override() def test_create_override(self, m): register_uris({"assignment": ["create_override"]}, m) @@ -256,86 +336,6 @@ def test_submit_file_upload_failure(self, m): finally: cleanup_file(filename) - # bulk_submit() - def test_bulk_submit(self, m): - register_uris({"assignment": ["submit"]}, m) - - sub_type = "online_upload" - sub_dict = {"submission_type": sub_type} - submission = self.assignment.bulk_submit(sub_dict) - - self.assertIsInstance(submission, Submission) - self.assertTrue(hasattr(submission, "submission_type")) - self.assertEqual(submission.submission_type, sub_type) - - def test_bulk_submit_fail(self, m): - with self.assertRaises(RequiredFieldMissing): - self.assignment.bulk_submit({}) - - def test_bulk_submit_file(self, m): - register_uris({"assignment": ["submit", "upload", "upload_final"]}, m) - - filename = "testfile_assignment_{}".format(uuid.uuid4().hex) - - try: - with open(filename, "w+") as file: - sub_type = "online_upload" - sub_dict = {"submission_type": sub_type} - submission = self.assignment.bulk_submit(sub_dict, file) - - self.assertIsInstance(submission, Submission) - self.assertTrue(hasattr(submission, "submission_type")) - self.assertEqual(submission.submission_type, sub_type) - finally: - cleanup_file(filename) - - def test_bulk_submit_multiple_files(self, m): - register_uris({"assignment": ["submit", "upload", "upload_final"]}, m) - - filename_one = "testfile_assignment_{}".format(uuid.uuid4().hex) - filename_two = "testfile_assignment_{}".format(uuid.uuid4().hex) - - try: - with open(filename_one, "w+") as f1, open(filename_two, "w+") as f2: - files = [f1, f2] - - sub_type = "online_upload" - sub_dict = {"submission_type": sub_type} - submission = self.assignment.bulk_submit(sub_dict, files) - - self.assertIsInstance(submission, Submission) - self.assertTrue(hasattr(submission, "submission_type")) - self.assertEqual(submission.submission_type, sub_type) - finally: - cleanup_file(filename_one) - cleanup_file(filename_two) - - def test_bulk_submit_wrong_type(self, m): - filename = "testfile_assignment_{}".format(uuid.uuid4().hex) - sub_type = "online_text_entry" - sub_dict = {"submission_type": sub_type} - - with self.assertRaises(ValueError): - self.assignment.bulk_submit(sub_dict, filename) - - def test_bulk_submit_upload_failure(self, m): - register_uris({"assignment": ["submit", "upload", "upload_fail"]}, m) - - filename_one = "testfile_assignment_{}".format(uuid.uuid4().hex) - filename_two = "testfile_assignment_{}".format(uuid.uuid4().hex) - - try: - with open(filename_one, "w+") as f1, open(filename_two, "w+") as f2: - files = [f1, f2] - - sub_type = "online_upload" - sub_dict = {"submission_type": sub_type} - with self.assertRaises(CanvasException): - self.assignment.bulk_submit(sub_dict, files) - finally: - cleanup_file(filename_one) - cleanup_file(filename_two) - # __str__() def test__str__(self, m): string = str(self.assignment) From d32a81dead02b984d4eb3cb14e798b19ca54b66e Mon Sep 17 00:00:00 2001 From: Brendan Kailukaitis Date: Tue, 13 Apr 2021 22:23:07 -0400 Subject: [PATCH 3/7] Fixed test cases not being discovered --- tests/test_assignment.py | 122 +++++++++++++++++++-------------------- 1 file changed, 61 insertions(+), 61 deletions(-) diff --git a/tests/test_assignment.py b/tests/test_assignment.py index afd97e6a..54946675 100644 --- a/tests/test_assignment.py +++ b/tests/test_assignment.py @@ -41,85 +41,85 @@ def test__init__overrides(self, m): self.assertEqual(len(assignment.overrides), 1) self.assertIsInstance(assignment.overrides[0], AssignmentOverride) - # bulk_submit() - def test_bulk_submit(self, m): - register_uris({"assignment": ["submit"]}, m) + # bulk_submit() + def test_bulk_submit(self, m): + register_uris({"assignment": ["submit"]}, m) - sub_type = "online_upload" - sub_dict = {"submission_type": sub_type} - submission = self.assignment.bulk_submit(sub_dict) + sub_type = "online_upload" + sub_dict = {"submission_type": sub_type} + submission = self.assignment.bulk_submit(sub_dict) - self.assertIsInstance(submission, Submission) - self.assertTrue(hasattr(submission, "submission_type")) - self.assertEqual(submission.submission_type, sub_type) + self.assertIsInstance(submission, Submission) + self.assertTrue(hasattr(submission, "submission_type")) + self.assertEqual(submission.submission_type, sub_type) - def test_bulk_submit_fail(self, m): - with self.assertRaises(RequiredFieldMissing): - self.assignment.bulk_submit({}) + def test_bulk_submit_fail(self, m): + with self.assertRaises(RequiredFieldMissing): + self.assignment.bulk_submit({}) - def test_bulk_submit_file(self, m): - register_uris({"assignment": ["submit", "upload", "upload_final"]}, m) + def test_bulk_submit_file(self, m): + register_uris({"assignment": ["submit", "upload", "upload_final"]}, m) - filename = "testfile_assignment_{}".format(uuid.uuid4().hex) + filename = "testfile_assignment_{}".format(uuid.uuid4().hex) - try: - with open(filename, "w+") as file: - sub_type = "online_upload" - sub_dict = {"submission_type": sub_type} - submission = self.assignment.bulk_submit(sub_dict, file) + try: + with open(filename, "w+") as file: + sub_type = "online_upload" + sub_dict = {"submission_type": sub_type} + submission = self.assignment.bulk_submit(sub_dict, file) - self.assertIsInstance(submission, Submission) - self.assertTrue(hasattr(submission, "submission_type")) - self.assertEqual(submission.submission_type, sub_type) - finally: - cleanup_file(filename) + self.assertIsInstance(submission, Submission) + self.assertTrue(hasattr(submission, "submission_type")) + self.assertEqual(submission.submission_type, sub_type) + finally: + cleanup_file(filename) - def test_bulk_submit_multiple_files(self, m): - register_uris({"assignment": ["submit", "upload", "upload_final"]}, m) + def test_bulk_submit_multiple_files(self, m): + register_uris({"assignment": ["submit", "upload", "upload_final"]}, m) - filename_one = "testfile_assignment_{}".format(uuid.uuid4().hex) - filename_two = "testfile_assignment_{}".format(uuid.uuid4().hex) + filename_one = "testfile_assignment_{}".format(uuid.uuid4().hex) + filename_two = "testfile_assignment_{}".format(uuid.uuid4().hex) - try: - with open(filename_one, "w+") as f1, open(filename_two, "w+") as f2: - files = [f1, f2] + try: + with open(filename_one, "w+") as f1, open(filename_two, "w+") as f2: + files = [f1, f2] - sub_type = "online_upload" - sub_dict = {"submission_type": sub_type} - submission = self.assignment.bulk_submit(sub_dict, files) + sub_type = "online_upload" + sub_dict = {"submission_type": sub_type} + submission = self.assignment.bulk_submit(sub_dict, files) - self.assertIsInstance(submission, Submission) - self.assertTrue(hasattr(submission, "submission_type")) - self.assertEqual(submission.submission_type, sub_type) - finally: - cleanup_file(filename_one) - cleanup_file(filename_two) + self.assertIsInstance(submission, Submission) + self.assertTrue(hasattr(submission, "submission_type")) + self.assertEqual(submission.submission_type, sub_type) + finally: + cleanup_file(filename_one) + cleanup_file(filename_two) - def test_bulk_submit_wrong_type(self, m): - filename = "testfile_assignment_{}".format(uuid.uuid4().hex) - sub_type = "online_text_entry" - sub_dict = {"submission_type": sub_type} + def test_bulk_submit_wrong_type(self, m): + filename = "testfile_assignment_{}".format(uuid.uuid4().hex) + sub_type = "online_text_entry" + sub_dict = {"submission_type": sub_type} - with self.assertRaises(ValueError): - self.assignment.bulk_submit(sub_dict, filename) + with self.assertRaises(ValueError): + self.assignment.bulk_submit(sub_dict, filename) - def test_bulk_submit_upload_failure(self, m): - register_uris({"assignment": ["submit", "upload", "upload_fail"]}, m) + def test_bulk_submit_upload_failure(self, m): + register_uris({"assignment": ["submit", "upload", "upload_fail"]}, m) - filename_one = "testfile_assignment_{}".format(uuid.uuid4().hex) - filename_two = "testfile_assignment_{}".format(uuid.uuid4().hex) + filename_one = "testfile_assignment_{}".format(uuid.uuid4().hex) + filename_two = "testfile_assignment_{}".format(uuid.uuid4().hex) - try: - with open(filename_one, "w+") as f1, open(filename_two, "w+") as f2: - files = [f1, f2] + try: + with open(filename_one, "w+") as f1, open(filename_two, "w+") as f2: + files = [f1, f2] - sub_type = "online_upload" - sub_dict = {"submission_type": sub_type} - with self.assertRaises(CanvasException): - self.assignment.bulk_submit(sub_dict, files) - finally: - cleanup_file(filename_one) - cleanup_file(filename_two) + sub_type = "online_upload" + sub_dict = {"submission_type": sub_type} + with self.assertRaises(CanvasException): + self.assignment.bulk_submit(sub_dict, files) + finally: + cleanup_file(filename_one) + cleanup_file(filename_two) # create_override() def test_create_override(self, m): From 56b388fbaa01a970dc81adc56560677bb969c88e Mon Sep 17 00:00:00 2001 From: Brendan Kailukaitis Date: Tue, 13 Apr 2021 22:32:16 -0400 Subject: [PATCH 4/7] Removed file from gitignore --- .gitignore | 1 - 1 file changed, 1 deletion(-) diff --git a/.gitignore b/.gitignore index 10cacd75..109ce105 100644 --- a/.gitignore +++ b/.gitignore @@ -22,4 +22,3 @@ venv/ setup.sh .python-version .*.swp -.idea* From 22cb74e4b89369eea243e421bb8125050a1b5814 Mon Sep 17 00:00:00 2001 From: Brendan Kailukaitis Date: Tue, 13 Apr 2021 22:52:54 -0400 Subject: [PATCH 5/7] Imported List from typing for method type annotations --- .gitignore | 1 - canvasapi/assignment.py | 3 ++- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.gitignore b/.gitignore index 10cacd75..109ce105 100644 --- a/.gitignore +++ b/.gitignore @@ -22,4 +22,3 @@ venv/ setup.sh .python-version .*.swp -.idea* diff --git a/canvasapi/assignment.py b/canvasapi/assignment.py index 761a619a..ebf7ede9 100644 --- a/canvasapi/assignment.py +++ b/canvasapi/assignment.py @@ -7,6 +7,7 @@ from canvasapi.upload import FileOrPathLike, Uploader from canvasapi.user import User, UserDisplay from canvasapi.util import combine_kwargs, obj_or_id +from typing import List class Assignment(CanvasObject): @@ -62,7 +63,7 @@ def bulk_submit(self, submission, files=None, **kwargs): return Submission(self._requester, response_json) - def bulk_upload(self, files: list[FileOrPathLike], user="self", **kwargs): + def bulk_upload(self, files: List[FileOrPathLike], user="self", **kwargs): """ Upload multiples files to a submission. From 48fe21914f6b5748fcff18b2ea2ad9ff3377c135 Mon Sep 17 00:00:00 2001 From: Brendan Kailukaitis Date: Tue, 13 Apr 2021 22:54:29 -0400 Subject: [PATCH 6/7] Fixed import sorting --- canvasapi/assignment.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/canvasapi/assignment.py b/canvasapi/assignment.py index ebf7ede9..b6625a8e 100644 --- a/canvasapi/assignment.py +++ b/canvasapi/assignment.py @@ -1,3 +1,5 @@ +from typing import List + from canvasapi.canvas_object import CanvasObject from canvasapi.exceptions import CanvasException, RequiredFieldMissing from canvasapi.paginated_list import PaginatedList @@ -7,7 +9,6 @@ from canvasapi.upload import FileOrPathLike, Uploader from canvasapi.user import User, UserDisplay from canvasapi.util import combine_kwargs, obj_or_id -from typing import List class Assignment(CanvasObject): From f25b9a950c01477913a5288877e0ac7341c9ed2f Mon Sep 17 00:00:00 2001 From: Brendan Kailukaitis Date: Tue, 13 Apr 2021 23:27:59 -0400 Subject: [PATCH 7/7] Fixed formatting --- canvasapi/assignment.py | 4 +-- tests/test_assignment.py | 55 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+), 2 deletions(-) diff --git a/canvasapi/assignment.py b/canvasapi/assignment.py index b6625a8e..8cfc14ad 100644 --- a/canvasapi/assignment.py +++ b/canvasapi/assignment.py @@ -85,7 +85,7 @@ def bulk_upload(self, files: List[FileOrPathLike], user="self", **kwargs): if upload_response[0]: file_ids.append(upload_response[1]["id"]) else: - raise CanvasException("File upload failed.") + raise CanvasException(f"File {file} upload failed.") return file_ids @@ -510,7 +510,7 @@ def upload_to_submission(self, file: FileOrPathLike, user="self", **kwargs): self.course_id, self.id, user_id ), file, - **kwargs + **kwargs, ).start() diff --git a/tests/test_assignment.py b/tests/test_assignment.py index 54946675..8583b829 100644 --- a/tests/test_assignment.py +++ b/tests/test_assignment.py @@ -121,6 +121,61 @@ def test_bulk_submit_upload_failure(self, m): cleanup_file(filename_one) cleanup_file(filename_two) + # bulk_upload() + def test_bulk_upload_self(self, m): + register_uris({"assignment": ["upload", "upload_final"]}, m) + + filename_one = "testfile_assignment_{}".format(uuid.uuid4().hex) + filename_two = "testfile_assignment_{}".format(uuid.uuid4().hex) + + try: + with open(filename_one, "w+") as f1, open(filename_two, "w+") as f2: + files = [f1, f2] + + file_ids = self.assignment.bulk_upload(files) + + self.assertIsNotNone(file_ids) + self.assertIsInstance(file_ids, list) + finally: + cleanup_file(filename_one) + cleanup_file(filename_two) + + def test_bulk_upload_failure(self, m): + register_uris({"assignment": ["upload", "upload_fail"]}, m) + + filename_one = "testfile_assignment_{}".format(uuid.uuid4().hex) + filename_two = "testfile_assignment_{}".format(uuid.uuid4().hex) + + try: + with open(filename_one, "w+") as f1, open(filename_two, "w+") as f2: + files = [f1, f2] + + with self.assertRaises(CanvasException): + self.assignment.bulk_upload(files) + finally: + cleanup_file(filename_one) + cleanup_file(filename_two) + + def test_bulk_upload_user(self, m): + register_uris({"assignment": ["upload_by_id", "upload_final"]}, m) + + filename_one = "testfile_assignment_{}".format(uuid.uuid4().hex) + filename_two = "testfile_assignment_{}".format(uuid.uuid4().hex) + + user_id = 1 + + try: + with open(filename_one, "w+") as f1, open(filename_two, "w+") as f2: + files = [f1, f2] + + file_ids = self.assignment.bulk_upload(files, user_id) + + self.assertIsNotNone(file_ids) + self.assertIsInstance(file_ids, list) + finally: + cleanup_file(filename_one) + cleanup_file(filename_two) + # create_override() def test_create_override(self, m): register_uris({"assignment": ["create_override"]}, m)