def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {'account': ['get_by_id'], 'enrollment': ['get_by_id']}
register_uris(requires, m)
self.account = self.canvas.get_account(1)
self.enrollment = self.account.get_enrollment(1)
class TestPageRevision(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
'course': ['get_by_id', 'get_page'],
'group': ['get_by_id', 'pages_get_page'],
'page': ['get_latest_rev_by_id', 'get_latest_rev_by_id_group']
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.group = self.canvas.get_group(1)
self.page_course = self.course.get_page('my-url')
self.page_group = self.group.get_page('my-url')
self.revision = self.page_course.get_revision_by_id(2)
self.group_revision = self.page_group.get_revision_by_id(2)
# __str__()
def test__str__(self, m):
string = str(self.revision)
self.assertIsInstance(string, str)
# parent_id
def test_parent_id_course(self, m):
self.assertEqual(self.revision.parent_id, 1)
def test_parent_id_no_id(self, m):
page = PageRevision(self.canvas._Canvas__requester, {'url': 'my-url'})
with self.assertRaises(ValueError):
page.parent_id
# parent_type
def test_parent_type_course(self, m):
self.assertEqual(self.page_course.parent_type, 'course')
def test_parent_type_group(self, m):
self.assertEqual(self.page_group.parent_type, 'group')
def test_parent_type_no_id(self, m):
page = PageRevision(self.canvas._Canvas__requester, {'url': 'my-url'})
with self.assertRaises(ValueError):
page.parent_type
# get_parent()
def test_get_parent_course(self, m):
register_uris({'course': ['get_by_id']}, m)
self.assertIsInstance(self.revision.get_parent(), Course)
def test_get_parent_group(self, m):
register_uris({'group': ['get_by_id']}, m)
self.assertIsInstance(self.group_revision.get_parent(), Group)
class TestPageRevision(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
"course": ["get_by_id", "get_page"],
"group": ["get_by_id", "pages_get_page"],
"page": ["get_latest_rev_by_id", "get_latest_rev_by_id_group"],
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.group = self.canvas.get_group(1)
self.page_course = self.course.get_page("my-url")
self.page_group = self.group.get_page("my-url")
self.revision = self.page_course.get_revision_by_id(2)
self.group_revision = self.page_group.get_revision_by_id(2)
# __str__()
def test__str__(self, m):
string = str(self.revision)
self.assertIsInstance(string, str)
# parent_id
def test_parent_id_course(self, m):
self.assertEqual(self.revision.parent_id, 1)
def test_parent_id_no_id(self, m):
page = PageRevision(self.canvas._Canvas__requester, {"url": "my-url"})
with self.assertRaises(ValueError):
page.parent_id
# parent_type
def test_parent_type_course(self, m):
self.assertEqual(self.page_course.parent_type, "course")
def test_parent_type_group(self, m):
self.assertEqual(self.page_group.parent_type, "group")
def test_parent_type_no_id(self, m):
page = PageRevision(self.canvas._Canvas__requester, {"url": "my-url"})
with self.assertRaises(ValueError):
page.parent_type
# get_parent()
def test_get_parent_course(self, m):
register_uris({"course": ["get_by_id"]}, m)
self.assertIsInstance(self.revision.get_parent(), Course)
def test_get_parent_group(self, m):
register_uris({"group": ["get_by_id"]}, m)
self.assertIsInstance(self.group_revision.get_parent(), Group)
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
"course": ["get_by_id", "create_group_category"],
"group": ["category_assign_members_false"],
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.group_category = self.course.create_group_category("Test String")
self.progress = self.group_category.assign_members()
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
'course': ['get_by_id', 'create_group_category'],
'group': ['category_assign_members_false']
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.group_category = self.course.create_group_category(
"Test String")
self.progress = self.group_category.assign_members()
def build_canvas_connection(self) -> Canvas:
self.line_separator()
while True:
try:
url = input(
"Please enter the Canvas url (example: https://canvas.ucdavis.edu/): "
)
token = input("Please enter your Canvas token: ")
connection = Canvas(url, token)
# Check if url and token match
connection.get_current_user()
except (UserWarning, ValueError) as e:
print(e)
else:
return connection
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
'course': ['get_by_id'],
'group': ['get_by_id', 'pages_get_page'],
'page': ['get_page']
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.group = self.canvas.get_group(1)
self.page_course = self.course.get_page('my-url')
self.page_group = self.group.get_page('my-url')
class TestProgress(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
'course': ['get_by_id', 'create_group_category'],
'group': ['category_assign_members_false']
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.group_category = self.course.create_group_category(
"Test String")
self.progress = self.group_category.assign_members()
# __str__()
def test__str__(self, m):
string = str(self.progress)
self.assertIsInstance(string, str)
# query()
def test_query(self, m):
register_uris({'progress': ['progress_query']}, m)
response = self.progress.query()
self.assertIsInstance(response, Progress)
def print_favorite_courses(self, canvas: Canvas) -> int:
print("These are your FAVORITE Canvas courses.")
end_favorite_index = self.print_list_with_index(
canvas.get_current_user().get_favorite_courses())
all_course_index = end_favorite_index + 1
print(str(all_course_index) + ": " + "Show me ALL Canvas courses")
return all_course_index
class TestEnrollment(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {"account": ["get_by_id"], "enrollment": ["get_by_id"]}
register_uris(requires, m)
self.account = self.canvas.get_account(1)
self.enrollment = self.account.get_enrollment(1)
# __str__()
def test__str__(self, m):
string = str(self.enrollment)
self.assertIsInstance(string, str)
# deactivate()
def test_deactivate(self, m):
register_uris({"enrollment": ["deactivate"]}, m)
target_enrollment = self.enrollment.deactivate("conclude")
self.assertIsInstance(target_enrollment, Enrollment)
def test_deactivate_invalid_task(self, m):
with self.assertRaises(ValueError):
self.enrollment.deactivate("finish")
# reactivate()
def test_reactivate(self, m):
register_uris({"enrollment": ["reactivate"]}, m)
target_enrollment = self.enrollment.reactivate()
self.assertIsInstance(target_enrollment, Enrollment)
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
"course": ["get_by_id"],
"group": ["get_by_id", "pages_get_page"],
"page": ["get_page"],
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.group = self.canvas.get_group(1)
self.page_course = self.course.get_page("my-url")
self.page_group = self.group.get_page("my-url")
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
"course": ["get_by_id", "get_assignment_by_id"],
"assignment": ["list_peer_reviews"],
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.assignment = self.course.get_assignment(1)
self.peer_reviews = [
peer_review for peer_review in self.assignment.get_peer_reviews()
]
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
'course': ['get_by_id', 'get_assignment_by_id'],
'assignment': ['list_peer_reviews']
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.assignment = self.course.get_assignment(1)
self.peer_reviews = [
peer_review
for peer_review in self.assignment.get_peer_reviews()
]
def get_course(self, canvas: Canvas) -> Course:
self.line_separator()
ask_course = "Please enter the index number in front of the course in which you want to manage the grades: "
all_course_index = self.print_favorite_courses(canvas)
user_input_course = self.get_user_input_int(start_point=1,
end_point=all_course_index,
prompt=ask_course,
comma_allowed=False)
if user_input_course == all_course_index:
end_all_index = self.print_all_courses(canvas)
user_input_course = self.get_user_input_int(
start_point=1,
end_point=end_all_index,
prompt=ask_course,
comma_allowed=False)
course_index = user_input_course - 1
canvas_course = canvas.get_current_user().get_favorite_courses(
)[course_index]
return canvas_course
class TestPeerReview(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
"course": ["get_by_id", "get_assignment_by_id"],
"assignment": ["list_peer_reviews"],
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.assignment = self.course.get_assignment(1)
self.peer_reviews = [
peer_review for peer_review in self.assignment.get_peer_reviews()
]
# __str__()
def test__str__(self, m):
string = str(self.peer_reviews[0])
self.assertIsInstance(string, str)
class TestEnrollment(unittest.TestCase):
@classmethod
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {'account': ['get_by_id'], 'enrollment': ['get_by_id']}
register_uris(requires, m)
self.account = self.canvas.get_account(1)
self.enrollment = self.account.get_enrollment(1)
# __str__()
def test__str__(self, m):
string = str(self.enrollment)
self.assertIsInstance(string, str)
# deactivate()
def test_deactivate(self, m):
register_uris({'enrollment': ['deactivate']}, m)
target_enrollment = self.enrollment.deactivate('conclude')
self.assertIsInstance(target_enrollment, Enrollment)
def test_deactivate_invalid_task(self, m):
with self.assertRaises(ValueError):
self.enrollment.deactivate('finish')
# reactivate()
def test_reactivate(self, m):
register_uris({'enrollment': ['reactivate']}, m)
target_enrollment = self.enrollment.reactivate()
self.assertIsInstance(target_enrollment, Enrollment)
class TestPage(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
"course": ["get_by_id"],
"group": ["get_by_id", "pages_get_page"],
"page": ["get_page"],
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.group = self.canvas.get_group(1)
self.page_course = self.course.get_page("my-url")
self.page_group = self.group.get_page("my-url")
# __str__()
def test__str__(self, m):
string = str(self.page_course)
self.assertIsInstance(string, str)
def test_edit(self, m):
register_uris({"page": ["edit"]}, m)
new_title = "New Page"
self.page_course.edit(page={"title": new_title})
self.assertIsInstance(self.page_course, Page)
self.assertTrue(hasattr(self.page_course, "title"))
self.assertEqual(self.page_course.title, new_title)
def test_delete(self, m):
register_uris({"page": ["delete_page"]}, m)
page = self.page_course
deleted_page = page.delete()
self.assertIsInstance(deleted_page, Page)
# get_revisions()
def test_get_revisions(self, m):
register_uris({"page": ["list_revisions", "list_revisions2"]}, m)
revisions = self.page_course.get_revisions()
rev_list = [rev for rev in revisions]
self.assertEqual(len(rev_list), 4)
self.assertIsInstance(rev_list[0], PageRevision)
def test_show_latest_revision(self, m):
register_uris({"page": ["latest_revision"]}, m)
revision = self.page_course.show_latest_revision()
self.assertIsInstance(revision, PageRevision)
def test_get_revision_by_id_course(self, m):
register_uris({"page": ["get_latest_rev_by_id"]}, m)
revision_by_id = self.page_course.get_revision_by_id(2)
self.assertIsInstance(revision_by_id, PageRevision)
revision_by_obj = self.page_course.get_revision_by_id(revision_by_id)
self.assertIsInstance(revision_by_obj, PageRevision)
def test_get_revision_by_id_group(self, m):
register_uris({"page": ["get_latest_rev_by_id_group"]}, m)
revision_by_id = self.page_group.get_revision_by_id(2)
self.assertIsInstance(revision_by_id, PageRevision)
revision_by_obj = self.page_group.get_revision_by_id(revision_by_id)
self.assertIsInstance(revision_by_obj, PageRevision)
def test_revert_to_revision_course(self, m):
register_uris({"page": ["revert_to_revision"]}, m)
revision = self.page_course.revert_to_revision(3)
self.assertIsInstance(revision, PageRevision)
def test_revert_to_revision_group(self, m):
register_uris({"page": ["revert_to_revision_group"]}, m)
revision = self.page_group.revert_to_revision(3)
self.assertIsInstance(revision, PageRevision)
# parent_id
def test_parent_id_course(self, m):
self.assertEqual(self.page_course.parent_id, 1)
def test_parent_id_group(self, m):
self.assertEqual(self.page_group.parent_id, 1)
def test_parent_id_no_id(self, m):
page = Page(self.canvas._Canvas__requester, {"url": "my-url"})
with self.assertRaises(ValueError):
page.parent_id
# parent_type
def test_parent_type_course(self, m):
self.assertEqual(self.page_course.parent_type, "course")
def test_parent_type_group(self, m):
self.assertEqual(self.page_group.parent_type, "group")
def test_parent_type_no_id(self, m):
page = Page(self.canvas._Canvas__requester, {"url": "my-url"})
with self.assertRaises(ValueError):
page.parent_type
# get_parent()
def test_get_parent_course(self, m):
register_uris({"course": ["get_by_id"]}, m)
self.assertIsInstance(self.page_course.get_parent(), Course)
def test_get_parent_group(self, m):
register_uris({"group": ["get_by_id"]}, m)
self.assertIsInstance(self.page_group.get_parent(), Group)
def print_all_courses(self, canvas: Canvas) -> int:
print("These are ALL of your Canvas courses")
end_all_index = self.print_list_with_index(canvas.get_courses())
return end_all_index
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
self.requester = self.canvas._Canvas__requester
self.filename = "testfile_uploader_{}".format(uuid.uuid4().hex)
self.file = open(self.filename, "w+")
for row in range(0, len(df['Login ID'].keys())):
user_dic[df['Login ID'][row]] = df['ID'][row]
id_list = []
for student in participant_list:
if student in user_dic.keys():
id_list.append(user_dic[student])
API_URL = "https://uncc.instructure.com/"
# Canvas API key
file = open('token.txt', 'r')
API_KEY = str(file.read())
file.close()
# Initialize a new Canvas object
canvas = Canvas(API_URL, API_KEY)
course = canvas.get_course(input('Enter Course ID: '))
print('Grading the course : ' + course.name)
survey_assignment = course.get_assignment(input('Enter Assignment ID: '))
submissions = survey_assignment.get_submissions()
total_points = float(survey_assignment.points_possible)
for submission in submissions:
if submission.user_id in id_list:
submission.edit(submission={'posted_grade': total_points})
else:
submission.edit(submission={'posted_grade': 0.0})
print('student ' + str(submission.user_id) + ' graded')
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
self.requester = self.canvas._Canvas__requester
self.filename = 'testfile_uploader_%s' % uuid.uuid4().hex
self.file = open(self.filename, 'w+')
class TestPage(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
with requests_mock.Mocker() as m:
requires = {
'course': ['get_by_id'],
'group': ['get_by_id', 'pages_get_page'],
'page': ['get_page']
}
register_uris(requires, m)
self.course = self.canvas.get_course(1)
self.group = self.canvas.get_group(1)
self.page_course = self.course.get_page('my-url')
self.page_group = self.group.get_page('my-url')
# __str__()
def test__str__(self, m):
string = str(self.page_course)
self.assertIsInstance(string, str)
def test_edit(self, m):
register_uris({'page': ['edit']}, m)
new_title = "New Page"
self.page_course.edit(page={'title': new_title})
self.assertIsInstance(self.page_course, Page)
self.assertTrue(hasattr(self.page_course, 'title'))
self.assertEqual(self.page_course.title, new_title)
def test_delete(self, m):
register_uris({'page': ['delete_page']}, m)
page = self.page_course
deleted_page = page.delete()
self.assertIsInstance(deleted_page, Page)
def test_list_revisions(self, m):
register_uris({'page': ['list_revisions', 'list_revisions2']}, m)
revisions = self.page_course.list_revisions()
rev_list = [rev for rev in revisions]
self.assertEqual(len(rev_list), 4)
self.assertIsInstance(rev_list[0], PageRevision)
def test_show_latest_revision(self, m):
register_uris({'page': ['latest_revision']}, m)
revision = self.page_course.show_latest_revision()
self.assertIsInstance(revision, PageRevision)
def test_get_revision_by_id_course(self, m):
register_uris({'page': ['get_latest_rev_by_id']}, m)
revision = self.page_course.get_revision_by_id(2)
self.assertIsInstance(revision, PageRevision)
def test_get_revision_by_id_group(self, m):
register_uris({'page': ['get_latest_rev_by_id_group']}, m)
revision = self.page_group.get_revision_by_id(2)
self.assertIsInstance(revision, PageRevision)
def test_revert_to_revision_course(self, m):
register_uris({'page': ['revert_to_revision']}, m)
revision = self.page_course.revert_to_revision(3)
self.assertIsInstance(revision, PageRevision)
def test_revert_to_revision_group(self, m):
register_uris({'page': ['revert_to_revision_group']}, m)
revision = self.page_group.revert_to_revision(3)
self.assertIsInstance(revision, PageRevision)
# parent_id
def test_parent_id_course(self, m):
self.assertEqual(self.page_course.parent_id, 1)
def test_parent_id_group(self, m):
self.assertEqual(self.page_group.parent_id, 1)
def test_parent_id_no_id(self, m):
page = Page(self.canvas._Canvas__requester, {'url': 'my-url'})
with self.assertRaises(ValueError):
page.parent_id
# parent_type
def test_parent_type_course(self, m):
self.assertEqual(self.page_course.parent_type, 'course')
def test_parent_type_group(self, m):
self.assertEqual(self.page_group.parent_type, 'group')
def test_parent_type_no_id(self, m):
page = Page(self.canvas._Canvas__requester, {'url': 'my-url'})
with self.assertRaises(ValueError):
page.parent_type
# get_parent()
def test_get_parent_course(self, m):
register_uris({'course': ['get_by_id']}, m)
self.assertIsInstance(self.page_course.get_parent(), Course)
def test_get_parent_group(self, m):
register_uris({'group': ['get_by_id']}, m)
self.assertIsInstance(self.page_group.get_parent(), Group)
