class TestCanvas(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
# Canvas()
def test_init_deprecate_url_contains_version(self, m):
with self.assertRaises(
ValueError,
msg=
"`base_url` should not specify an API version. Remove trailing /api/v1/",
):
Canvas(settings.BASE_URL_WITH_VERSION, settings.API_KEY)
def test_init_warns_when_url_is_http(self, m):
with warnings.catch_warnings(record=True):
Canvas(settings.BASE_URL_AS_HTTP, settings.API_KEY)
self.assertRaises(
UserWarning,
msg=
("Canvas may respond unexpectedly when making requests to HTTP"
"URLs. If possible, please use HTTPS."),
)
def test_init_warns_when_url_is_blank(self, m):
with warnings.catch_warnings(record=True):
Canvas(settings.BASE_URL_AS_BLANK, settings.API_KEY)
self.assertRaises(
UserWarning,
msg=
"Canvas needs a valid URL, please provide a non-blank `base_url`.",
)
def test_init_warns_when_url_is_invalid(self, m):
with warnings.catch_warnings(record=True):
Canvas(settings.BASE_URL_AS_INVALID, settings.API_KEY)
self.assertRaises(
UserWarning,
msg=
("An invalid `base_url` for the Canvas API Instance was used."
"Please provide a valid HTTP or HTTPS URL if possible."),
)
def test_init_strips_extra_spaces_in_api_key(self, m):
client = Canvas(settings.BASE_URL, " 12345 ")
self.assertEqual(client._Canvas__requester.access_token, "12345")
def test_init_strips_extra_spaces_in_base_url(self, m):
client = Canvas(settings.BASE_URL_WITH_EXTRA_SPACES, "12345")
self.assertEqual(client._Canvas__requester.base_url,
settings.BASE_URL_WITH_VERSION)
# create_account()
def test_create_account(self, m):
register_uris({"account": ["create"]}, m)
name = "Newly Created Account"
account_dict = {"name": name}
account = self.canvas.create_account(account=account_dict)
self.assertIsInstance(account, Account)
self.assertTrue(hasattr(account, "name"))
self.assertEqual(account.name, name)
# get_account()
def test_get_account(self, m):
register_uris({"account": ["get_by_id"]}, m)
account_by_id = self.canvas.get_account(1)
self.assertIsInstance(account_by_id, Account)
account_by_obj = self.canvas.get_account(account_by_id)
self.assertIsInstance(account_by_obj, Account)
def test_get_account_sis_id(self, m):
register_uris({"account": ["get_by_sis_id"]}, m)
account = self.canvas.get_account("test-sis-id", use_sis_id=True)
self.assertIsInstance(account, Account)
self.assertEqual(account.name, "Account From SIS")
def test_get_account_fail(self, m):
register_uris({"generic": ["not_found"]}, m)
with self.assertRaises(ResourceDoesNotExist):
self.canvas.get_account(settings.INVALID_ID)
# get_accounts()
def test_get_accounts(self, m):
register_uris({"account": ["multiple"]}, m)
accounts = self.canvas.get_accounts()
account_list = [account for account in accounts]
self.assertEqual(len(account_list), 2)
# get_course_accounts()
def test_get_course_accounts(self, m):
register_uris({"account": ["multiple_course"]}, m)
accounts = self.canvas.get_course_accounts()
account_list = [account for account in accounts]
self.assertEqual(len(account_list), 2)
# get_brand_variables()
def test_get_brand_variables(self, m):
register_uris({"account": ["get_brand_variables"]}, m)
variables = self.canvas.get_brand_variables()
self.assertIsInstance(variables, dict)
# get_course()
def test_get_course(self, m):
register_uris({"course": ["get_by_id"]}, m)
course_by_id = self.canvas.get_course(1)
self.assertIsInstance(course_by_id, Course)
self.assertTrue(hasattr(course_by_id, "name"))
course_by_obj = self.canvas.get_course(course_by_id)
self.assertIsInstance(course_by_obj, Course)
self.assertTrue(hasattr(course_by_obj, "name"))
def test_get_course_sis_id(self, m):
register_uris({"course": ["get_by_sis_id"]}, m)
course = self.canvas.get_course("test-sis-id", use_sis_id=True)
self.assertIsInstance(course, Course)
self.assertEqual(course.name, "SIS Course")
def test_get_course_with_start_date(self, m):
register_uris({"course": ["start_at_date"]}, m)
course = self.canvas.get_course(2)
self.assertTrue(hasattr(course, "start_at"))
self.assertIsInstance(course.start_at, str)
self.assertTrue(hasattr(course, "start_at_date"))
self.assertIsInstance(course.start_at_date, datetime)
self.assertEqual(course.start_at_date.tzinfo, pytz.utc)
def test_get_course_non_unicode_char(self, m):
register_uris({"course": ["unicode_encode_error"]}, m)
course = self.canvas.get_course(3)
self.assertTrue(hasattr(course, "name"))
def test_get_course_fail(self, m):
register_uris({"generic": ["not_found"]}, m)
with self.assertRaises(ResourceDoesNotExist):
self.canvas.get_course(settings.INVALID_ID)
# get_user()
def test_get_user(self, m):
register_uris({"user": ["get_by_id"]}, m)
user_by_id = self.canvas.get_user(1)
self.assertIsInstance(user_by_id, User)
self.assertTrue(hasattr(user_by_id, "name"))
user_by_obj = self.canvas.get_user(user_by_id)
self.assertIsInstance(user_by_obj, User)
self.assertTrue(hasattr(user_by_obj, "name"))
def test_get_user_by_id_type(self, m):
register_uris({"user": ["get_by_id_type"]}, m)
user = self.canvas.get_user("jdoe", "sis_user_id")
self.assertIsInstance(user, User)
self.assertTrue(hasattr(user, "name"))
def test_get_user_self(self, m):
register_uris({"user": ["get_by_id_self"]}, m)
user = self.canvas.get_user("self")
self.assertIsInstance(user, User)
self.assertTrue(hasattr(user, "name"))
def test_get_user_fail(self, m):
register_uris({"generic": ["not_found"]}, m)
with self.assertRaises(ResourceDoesNotExist):
self.canvas.get_user(settings.INVALID_ID)
# get_courses()
def test_get_courses(self, m):
register_uris({"course": ["multiple", "multiple_page_2"]}, m)
courses = self.canvas.get_courses(per_page=1)
course_list = [course for course in courses]
self.assertEqual(len(course_list), 4)
self.assertIsInstance(course_list[0], Course)
# get_activity_stream_summary()
def test_get_activity_stream_summary(self, m):
register_uris({"user": ["activity_stream_summary"]}, m)
summary = self.canvas.get_activity_stream_summary()
self.assertIsInstance(summary, list)
# get_todo_items()
def test_get_todo_items(self, m):
register_uris({"user": ["todo_items"]}, m)
todo_items = self.canvas.get_todo_items()
self.assertIsInstance(todo_items, list)
# get_upcoming_events()
def test_get_upcoming_events(self, m):
register_uris({"user": ["upcoming_events"]}, m)
events = self.canvas.get_upcoming_events()
self.assertIsInstance(events, list)
# get_course_nicknames()
def test_get_course_nicknames(self, m):
register_uris(
{"user": ["course_nicknames", "course_nicknames_page_2"]}, m)
nicknames = self.canvas.get_course_nicknames()
nickname_list = [name for name in nicknames]
self.assertEqual(len(nickname_list), 4)
self.assertIsInstance(nickname_list[0], CourseNickname)
self.assertTrue(hasattr(nickname_list[0], "nickname"))
# get_course_nickname()
def test_get_course_nickname(self, m):
register_uris({
"course": ["get_by_id"],
"user": ["course_nickname"]
}, m)
nickname_by_id = self.canvas.get_course_nickname(1)
self.assertIsInstance(nickname_by_id, CourseNickname)
self.assertTrue(hasattr(nickname_by_id, "nickname"))
course_for_obj = self.canvas.get_course(1)
nickname_by_obj = self.canvas.get_course_nickname(course_for_obj)
self.assertIsInstance(nickname_by_obj, CourseNickname)
self.assertTrue(hasattr(nickname_by_obj, "nickname"))
def test_get_course_nickname_fail(self, m):
register_uris({"generic": ["not_found"]}, m)
with self.assertRaises(ResourceDoesNotExist):
self.canvas.get_course_nickname(settings.INVALID_ID)
# set_course_nickname()
def test_set_course_nickname(self, m):
register_uris(
{
"course": ["get_by_id"],
"user": ["course_nickname_set"]
}, m)
name = "New Course Nickname"
nickname_by_id = self.canvas.set_course_nickname(1, name)
self.assertIsInstance(nickname_by_id, CourseNickname)
self.assertTrue(hasattr(nickname_by_id, "nickname"))
self.assertEqual(nickname_by_id.nickname, name)
course_for_obj = self.canvas.get_course(1)
nickname_by_obj = self.canvas.set_course_nickname(course_for_obj, name)
self.assertIsInstance(nickname_by_obj, CourseNickname)
self.assertTrue(hasattr(nickname_by_obj, "nickname"))
# clear_course_nicknames()
def test_clear_course_nicknames(self, m):
register_uris({"user": ["course_nicknames_delete"]}, m)
success = self.canvas.clear_course_nicknames()
self.assertTrue(success)
# search_accounts()
def test_search_accounts(self, m):
register_uris({"account": ["domains"]}, m)
domains = self.canvas.search_accounts()
self.assertIsInstance(domains, list)
self.assertEqual(len(domains), 1)
self.assertIn("name", domains[0])
# get_section()
def test_get_section(self, m):
register_uris({"section": ["get_by_id"]}, m)
section_by_id = self.canvas.get_section(1)
self.assertIsInstance(section_by_id, Section)
section_by_obj = self.canvas.get_section(section_by_id)
self.assertIsInstance(section_by_obj, Section)
def test_get_section_sis_id(self, m):
register_uris({"section": ["get_by_sis_id"]}, m)
section = self.canvas.get_section("test-sis-id", use_sis_id=True)
self.assertIsInstance(section, Section)
self.assertEqual(section.name, "SIS Section")
# create_group()
def test_create_group(self, m):
register_uris({"group": ["create"]}, m)
group = self.canvas.create_group()
self.assertIsInstance(group, Group)
self.assertTrue(hasattr(group, "name"))
self.assertTrue(hasattr(group, "description"))
# get_group()
def test_get_group(self, m):
register_uris({"group": ["get_by_id"]}, m)
group_by_id = self.canvas.get_group(1)
self.assertIsInstance(group_by_id, Group)
self.assertTrue(hasattr(group_by_id, "name"))
self.assertTrue(hasattr(group_by_id, "description"))
group_by_obj = self.canvas.get_group(group_by_id)
self.assertIsInstance(group_by_obj, Group)
self.assertTrue(hasattr(group_by_obj, "name"))
self.assertTrue(hasattr(group_by_obj, "description"))
def test_get_group_sis_id(self, m):
register_uris({"group": ["get_by_sis_id"]}, m)
group = self.canvas.get_group("test-sis-id", use_sis_id=True)
self.assertIsInstance(group, Group)
self.assertEqual(group.name, "SIS Group")
# get_group_category()
def test_get_group_category(self, m):
register_uris({"group": ["get_category_by_id"]}, m)
group_category_by_id = self.canvas.get_group_category(1)
self.assertIsInstance(group_category_by_id, GroupCategory)
group_category_by_obj = self.canvas.get_group_category(
group_category_by_id)
self.assertIsInstance(group_category_by_obj, GroupCategory)
# create_conversation()
def test_create_conversation(self, m):
register_uris({"conversation": ["create_conversation"]}, m)
recipients = ["2"]
body = "Hello, World!"
conversations = self.canvas.create_conversation(recipients=recipients,
body=body)
self.assertIsInstance(conversations, list)
self.assertEqual(len(conversations), 1)
self.assertIsInstance(conversations[0], Conversation)
self.assertTrue(hasattr(conversations[0], "last_message"))
self.assertEqual(conversations[0].last_message, body)
def test_create_conversation_multiple_people(self, m):
register_uris({"conversation": ["create_conversation_multiple"]}, m)
recipients = ["2", "3"]
body = "Hey guys!"
conversations = self.canvas.create_conversation(recipients=recipients,
body=body)
self.assertIsInstance(conversations, list)
self.assertEqual(len(conversations), 2)
self.assertIsInstance(conversations[0], Conversation)
self.assertTrue(hasattr(conversations[0], "last_message"))
self.assertEqual(conversations[0].last_message, body)
self.assertIsInstance(conversations[1], Conversation)
self.assertTrue(hasattr(conversations[1], "last_message"))
self.assertEqual(conversations[1].last_message, body)
# get_conversation()
def test_get_conversation(self, m):
register_uris({"conversation": ["get_by_id"]}, m)
conversation_by_id = self.canvas.get_conversation(1)
self.assertIsInstance(conversation_by_id, Conversation)
self.assertTrue(hasattr(conversation_by_id, "subject"))
conversation_by_obj = self.canvas.get_conversation(conversation_by_id)
self.assertIsInstance(conversation_by_obj, Conversation)
self.assertTrue(hasattr(conversation_by_obj, "subject"))
# get_conversations()
def test_get_conversations(self, m):
requires = {
"conversation": ["get_conversations", "get_conversations_2"]
}
register_uris(requires, m)
convos = self.canvas.get_conversations()
conversation_list = [conversation for conversation in convos]
self.assertEqual(len(conversation_list), 4)
self.assertIsInstance(conversation_list[0], Conversation)
# mark_all_as_read()
def test_conversations_mark_all_as_read(self, m):
register_uris({"conversation": ["mark_all_as_read"]}, m)
result = self.canvas.conversations_mark_all_as_read()
self.assertTrue(result)
# unread_count()
def test_conversations_unread_count(self, m):
register_uris({"conversation": ["unread_count"]}, m)
result = self.canvas.conversations_unread_count()
self.assertEqual(result["unread_count"], "7")
# get_running_batches()
def test_conversations_get_running_batches(self, m):
register_uris({"conversation": ["get_running_batches"]}, m)
result = self.canvas.conversations_get_running_batches()
self.assertEqual(len(result), 2)
self.assertIn("body", result[0]["message"])
self.assertEqual(result[1]["message"]["author_id"], 1)
# batch_update()
def test_conversations_batch_update(self, m):
register_uris({"conversation": ["batch_update"]}, m)
conversation_ids = [1, 2]
this_event = "mark_as_read"
result = self.canvas.conversations_batch_update(
event=this_event, conversation_ids=conversation_ids)
self.assertIsInstance(result, Progress)
def test_conversations_batch_updated_fail_on_event(self, m):
conversation_ids = [1, 2]
this_event = "this doesn't work"
with self.assertRaises(ValueError):
self.canvas.conversations_batch_update(
event=this_event, conversation_ids=conversation_ids)
def test_conversations_batch_updated_fail_on_ids(self, m):
conversation_ids = [None] * 501
this_event = "mark_as_read"
with self.assertRaises(ValueError):
self.canvas.conversations_batch_update(
event=this_event, conversation_ids=conversation_ids)
# create_calendar_event()
def test_create_calendar_event(self, m):
register_uris({"calendar_event": ["create_calendar_event"]}, m)
cal_event = {"context_code": "course_123"}
evnt = self.canvas.create_calendar_event(calendar_event=cal_event)
self.assertIsInstance(evnt, CalendarEvent)
self.assertEqual(evnt.context_code, "course_123")
self.assertEqual(evnt.id, 234)
def test_create_calendar_event_fail(self, m):
with self.assertRaises(RequiredFieldMissing):
self.canvas.create_calendar_event({})
# get_calendar_events()
def test_get_calendar_events(self, m):
register_uris({"calendar_event": ["list_calendar_events"]}, m)
cal_events = self.canvas.get_calendar_events()
cal_event_list = [cal_event for cal_event in cal_events]
self.assertEqual(len(cal_event_list), 2)
# get_calendar_event()
def test_get_calendar_event(self, m):
register_uris({"calendar_event": ["get_calendar_event"]}, m)
calendar_event_by_id = self.canvas.get_calendar_event(567)
self.assertIsInstance(calendar_event_by_id, CalendarEvent)
self.assertEqual(calendar_event_by_id.title, "Test Event 3")
calendar_event_by_obj = self.canvas.get_calendar_event(
calendar_event_by_id)
self.assertIsInstance(calendar_event_by_obj, CalendarEvent)
self.assertEqual(calendar_event_by_obj.title, "Test Event 3")
# reserve_time_slot()
def test_reserve_time_slot(self, m):
register_uris({"calendar_event": ["reserve_time_slot"]}, m)
calendar_event_by_id = self.canvas.reserve_time_slot(
calendar_event=567)
self.assertIsInstance(calendar_event_by_id, CalendarEvent)
self.assertEqual(calendar_event_by_id.title, "Test Reservation")
calendar_event_by_obj = self.canvas.reserve_time_slot(
calendar_event=calendar_event_by_id)
self.assertIsInstance(calendar_event_by_obj, CalendarEvent)
self.assertEqual(calendar_event_by_obj.title, "Test Reservation")
def test_reserve_time_slot_by_participant_id(self, m):
register_uris({"calendar_event": ["reserve_time_slot_participant_id"]},
m)
cal_event = self.canvas.reserve_time_slot(calendar_event=567,
participant_id=777)
self.assertIsInstance(cal_event, CalendarEvent)
self.assertEqual(cal_event.title, "Test Reservation")
self.assertEqual(cal_event.user, 777)
# get_appointment_groups()
def test_get_appointment_groups(self, m):
register_uris({"appointment_group": ["list_appointment_groups"]}, m)
appt_groups = self.canvas.get_appointment_groups()
appt_groups_list = [appt_group for appt_group in appt_groups]
self.assertEqual(len(appt_groups_list), 2)
# get_appointment_group()
def test_get_appointment_group(self, m):
register_uris({"appointment_group": ["get_appointment_group"]}, m)
appointment_group_by_id = self.canvas.get_appointment_group(567)
self.assertIsInstance(appointment_group_by_id, AppointmentGroup)
self.assertEqual(appointment_group_by_id.title, "Test Group 3")
appointment_group_by_obj = self.canvas.get_appointment_group(
appointment_group_by_id)
self.assertIsInstance(appointment_group_by_obj, AppointmentGroup)
self.assertEqual(appointment_group_by_obj.title, "Test Group 3")
# create_appointment_group()
def test_create_appointment_group(self, m):
register_uris({"appointment_group": ["create_appointment_group"]}, m)
evnt = self.canvas.create_appointment_group({
"context_codes": ["course_123"],
"title":
"Test Group"
})
self.assertIsInstance(evnt, AppointmentGroup)
self.assertEqual(evnt.context_codes[0], "course_123")
self.assertEqual(evnt.id, 234)
def test_create_appointment_group_fail_on_context_codes(self, m):
with self.assertRaises(RequiredFieldMissing):
self.canvas.create_appointment_group({"title": "Test Group"})
def test_create_appointment_group_fail_on_title(self, m):
with self.assertRaises(RequiredFieldMissing):
self.canvas.create_appointment_group(
{"context_codes": "course_123"})
# get_user_participants()
def test_get_user_participants(self, m):
register_uris(
{
"appointment_group": [
"get_appointment_group_222",
"list_user_participants",
]
},
m,
)
users_by_id = self.canvas.get_user_participants(222)
users_get_by_id = [user for user in users_by_id]
self.assertEqual(len(users_get_by_id), 2)
appointment_group_for_obj = self.canvas.get_appointment_group(222)
users_by_id = self.canvas.get_user_participants(
appointment_group_for_obj)
users_get_by_id = [user for user in users_by_id]
self.assertEqual(len(users_get_by_id), 2)
# get_group_participants()
def test_get_group_participants(self, m):
register_uris(
{
"appointment_group": [
"get_appointment_group_222",
"list_group_participants",
]
},
m,
)
groups_by_id = self.canvas.get_group_participants(222)
groups_get_by_id = [group for group in groups_by_id]
self.assertEqual(len(groups_get_by_id), 2)
appointment_group_for_obj = self.canvas.get_appointment_group(222)
groups_by_obj = self.canvas.get_group_participants(
appointment_group_for_obj)
groups_get_by_obj = [group for group in groups_by_obj]
self.assertEqual(len(groups_get_by_obj), 2)
# get_file()
def test_get_file(self, m):
register_uris({"file": ["get_by_id"]}, m)
file_by_id = self.canvas.get_file(1)
self.assertIsInstance(file_by_id, File)
self.assertEqual(file_by_id.display_name, "File.docx")
self.assertEqual(file_by_id.size, 6144)
file_by_obj = self.canvas.get_file(file_by_id)
self.assertIsInstance(file_by_obj, File)
self.assertEqual(file_by_obj.display_name, "File.docx")
self.assertEqual(file_by_obj.size, 6144)
# search_recipients()
def test_search_recipients(self, m):
register_uris({"user": ["search_recipients"]}, m)
recipients = self.canvas.search_recipients()
self.assertIsInstance(recipients, list)
self.assertEqual(len(recipients), 2)
# search_all_courses()
def test_search_all_courses(self, m):
register_uris({"course": ["search_all_courses"]}, m)
courses = self.canvas.search_all_courses()
self.assertIsInstance(courses, list)
self.assertEqual(len(courses), 2)
# get_outcome()
def test_get_outcome(self, m):
register_uris({"outcome": ["canvas_get_outcome"]}, m)
outcome_group_by_id = self.canvas.get_outcome(3)
self.assertIsInstance(outcome_group_by_id, Outcome)
self.assertEqual(outcome_group_by_id.id, 3)
self.assertEqual(outcome_group_by_id.title, "Outcome Show Example")
outcome_group_by_obj = self.canvas.get_outcome(outcome_group_by_id)
self.assertIsInstance(outcome_group_by_obj, Outcome)
self.assertEqual(outcome_group_by_obj.id, 3)
self.assertEqual(outcome_group_by_obj.title, "Outcome Show Example")
# get_root_outcome_group()
def test_get_root_outcome_group(self, m):
register_uris({"outcome": ["canvas_root_outcome_group"]}, m)
outcome_group = self.canvas.get_root_outcome_group()
self.assertIsInstance(outcome_group, OutcomeGroup)
self.assertEqual(outcome_group.id, 1)
self.assertEqual(outcome_group.title, "ROOT")
# get_outcome_group()
def test_get_outcome_group(self, m):
register_uris({"outcome": ["canvas_get_outcome_group"]}, m)
outcome_group_by_id = self.canvas.get_outcome_group(1)
self.assertIsInstance(outcome_group_by_id, OutcomeGroup)
self.assertEqual(outcome_group_by_id.id, 1)
self.assertEqual(outcome_group_by_id.title,
"Canvas outcome group title")
outcome_group_by_obj = self.canvas.get_outcome_group(
outcome_group_by_id)
self.assertIsInstance(outcome_group_by_obj, OutcomeGroup)
self.assertEqual(outcome_group_by_obj.id, 1)
self.assertEqual(outcome_group_by_obj.title,
"Canvas outcome group title")
# get_progress()
def test_get_progress(self, m):
register_uris({"content_migration": ["get_progress"]}, m)
progress = self.canvas.get_progress(1)
self.assertIsInstance(progress, Progress)
self.assertTrue(hasattr(progress, "id"))
self.assertEqual(progress.id, 1)
# get_announcements()
def test_get_announcements(self, m):
register_uris({"announcements": ["list_announcements"]}, m)
announcements = self.canvas.get_announcements()
announcement_list = [announcement for announcement in announcements]
self.assertIsInstance(announcements, PaginatedList)
self.assertIsInstance(announcement_list[0], DiscussionTopic)
self.assertEqual(len(announcement_list), 2)
# get_epub_exports()
def test_get_epub_exports(self, m):
register_uris({"course": ["get_epub_exports"]}, m)
epub_export_list = self.canvas.get_epub_exports()
self.assertIsInstance(epub_export_list, PaginatedList)
self.assertIsInstance(epub_export_list[0], CourseEpubExport)
self.assertIsInstance(epub_export_list[1], CourseEpubExport)
self.assertEqual(epub_export_list[0].id, 1)
self.assertEqual(epub_export_list[1].id, 2)
self.assertEqual(epub_export_list[0].name, "course1")
self.assertEqual(epub_export_list[1].name, "course2")
self.assertTrue(hasattr(epub_export_list[0], "epub_export"))
self.assertTrue(hasattr(epub_export_list[1], "epub_export"))
epub1 = epub_export_list[0].epub_export
epub2 = epub_export_list[1].epub_export
self.assertEqual(epub1["id"], 1)
self.assertEqual(epub2["id"], 2)
self.assertEqual(epub1["workflow_state"], "exported")
self.assertEqual(epub2["workflow_state"], "exported")
# comm_messages()
def test_get_comm_messages(self, m):
register_uris({"comm_message": ["comm_messages"]}, m)
comm_messages = self.canvas.get_comm_messages(2)
self.assertIsInstance(comm_messages, PaginatedList)
self.assertIsInstance(comm_messages[0], CommMessage)
self.assertIsInstance(comm_messages[1], CommMessage)
self.assertTrue(hasattr(comm_messages[0], "id"))
self.assertTrue(hasattr(comm_messages[1], "body"))
self.assertEqual(comm_messages[0].id, 42)
self.assertEqual(comm_messages[0].subject, "example subject line")
self.assertEqual(comm_messages[1].id, 2)
self.assertEqual(comm_messages[1].subject, "My Subject")
def test_graphql(self, m):
register_uris({"graphql": ["graphql"]},
m,
base_url=settings.BASE_URL_GRAPHQL)
query = """
query MyQuery($termid: ID!) {
term(id: $termid) {
coursesConnection {
nodes {
_id
assignmentsConnection {
nodes {
name
_id
expectsExternalSubmission
}
}
}
edges {
node {
id
}
}
}
}
}
"""
variables = {"termid": 125}
graphql_response = self.canvas.graphql(query=query,
variables=variables)
# Just a super simple check right now that it gets back a dict respose
self.assertIsInstance(graphql_response, dict)
class Canvas_Calendar:
def __init__(self, api_key):
self.API_URL = "https://asu.instructure.com"
self.canvas = Canvas(self.API_URL, api_key)
def getallevents(self, id):
courses_array = ['course_' + str(id)]
resultant_json_format = {"events": [], "assignments": []}
course_events = self.canvas.get_calendar_events(
all_events=1, type='event', context_codes=courses_array)
course_assignments = self.canvas.get_calendar_events(
all_events=1, type='assignment', context_codes=courses_array)
for event in course_events:
temp = {
key: event.__dict__['attributes'][key]
for key in ['id', 'title', 'start_at', 'end_at']
}
resultant_json_format["events"].append(temp)
for assignment in course_assignments:
temp = {
key: assignment.__dict__['assignment'][key]
for key in ['id', 'name', 'due_at']
}
resultant_json_format["assignments"].append(temp)
return resultant_json_format
def create_event(self, array_of_objects):
counter = 0
for objects in array_of_objects:
event_dict = objects
if self.canvas.create_calendar_event(calendar_event=event_dict):
counter += 1
if counter == len(array_of_objects):
return "success"
else:
return "failure"
def delete_event(self, array_ids):
counter = 0
for ids in array_ids:
event = self.canvas.get_calendar_event(ids)
if event.delete():
counter += 1
if counter == len(array_ids):
return "success"
else:
return "failure"
def edit_event(self, array_of_objects):
counter = 0
for objects in array_of_objects:
event = self.canvas.get_calendar_event(objects['id'])
event_dict = objects
if event.edit(calendar_event=event_dict):
counter += 1
if counter == len(array_of_objects):
return "success"
else:
return "failure"
def edit_assignment(self, array_of_objects, course_id):
counter = 0
course = self.canvas.get_course(course_id)
for objects in array_of_objects:
assignment = course.get_assignment(objects['id'])
assignment_dict = objects
if assignment.edit(assignment=assignment_dict):
counter += 1
if counter == len(array_of_objects):
return "success"
else:
return "failure"
def delete_assignment(self, array_ids, course_id):
counter = 0
course = self.canvas.get_course(course_id)
for ids in array_ids:
assignment = course.get_assignment(ids)
if assignment.delete():
counter += 1
if counter == len(array_ids):
return "success"
else:
return "failure"
class TestCanvas(unittest.TestCase):
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
# Canvas()
def test_init_deprecate_url_contains_version(self, m):
with warnings.catch_warnings(record=True) as w:
Canvas(settings.BASE_URL_WITH_VERSION, settings.API_KEY)
self.assertTrue(issubclass(w[0].category, DeprecationWarning))
# Canvas()
def test_init_warns_when_url_is_http(self, m):
with warnings.catch_warnings(record=True) as w:
Canvas(settings.BASE_URL_AS_HTTP, settings.API_KEY)
self.assertTrue(issubclass(w[0].category, UserWarning))
# create_account()
def test_create_account(self, m):
register_uris({'account': ['create']}, m)
name = 'Newly Created Account'
account_dict = {'name': name}
account = self.canvas.create_account(account=account_dict)
self.assertIsInstance(account, Account)
self.assertTrue(hasattr(account, 'name'))
self.assertEqual(account.name, name)
# get_account()
def test_get_account(self, m):
register_uris({'account': ['get_by_id']}, m)
account_by_id = self.canvas.get_account(1)
self.assertIsInstance(account_by_id, Account)
account_by_obj = self.canvas.get_account(account_by_id)
self.assertIsInstance(account_by_obj, Account)
def test_get_account_sis_id(self, m):
register_uris({'account': ['get_by_sis_id']}, m)
account = self.canvas.get_account('test-sis-id', use_sis_id=True)
self.assertIsInstance(account, Account)
self.assertEqual(account.name, 'Account From SIS')
def test_get_account_fail(self, m):
register_uris({'generic': ['not_found']}, m)
with self.assertRaises(ResourceDoesNotExist):
self.canvas.get_account(settings.INVALID_ID)
# get_accounts()
def test_get_accounts(self, m):
register_uris({'account': ['multiple']}, m)
accounts = self.canvas.get_accounts()
account_list = [account for account in accounts]
self.assertEqual(len(account_list), 2)
# get_course_accounts()
def test_get_course_accounts(self, m):
register_uris({'account': ['multiple_course']}, m)
accounts = self.canvas.get_course_accounts()
account_list = [account for account in accounts]
self.assertEqual(len(account_list), 2)
# get_course()
def test_get_course(self, m):
register_uris({'course': ['get_by_id']}, m)
course_by_id = self.canvas.get_course(1)
self.assertIsInstance(course_by_id, Course)
self.assertTrue(hasattr(course_by_id, 'name'))
course_by_obj = self.canvas.get_course(course_by_id)
self.assertIsInstance(course_by_obj, Course)
self.assertTrue(hasattr(course_by_obj, 'name'))
def test_get_course_sis_id(self, m):
register_uris({'course': ['get_by_sis_id']}, m)
course = self.canvas.get_course('test-sis-id', use_sis_id=True)
self.assertIsInstance(course, Course)
self.assertEqual(course.name, 'SIS Course')
def test_get_course_with_start_date(self, m):
register_uris({'course': ['start_at_date']}, m)
course = self.canvas.get_course(2)
self.assertTrue(hasattr(course, 'start_at'))
self.assertIsInstance(course.start_at, text_type)
self.assertTrue(hasattr(course, 'start_at_date'))
self.assertIsInstance(course.start_at_date, datetime)
self.assertEqual(course.start_at_date.tzinfo, pytz.utc)
def test_get_course_non_unicode_char(self, m):
register_uris({'course': ['unicode_encode_error']}, m)
course = self.canvas.get_course(3)
self.assertTrue(hasattr(course, 'name'))
def test_get_course_fail(self, m):
register_uris({'generic': ['not_found']}, m)
with self.assertRaises(ResourceDoesNotExist):
self.canvas.get_course(settings.INVALID_ID)
# get_user()
def test_get_user(self, m):
register_uris({'user': ['get_by_id']}, m)
user_by_id = self.canvas.get_user(1)
self.assertIsInstance(user_by_id, User)
self.assertTrue(hasattr(user_by_id, 'name'))
user_by_obj = self.canvas.get_user(user_by_id)
self.assertIsInstance(user_by_obj, User)
self.assertTrue(hasattr(user_by_obj, 'name'))
def test_get_user_by_id_type(self, m):
register_uris({'user': ['get_by_id_type']}, m)
user = self.canvas.get_user('jdoe', 'sis_user_id')
self.assertIsInstance(user, User)
self.assertTrue(hasattr(user, 'name'))
def test_get_user_self(self, m):
register_uris({'user': ['get_by_id_self']}, m)
user = self.canvas.get_user('self')
self.assertIsInstance(user, User)
self.assertTrue(hasattr(user, 'name'))
def test_get_user_fail(self, m):
register_uris({'generic': ['not_found']}, m)
with self.assertRaises(ResourceDoesNotExist):
self.canvas.get_user(settings.INVALID_ID)
# get_courses()
def test_get_courses(self, m):
register_uris({'course': ['multiple', 'multiple_page_2']}, m)
courses = self.canvas.get_courses(per_page=1)
course_list = [course for course in courses]
self.assertEqual(len(course_list), 4)
self.assertIsInstance(course_list[0], Course)
# get_activity_stream_summary()
def test_get_activity_stream_summary(self, m):
register_uris({'user': ['activity_stream_summary']}, m)
summary = self.canvas.get_activity_stream_summary()
self.assertIsInstance(summary, list)
# get_todo_items()
def test_get_todo_items(self, m):
register_uris({'user': ['todo_items']}, m)
todo_items = self.canvas.get_todo_items()
self.assertIsInstance(todo_items, list)
# get_upcoming_events()
def test_get_upcoming_events(self, m):
register_uris({'user': ['upcoming_events']}, m)
events = self.canvas.get_upcoming_events()
self.assertIsInstance(events, list)
# get_course_nicknames()
def test_get_course_nicknames(self, m):
register_uris(
{'user': ['course_nicknames', 'course_nicknames_page_2']}, m)
nicknames = self.canvas.get_course_nicknames()
nickname_list = [name for name in nicknames]
self.assertEqual(len(nickname_list), 4)
self.assertIsInstance(nickname_list[0], CourseNickname)
self.assertTrue(hasattr(nickname_list[0], 'nickname'))
# get_course_nickname()
def test_get_course_nickname(self, m):
register_uris({
'course': ['get_by_id'],
'user': ['course_nickname']
}, m)
nickname_by_id = self.canvas.get_course_nickname(1)
self.assertIsInstance(nickname_by_id, CourseNickname)
self.assertTrue(hasattr(nickname_by_id, 'nickname'))
course_for_obj = self.canvas.get_course(1)
nickname_by_obj = self.canvas.get_course_nickname(course_for_obj)
self.assertIsInstance(nickname_by_obj, CourseNickname)
self.assertTrue(hasattr(nickname_by_obj, 'nickname'))
def test_get_course_nickname_fail(self, m):
register_uris({'generic': ['not_found']}, m)
with self.assertRaises(ResourceDoesNotExist):
self.canvas.get_course_nickname(settings.INVALID_ID)
# set_course_nickname()
def test_set_course_nickname(self, m):
register_uris(
{
'course': ['get_by_id'],
'user': ['course_nickname_set']
}, m)
name = 'New Course Nickname'
nickname_by_id = self.canvas.set_course_nickname(1, name)
self.assertIsInstance(nickname_by_id, CourseNickname)
self.assertTrue(hasattr(nickname_by_id, 'nickname'))
self.assertEqual(nickname_by_id.nickname, name)
course_for_obj = self.canvas.get_course(1)
nickname_by_obj = self.canvas.set_course_nickname(course_for_obj, name)
self.assertIsInstance(nickname_by_obj, CourseNickname)
self.assertTrue(hasattr(nickname_by_obj, 'nickname'))
# clear_course_nicknames()
def test_clear_course_nicknames(self, m):
register_uris({'user': ['course_nicknames_delete']}, m)
success = self.canvas.clear_course_nicknames()
self.assertTrue(success)
# search_accounts()
def test_search_accounts(self, m):
register_uris({'account': ['domains']}, m)
domains = self.canvas.search_accounts()
self.assertIsInstance(domains, list)
self.assertEqual(len(domains), 1)
self.assertIn('name', domains[0])
# get_section()
def test_get_section(self, m):
register_uris({'section': ['get_by_id']}, m)
section_by_id = self.canvas.get_section(1)
self.assertIsInstance(section_by_id, Section)
section_by_obj = self.canvas.get_section(section_by_id)
self.assertIsInstance(section_by_obj, Section)
def test_get_section_sis_id(self, m):
register_uris({'section': ['get_by_sis_id']}, m)
section = self.canvas.get_section('test-sis-id', use_sis_id=True)
self.assertIsInstance(section, Section)
self.assertEqual(section.name, 'SIS Section')
# create_group()
def test_create_group(self, m):
register_uris({'group': ['create']}, m)
group = self.canvas.create_group()
self.assertIsInstance(group, Group)
self.assertTrue(hasattr(group, 'name'))
self.assertTrue(hasattr(group, 'description'))
# get_group()
def test_get_group(self, m):
register_uris({'group': ['get_by_id']}, m)
group_by_id = self.canvas.get_group(1)
self.assertIsInstance(group_by_id, Group)
self.assertTrue(hasattr(group_by_id, 'name'))
self.assertTrue(hasattr(group_by_id, 'description'))
group_by_obj = self.canvas.get_group(group_by_id)
self.assertIsInstance(group_by_obj, Group)
self.assertTrue(hasattr(group_by_obj, 'name'))
self.assertTrue(hasattr(group_by_obj, 'description'))
def test_get_group_sis_id(self, m):
register_uris({'group': ['get_by_sis_id']}, m)
group = self.canvas.get_group('test-sis-id', use_sis_id=True)
self.assertIsInstance(group, Group)
self.assertEqual(group.name, 'SIS Group')
# get_group_category()
def test_get_group_category(self, m):
register_uris({'group': ['get_category_by_id']}, m)
group_category_by_id = self.canvas.get_group_category(1)
self.assertIsInstance(group_category_by_id, GroupCategory)
group_category_by_obj = self.canvas.get_group_category(
group_category_by_id)
self.assertIsInstance(group_category_by_obj, GroupCategory)
# create_conversation()
def test_create_conversation(self, m):
register_uris({'conversation': ['create_conversation']}, m)
recipients = ['2']
body = 'Hello, World!'
conversations = self.canvas.create_conversation(recipients=recipients,
body=body)
self.assertIsInstance(conversations, list)
self.assertEqual(len(conversations), 1)
self.assertIsInstance(conversations[0], Conversation)
self.assertTrue(hasattr(conversations[0], 'last_message'))
self.assertEqual(conversations[0].last_message, body)
def test_create_conversation_multiple_people(self, m):
register_uris({'conversation': ['create_conversation_multiple']}, m)
recipients = ['2', '3']
body = 'Hey guys!'
conversations = self.canvas.create_conversation(recipients=recipients,
body=body)
self.assertIsInstance(conversations, list)
self.assertEqual(len(conversations), 2)
self.assertIsInstance(conversations[0], Conversation)
self.assertTrue(hasattr(conversations[0], 'last_message'))
self.assertEqual(conversations[0].last_message, body)
self.assertIsInstance(conversations[1], Conversation)
self.assertTrue(hasattr(conversations[1], 'last_message'))
self.assertEqual(conversations[1].last_message, body)
# get_conversation()
def test_get_conversation(self, m):
register_uris({'conversation': ['get_by_id']}, m)
conversation_by_id = self.canvas.get_conversation(1)
self.assertIsInstance(conversation_by_id, Conversation)
self.assertTrue(hasattr(conversation_by_id, 'subject'))
conversation_by_obj = self.canvas.get_conversation(conversation_by_id)
self.assertIsInstance(conversation_by_obj, Conversation)
self.assertTrue(hasattr(conversation_by_obj, 'subject'))
# get_conversations()
def test_get_conversations(self, m):
requires = {
'conversation': ['get_conversations', 'get_conversations_2']
}
register_uris(requires, m)
convos = self.canvas.get_conversations()
conversation_list = [conversation for conversation in convos]
self.assertEqual(len(conversation_list), 4)
self.assertIsInstance(conversation_list[0], Conversation)
# mark_all_as_read()
def test_conversations_mark_all_as_read(self, m):
register_uris({'conversation': ['mark_all_as_read']}, m)
result = self.canvas.conversations_mark_all_as_read()
self.assertTrue(result)
# unread_count()
def test_conversations_unread_count(self, m):
register_uris({'conversation': ['unread_count']}, m)
result = self.canvas.conversations_unread_count()
self.assertEqual(result['unread_count'], "7")
# get_running_batches()
def test_conversations_get_running_batches(self, m):
register_uris({'conversation': ['get_running_batches']}, m)
result = self.canvas.conversations_get_running_batches()
self.assertEqual(len(result), 2)
self.assertIn('body', result[0]['message'])
self.assertEqual(result[1]['message']['author_id'], 1)
# batch_update()
def test_conversations_batch_update(self, m):
register_uris({'conversation': ['batch_update']}, m)
conversation_ids = [1, 2]
this_event = "mark_as_read"
result = self.canvas.conversations_batch_update(
event=this_event, conversation_ids=conversation_ids)
self.assertIsInstance(result, Progress)
def test_conversations_batch_updated_fail_on_event(self, m):
conversation_ids = [1, 2]
this_event = "this doesn't work"
result = self.canvas.conversations_batch_update(
event=this_event, conversation_ids=conversation_ids)
self.assertIsInstance(result, ValueError)
def test_conversations_batch_updated_fail_on_ids(self, m):
conversation_ids = [None] * 501
this_event = "mark_as_read"
result = self.canvas.conversations_batch_update(
event=this_event, conversation_ids=conversation_ids)
self.assertIsInstance(result, ValueError)
# create_calendar_event()
def test_create_calendar_event(self, m):
register_uris({'calendar_event': ['create_calendar_event']}, m)
cal_event = {"context_code": "course_123"}
evnt = self.canvas.create_calendar_event(calendar_event=cal_event)
self.assertIsInstance(evnt, CalendarEvent)
self.assertEqual(evnt.context_code, "course_123")
self.assertEqual(evnt.id, 234)
def test_create_calendar_event_fail(self, m):
with self.assertRaises(RequiredFieldMissing):
self.canvas.create_calendar_event({})
# list_calendar_events()
def test_list_calendar_events(self, m):
register_uris({'calendar_event': ['list_calendar_events']}, m)
with warnings.catch_warnings(record=True) as warning_list:
cal_events = self.canvas.list_calendar_events()
cal_event_list = [cal_event for cal_event in cal_events]
self.assertEqual(len(cal_event_list), 2)
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
# get_calendar_events()
def test_get_calendar_events(self, m):
register_uris({'calendar_event': ['list_calendar_events']}, m)
cal_events = self.canvas.get_calendar_events()
cal_event_list = [cal_event for cal_event in cal_events]
self.assertEqual(len(cal_event_list), 2)
# get_calendar_event()
def test_get_calendar_event(self, m):
register_uris({'calendar_event': ['get_calendar_event']}, m)
calendar_event_by_id = self.canvas.get_calendar_event(567)
self.assertIsInstance(calendar_event_by_id, CalendarEvent)
self.assertEqual(calendar_event_by_id.title, "Test Event 3")
calendar_event_by_obj = self.canvas.get_calendar_event(
calendar_event_by_id)
self.assertIsInstance(calendar_event_by_obj, CalendarEvent)
self.assertEqual(calendar_event_by_obj.title, "Test Event 3")
# reserve_time_slot()
def test_reserve_time_slot(self, m):
register_uris({'calendar_event': ['reserve_time_slot']}, m)
calendar_event_by_id = self.canvas.reserve_time_slot(
calendar_event=567)
self.assertIsInstance(calendar_event_by_id, CalendarEvent)
self.assertEqual(calendar_event_by_id.title, "Test Reservation")
calendar_event_by_obj = self.canvas.reserve_time_slot(
calendar_event=calendar_event_by_id)
self.assertIsInstance(calendar_event_by_obj, CalendarEvent)
self.assertEqual(calendar_event_by_obj.title, "Test Reservation")
def test_reserve_time_slot_by_participant_id(self, m):
register_uris({'calendar_event': ['reserve_time_slot_participant_id']},
m)
cal_event = self.canvas.reserve_time_slot(calendar_event=567,
participant_id=777)
self.assertIsInstance(cal_event, CalendarEvent)
self.assertEqual(cal_event.title, "Test Reservation")
self.assertEqual(cal_event.user, 777)
# list_appointment_groups()
def test_list_appointment_groups(self, m):
register_uris({'appointment_group': ['list_appointment_groups']}, m)
with warnings.catch_warnings(record=True) as warning_list:
appt_groups = self.canvas.list_appointment_groups()
appt_groups_list = [appt_group for appt_group in appt_groups]
self.assertEqual(len(appt_groups_list), 2)
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
# get_appointment_groups()
def test_get_appointment_groups(self, m):
register_uris({'appointment_group': ['list_appointment_groups']}, m)
appt_groups = self.canvas.get_appointment_groups()
appt_groups_list = [appt_group for appt_group in appt_groups]
self.assertEqual(len(appt_groups_list), 2)
# get_appointment_group()
def test_get_appointment_group(self, m):
register_uris({'appointment_group': ['get_appointment_group']}, m)
appointment_group_by_id = self.canvas.get_appointment_group(567)
self.assertIsInstance(appointment_group_by_id, AppointmentGroup)
self.assertEqual(appointment_group_by_id.title, "Test Group 3")
appointment_group_by_obj = self.canvas.get_appointment_group(
appointment_group_by_id)
self.assertIsInstance(appointment_group_by_obj, AppointmentGroup)
self.assertEqual(appointment_group_by_obj.title, "Test Group 3")
# create_appointment_group()
def test_create_appointment_group(self, m):
register_uris({'appointment_group': ['create_appointment_group']}, m)
evnt = self.canvas.create_appointment_group({
"context_codes": ["course_123"],
"title":
"Test Group"
})
self.assertIsInstance(evnt, AppointmentGroup)
self.assertEqual(evnt.context_codes[0], "course_123")
self.assertEqual(evnt.id, 234)
def test_create_appointment_group_fail_on_context_codes(self, m):
with self.assertRaises(RequiredFieldMissing):
self.canvas.create_appointment_group({"title": "Test Group"})
def test_create_appointment_group_fail_on_title(self, m):
with self.assertRaises(RequiredFieldMissing):
self.canvas.create_appointment_group(
{"context_codes": "course_123"})
# list_user_participants()
def test_list_user_participants(self, m):
register_uris(
{
'appointment_group':
['get_appointment_group_222', 'list_user_participants']
}, m)
with warnings.catch_warnings(record=True) as warning_list:
users_by_id = self.canvas.list_user_participants(222)
users_list_by_id = [user for user in users_by_id]
self.assertEqual(len(users_list_by_id), 2)
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
with warnings.catch_warnings(record=True) as warning_list:
appointment_group_for_obj = self.canvas.get_appointment_group(222)
users_by_id = self.canvas.list_user_participants(
appointment_group_for_obj)
users_list_by_id = [user for user in users_by_id]
self.assertEqual(len(users_list_by_id), 2)
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
# get_user_participants()
def test_get_user_participants(self, m):
register_uris(
{
'appointment_group':
['get_appointment_group_222', 'list_user_participants']
}, m)
users_by_id = self.canvas.get_user_participants(222)
users_get_by_id = [user for user in users_by_id]
self.assertEqual(len(users_get_by_id), 2)
appointment_group_for_obj = self.canvas.get_appointment_group(222)
users_by_id = self.canvas.get_user_participants(
appointment_group_for_obj)
users_get_by_id = [user for user in users_by_id]
self.assertEqual(len(users_get_by_id), 2)
# list_group_participants()
def test_list_group_participants(self, m):
register_uris(
{
'appointment_group':
['get_appointment_group_222', 'list_group_participants']
}, m)
with warnings.catch_warnings(record=True) as warning_list:
groups_by_id = self.canvas.list_group_participants(222)
groups_list_by_id = [group for group in groups_by_id]
self.assertEqual(len(groups_list_by_id), 2)
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
with warnings.catch_warnings(record=True) as warning_list:
appointment_group_for_obj = self.canvas.get_appointment_group(222)
groups_by_obj = self.canvas.list_group_participants(
appointment_group_for_obj)
groups_list_by_obj = [group for group in groups_by_obj]
self.assertEqual(len(groups_list_by_obj), 2)
self.assertEqual(len(warning_list), 1)
self.assertEqual(warning_list[-1].category, DeprecationWarning)
# get_group_participants()
def test_get_group_participants(self, m):
register_uris(
{
'appointment_group':
['get_appointment_group_222', 'list_group_participants']
}, m)
groups_by_id = self.canvas.get_group_participants(222)
groups_get_by_id = [group for group in groups_by_id]
self.assertEqual(len(groups_get_by_id), 2)
appointment_group_for_obj = self.canvas.get_appointment_group(222)
groups_by_obj = self.canvas.get_group_participants(
appointment_group_for_obj)
groups_get_by_obj = [group for group in groups_by_obj]
self.assertEqual(len(groups_get_by_obj), 2)
# get_file()
def test_get_file(self, m):
register_uris({'file': ['get_by_id']}, m)
file_by_id = self.canvas.get_file(1)
self.assertIsInstance(file_by_id, File)
self.assertEqual(file_by_id.display_name, "File.docx")
self.assertEqual(file_by_id.size, 6144)
file_by_obj = self.canvas.get_file(file_by_id)
self.assertIsInstance(file_by_obj, File)
self.assertEqual(file_by_obj.display_name, "File.docx")
self.assertEqual(file_by_obj.size, 6144)
# search_recipients()
def test_search_recipients(self, m):
register_uris({'user': ['search_recipients']}, m)
recipients = self.canvas.search_recipients()
self.assertIsInstance(recipients, list)
self.assertEqual(len(recipients), 2)
# search_all_courses()
def test_search_all_courses(self, m):
register_uris({'course': ['search_all_courses']}, m)
courses = self.canvas.search_all_courses()
self.assertIsInstance(courses, list)
self.assertEqual(len(courses), 2)
# get_outcome()
def test_get_outcome(self, m):
register_uris({'outcome': ['canvas_get_outcome']}, m)
outcome_group_by_id = self.canvas.get_outcome(3)
self.assertIsInstance(outcome_group_by_id, Outcome)
self.assertEqual(outcome_group_by_id.id, 3)
self.assertEqual(outcome_group_by_id.title, "Outcome Show Example")
outcome_group_by_obj = self.canvas.get_outcome(outcome_group_by_id)
self.assertIsInstance(outcome_group_by_obj, Outcome)
self.assertEqual(outcome_group_by_obj.id, 3)
self.assertEqual(outcome_group_by_obj.title, "Outcome Show Example")
# get_root_outcome_group()
def test_get_root_outcome_group(self, m):
register_uris({'outcome': ['canvas_root_outcome_group']}, m)
outcome_group = self.canvas.get_root_outcome_group()
self.assertIsInstance(outcome_group, OutcomeGroup)
self.assertEqual(outcome_group.id, 1)
self.assertEqual(outcome_group.title, "ROOT")
# get_outcome_group()
def test_get_outcome_group(self, m):
register_uris({'outcome': ['canvas_get_outcome_group']}, m)
outcome_group_by_id = self.canvas.get_outcome_group(1)
self.assertIsInstance(outcome_group_by_id, OutcomeGroup)
self.assertEqual(outcome_group_by_id.id, 1)
self.assertEqual(outcome_group_by_id.title,
"Canvas outcome group title")
outcome_group_by_obj = self.canvas.get_outcome_group(
outcome_group_by_id)
self.assertIsInstance(outcome_group_by_obj, OutcomeGroup)
self.assertEqual(outcome_group_by_obj.id, 1)
self.assertEqual(outcome_group_by_obj.title,
"Canvas outcome group title")
# get_progress()
def test_get_progress(self, m):
register_uris({'content_migration': ['get_progress']}, m)
progress = self.canvas.get_progress(1)
self.assertIsInstance(progress, Progress)
self.assertTrue(hasattr(progress, 'id'))
self.assertEqual(progress.id, 1)
# get_announcements()
def test_get_announcements(self, m):
register_uris({'announcements': ['list_announcements']}, m)
announcements = self.canvas.get_announcements()
announcement_list = [announcement for announcement in announcements]
self.assertIsInstance(announcements, PaginatedList)
self.assertIsInstance(announcement_list[0], DiscussionTopic)
self.assertEqual(len(announcement_list), 2)
class TestCanvas(unittest.TestCase):
@classmethod
def setUp(self):
self.canvas = Canvas(settings.BASE_URL, settings.API_KEY)
# create_account()
def test_create_account(self, m):
register_uris({'account': ['create']}, m)
name = 'Newly Created Account'
account_dict = {'name': name}
account = self.canvas.create_account(account=account_dict)
self.assertIsInstance(account, Account)
self.assertTrue(hasattr(account, 'name'))
self.assertEqual(account.name, name)
# get_account()
def test_get_account(self, m):
register_uris({'account': ['get_by_id']}, m)
account = self.canvas.get_account(1)
self.assertIsInstance(account, Account)
def test_get_account_fail(self, m):
register_uris({'generic': ['not_found']}, m)
with self.assertRaises(ResourceDoesNotExist):
self.canvas.get_account(settings.INVALID_ID)
# get_accounts()
def test_get_accounts(self, m):
register_uris({'account': ['multiple']}, m)
accounts = self.canvas.get_accounts()
account_list = [account for account in accounts]
self.assertEqual(len(account_list), 2)
# get_course_accounts()
def test_get_course_accounts(self, m):
register_uris({'account': ['multiple_course']}, m)
accounts = self.canvas.get_course_accounts()
account_list = [account for account in accounts]
self.assertEqual(len(account_list), 2)
# get_course()
def test_get_course(self, m):
register_uris({'course': ['get_by_id']}, m)
course = self.canvas.get_course(1)
self.assertIsInstance(course, Course)
self.assertTrue(hasattr(course, 'name'))
def test_get_course_with_start_date(self, m):
register_uris({'course': ['start_at_date']}, m)
course = self.canvas.get_course(2)
self.assertTrue(hasattr(course, 'start_at'))
self.assertIsInstance(course.start_at, (str, unicode))
self.assertTrue(hasattr(course, 'start_at_date'))
self.assertIsInstance(course.start_at_date, datetime)
def test_get_course_non_unicode_char(self, m):
register_uris({'course': ['unicode_encode_error']}, m)
course = self.canvas.get_course(3)
self.assertTrue(hasattr(course, 'name'))
def test_get_course_fail(self, m):
register_uris({'generic': ['not_found']}, m)
with self.assertRaises(ResourceDoesNotExist):
self.canvas.get_course(settings.INVALID_ID)
# get_user()
def test_get_user(self, m):
register_uris({'user': ['get_by_id']}, m)
user = self.canvas.get_user(1)
self.assertIsInstance(user, User)
self.assertTrue(hasattr(user, 'name'))
def test_get_user_by_id_type(self, m):
register_uris({'user': ['get_by_id_type']}, m)
user = self.canvas.get_user('jdoe', 'sis_user_id')
self.assertIsInstance(user, User)
self.assertTrue(hasattr(user, 'name'))
def test_get_user_fail(self, m):
register_uris({'generic': ['not_found']}, m)
with self.assertRaises(ResourceDoesNotExist):
self.canvas.get_user(settings.INVALID_ID)
# get_courses()
def test_get_courses(self, m):
register_uris({'course': ['multiple', 'multiple_page_2']}, m)
courses = self.canvas.get_courses(per_page=1)
course_list = [course for course in courses]
self.assertEqual(len(course_list), 4)
self.assertIsInstance(course_list[0], Course)
# get_activity_stream_summary()
def test_get_activity_stream_summary(self, m):
register_uris({'user': ['activity_stream_summary']}, m)
summary = self.canvas.get_activity_stream_summary()
self.assertIsInstance(summary, list)
# get_todo_items()
def test_get_todo_items(self, m):
register_uris({'user': ['todo_items']}, m)
todo_items = self.canvas.get_todo_items()
self.assertIsInstance(todo_items, list)
# get_upcoming_events()
def test_get_upcoming_events(self, m):
register_uris({'user': ['upcoming_events']}, m)
events = self.canvas.get_upcoming_events()
self.assertIsInstance(events, list)
# get_course_nicknames()
def test_get_course_nicknames(self, m):
register_uris(
{'user': ['course_nicknames', 'course_nicknames_page_2']}, m)
nicknames = self.canvas.get_course_nicknames()
nickname_list = [name for name in nicknames]
self.assertEqual(len(nickname_list), 4)
self.assertIsInstance(nickname_list[0], CourseNickname)
self.assertTrue(hasattr(nickname_list[0], 'nickname'))
# get_course_nickname()
def test_get_course_nickname(self, m):
register_uris({'user': ['course_nickname']}, m)
nickname = self.canvas.get_course_nickname(1)
self.assertIsInstance(nickname, CourseNickname)
self.assertTrue(hasattr(nickname, 'nickname'))
def test_get_course_nickname_fail(self, m):
register_uris({'generic': ['not_found']}, m)
with self.assertRaises(ResourceDoesNotExist):
self.canvas.get_course_nickname(settings.INVALID_ID)
# set_course_nickname()
def test_set_course_nickname(self, m):
register_uris({'user': ['course_nickname_set']}, m)
name = 'New Course Nickname'
nickname = self.canvas.set_course_nickname(1, name)
self.assertIsInstance(nickname, CourseNickname)
self.assertTrue(hasattr(nickname, 'nickname'))
self.assertEqual(nickname.nickname, name)
# clear_course_nicknames()
def test_clear_course_nicknames(self, m):
register_uris({'user': ['course_nicknames_delete']}, m)
success = self.canvas.clear_course_nicknames()
self.assertTrue(success)
# search_accounts()
def test_search_accounts(self, m):
register_uris({'account': ['domains']}, m)
domains = self.canvas.search_accounts()
self.assertIsInstance(domains, list)
self.assertEqual(len(domains), 1)
self.assertIn('name', domains[0])
# get_section()
def test_get_section(self, m):
register_uris({'section': ['get_by_id']}, m)
info = self.canvas.get_section(1)
self.assertIsInstance(info, Section)
# create_group()
def test_create_group(self, m):
register_uris({'group': ['create']}, m)
group = self.canvas.create_group()
self.assertIsInstance(group, Group)
self.assertTrue(hasattr(group, 'name'))
self.assertTrue(hasattr(group, 'description'))
# get_group()
def test_get_group(self, m):
register_uris({'group': ['get_by_id']}, m)
group = self.canvas.get_group(1)
self.assertIsInstance(group, Group)
self.assertTrue(hasattr(group, 'name'))
self.assertTrue(hasattr(group, 'description'))
# get_group_category()
def test_get_group_category(self, m):
register_uris({'group': ['get_category_by_id']}, m)
response = self.canvas.get_group_category(1)
self.assertIsInstance(response, GroupCategory)
# create_conversation()
def test_create_conversation(self, m):
register_uris({'conversation': ['create_conversation']}, m)
recipients = ['1', '2']
body = 'Test Conversation Body'
conversations = self.canvas.create_conversation(recipients=recipients,
body=body)
conversation_list = [conversation for conversation in conversations]
self.assertIsInstance(conversation_list[0], Conversation)
self.assertEqual(len(conversation_list), 2)
# get_conversation()
def test_get_conversation(self, m):
register_uris({'conversation': ['get_by_id']}, m)
convo = self.canvas.get_conversation(1)
self.assertIsInstance(convo, Conversation)
self.assertTrue(hasattr(convo, 'subject'))
# get_conversations()
def test_get_conversations(self, m):
requires = {
'conversation': ['get_conversations', 'get_conversations_2']
}
register_uris(requires, m)
convos = self.canvas.get_conversations()
conversation_list = [conversation for conversation in convos]
self.assertEqual(len(conversation_list), 4)
self.assertIsInstance(conversation_list[0], Conversation)
# mark_all_as_read()
def test_conversations_mark_all_as_read(self, m):
register_uris({'conversation': ['mark_all_as_read']}, m)
result = self.canvas.conversations_mark_all_as_read()
self.assertTrue(result)
# unread_count()
def test_conversations_unread_count(self, m):
register_uris({'conversation': ['unread_count']}, m)
result = self.canvas.conversations_unread_count()
self.assertEqual(result['unread_count'], "7")
# get_running_batches()
def test_conversations_get_running_batches(self, m):
register_uris({'conversation': ['get_running_batches']}, m)
result = self.canvas.conversations_get_running_batches()
self.assertEqual(len(result), 2)
self.assertIn('body', result[0]['message'])
self.assertEqual(result[1]['message']['author_id'], 1)
# batch_update()
def test_conversations_batch_update(self, m):
register_uris({'conversation': ['batch_update']}, m)
conversation_ids = [1, 2]
this_event = "mark_as_read"
result = self.canvas.conversations_batch_update(
event=this_event, conversation_ids=conversation_ids)
self.assertIsInstance(result, Progress)
def test_conversations_batch_updated_fail_on_event(self, m):
conversation_ids = [1, 2]
this_event = "this doesn't work"
result = self.canvas.conversations_batch_update(
event=this_event, conversation_ids=conversation_ids)
self.assertIsInstance(result, ValueError)
def test_conversations_batch_updated_fail_on_ids(self, m):
conversation_ids = [None] * 501
this_event = "mark_as_read"
result = self.canvas.conversations_batch_update(
event=this_event, conversation_ids=conversation_ids)
self.assertIsInstance(result, ValueError)
# create_calendar_event()
def test_create_calendar_event(self, m):
register_uris({'calendar_event': ['create_calendar_event']}, m)
cal_event = {"context_code": "course_123"}
evnt = self.canvas.create_calendar_event(calendar_event=cal_event)
self.assertIsInstance(evnt, CalendarEvent)
self.assertEqual(evnt.context_code, "course_123")
self.assertEqual(evnt.id, 234)
def test_create_calendar_event_fail(self, m):
with self.assertRaises(RequiredFieldMissing):
self.canvas.create_calendar_event({})
# list_calendar_events()
def test_list_calendar_events(self, m):
register_uris({'calendar_event': ['list_calendar_events']}, m)
cal_events = self.canvas.list_calendar_events()
cal_event_list = [cal_event for cal_event in cal_events]
self.assertEqual(len(cal_event_list), 2)
# get_calendar_event()
def test_get_calendar_event(self, m):
register_uris({'calendar_event': ['get_calendar_event']}, m)
cal_event = self.canvas.get_calendar_event(567)
self.assertIsInstance(cal_event, CalendarEvent)
self.assertEqual(cal_event.title, "Test Event 3")
# reserve_time_slot()
def test_reserve_time_slot(self, m):
register_uris({'calendar_event': ['reserve_time_slot']}, m)
cal_event = self.canvas.reserve_time_slot(calendar_event_id=567)
self.assertIsInstance(cal_event, CalendarEvent)
self.assertEqual(cal_event.title, "Test Reservation")
def test_reserve_time_slot_by_participant_id(self, m):
register_uris({'calendar_event': ['reserve_time_slot_participant_id']},
m)
cal_event = self.canvas.reserve_time_slot(calendar_event_id=567,
participant_id=777)
self.assertIsInstance(cal_event, CalendarEvent)
self.assertEqual(cal_event.title, "Test Reservation")
self.assertEqual(cal_event.user, 777)
# list_appointment_groups()
def test_list_appointment_groups(self, m):
register_uris({'appointment_group': ['list_appointment_groups']}, m)
appt_groups = self.canvas.list_appointment_groups()
appt_groups_list = [appt_group for appt_group in appt_groups]
self.assertEqual(len(appt_groups_list), 2)
# get_appointment_group()
def test_get_appointment_group(self, m):
register_uris({'appointment_group': ['get_appointment_group']}, m)
appt_group = self.canvas.get_appointment_group(567)
self.assertIsInstance(appt_group, AppointmentGroup)
self.assertEqual(appt_group.title, "Test Group 3")
# create_appointment_group()
def test_create_appointment_group(self, m):
register_uris({'appointment_group': ['create_appointment_group']}, m)
evnt = self.canvas.create_appointment_group({
"context_codes": ["course_123"],
"title":
"Test Group"
})
self.assertIsInstance(evnt, AppointmentGroup)
self.assertEqual(evnt.context_codes[0], "course_123")
self.assertEqual(evnt.id, 234)
def test_create_appointment_group_fail_on_context_codes(self, m):
with self.assertRaises(RequiredFieldMissing):
self.canvas.create_appointment_group({"title": "Test Group"})
def test_create_appointment_group_fail_on_title(self, m):
with self.assertRaises(RequiredFieldMissing):
self.canvas.create_appointment_group(
{"context_codes": "course_123"})
# list_user_participants()
def test_list_user_participants(self, m):
register_uris({'appointment_group': ['list_user_participants']}, m)
users = self.canvas.list_user_participants(222)
users_list = [user for user in users]
self.assertEqual(len(users_list), 2)
# list_group_participants()
def test_list_group_participants(self, m):
register_uris({'appointment_group': ['list_group_participants']}, m)
groups = self.canvas.list_group_participants(222)
groups_list = [group for group in groups]
self.assertEqual(len(groups_list), 2)
