class ConceptsTests(TestCase):
def setUp(self):
self.user = User.objects.create_user(username='******', password='******')
self.client.login(username='******', password='******')
self.course = Course(title='test_title', addedBy=self.user)
self.course.save()
self.unit = Unit(title='test unit title', addedBy=self.user)
self.unit.save()
self.course_unit = CourseUnit(course=self.course, unit=self.unit, order=0, addedBy=self.user)
self.course_unit.save()
self.role = Role(course=self.course, user=self.user, role=Role.INSTRUCTOR)
self.role.save()
self.concept = Concept.new_concept('bad', 'idea', self.unit, self.user)
self.lesson = Lesson(title='New York Test Lesson', text='brr', addedBy=self.user)
self.lesson.save_root(self.concept)
self.unit_lesson = UnitLesson(unit=self.unit, lesson=self.lesson, addedBy=self.user, treeID=self.lesson.id)
self.unit_lesson.save()
def test_unit_concepts_search(self):
self.lesson.concept = self.concept
self.lesson.save()
response = self.client.get(
reverse('ct:unit_concepts', kwargs={'course_id': self.course.id, 'unit_id': self.unit.id}),
{'search': 'New York'},
follow=True
)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'ct/concepts.html')
self.assertIn('actionTarget', response.context)
cset_dict = {i[0]: i[1] for i in response.context['cset']}
self.assertIn('New York Test Lesson', cset_dict)
self.assertIn('New York', cset_dict)
self.assertIn('The New York Times Company', cset_dict)
def test_simple_chat_flow(fsm, enroll_unit_code, client, user):
"""
Try to test very simply chat flow.
"""
get_specs()[0].save_graph('admin')
get_specs_additional()[0].save_graph('admin')
get_specs_resource()[0].save_graph('admin')
get_specs_faq()[0].save_graph('admin')
lesson = Lesson(title='title', text='きつね', addedBy=user, url='/test/url/')
lesson.save()
unitlesson = UnitLesson(unit=enroll_unit_code.courseUnit.unit,
order=0,
lesson=lesson,
addedBy=user,
treeID=lesson.id)
unitlesson.save()
client.login(username='******', password='******')
page = Session(enroll_unit_code, client)
page.create_session()
assert page.show_input() is None
assert len(page.show_messages()) == 3
assert page.show_extras() == {'updates': {'threadId': None}}
class ConceptsTests(TestCase):
def setUp(self):
self.user = User.objects.create_user(username='******', password='******')
self.client.login(username='******', password='******')
self.course = Course(title='test_title', addedBy=self.user)
self.course.save()
self.unit = Unit(title='test unit title', addedBy=self.user)
self.unit.save()
self.course_unit = CourseUnit(course=self.course, unit=self.unit, order=0, addedBy=self.user)
self.course_unit.save()
self.role = Role(course=self.course, user=self.user, role=Role.INSTRUCTOR)
self.role.save()
self.concept = Concept.new_concept('bad', 'idea', self.unit, self.user)
self.lesson = Lesson(title='New York Test Lesson', text='brr', addedBy=self.user)
self.lesson.save_root(self.concept)
self.unit_lesson = UnitLesson(unit=self.unit, lesson=self.lesson, addedBy=self.user, treeID=self.lesson.id)
self.unit_lesson.save()
def test_unit_concepts_search(self):
self.lesson.concept = self.concept
self.lesson.save()
response = self.client.get(
reverse('ct:unit_concepts', kwargs={'course_id': self.course.id, 'unit_id': self.unit.id}),
{'search': 'New York'},
follow=True
)
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'ct/concepts.html')
self.assertIn('actionTarget', response.context)
cset_dict = {i[0]: i[1] for i in response.context['cset']}
self.assertIn('New York Test Lesson', cset_dict)
self.assertIn('New York', cset_dict)
self.assertIn('The New York Times Company', cset_dict)
def setUp(self):
super(EditUnitViewTests, self).setUp()
# need to create user with username 'admin'
User.objects.create_user(
username='******'
)
self.pk = self.get_test_unitlessons()[0].id
self.url = reverse(
'ctms:unit_edit',
kwargs={
'course_pk': self.get_test_course().id,
'courslet_pk': self.get_test_courseunit().id,
'pk': self.get_test_unitlessons()[0].id,
}
)
self.default_data = {
'form-TOTAL_FORMS': 1,
'form-INITIAL_FORMS': 0,
'form-MIN_NUM_FORMS': 0,
'form-MAX_NUM_FORMS': 1000,
'form-0-id': '',
'form-0-title': '',
'form-0-text': '',
}
# creating the new Lessons of kind 'answer' to avoid redirecting to the Get Started page
lesson = Lesson(title='title', text='text', addedBy=self.user, kind=Lesson.ANSWER)
lesson2 = Lesson(title='title', text='text', addedBy=self.user, kind=Lesson.ANSWER)
lesson.save()
lesson2.save()
def setUp(self):
super(EditUnitViewTests, self).setUp()
# need to create user with username 'admin'
User.objects.create_user(
username='******'
)
self.pk = self.get_test_unitlessons()[0].id
self.url = reverse(
'ctms:unit_edit',
kwargs={
'course_pk': self.get_test_course().id,
'courselet_pk': self.get_test_courseunit().id,
'pk': self.get_test_unitlessons()[0].id,
}
)
self.default_data = {
'form-TOTAL_FORMS': 1,
'form-INITIAL_FORMS': 0,
'form-MIN_NUM_FORMS': 0,
'form-MAX_NUM_FORMS': 1000,
'form-0-id': '',
'form-0-title': '',
'form-0-text': '',
}
# creating the new Lessons of kind 'answer' to avoid redirecting to the Get Started page
lesson = Lesson(title='title', text='text', addedBy=self.user, kind=Lesson.ANSWER)
lesson2 = Lesson(title='title', text='text', addedBy=self.user, kind=Lesson.ANSWER)
lesson.save()
lesson2.save()
class CreateUnitView(NewLoginRequiredMixin, CourseCoursletUnitMixin, CreateView):
model = Lesson
form_class = CreateUnitForm
template_name = 'ctms/create_unit_form.html'
course_pk_name = 'course_pk'
courslet_pk_name = 'courslet_pk'
unit_pk_name = 'pk'
def post(self, request, *args, **kwargs):
"""
Post handler for creating Unit
Unit can create only course owner (Course.addedBy field)
:param request:
:param args:
:param kwargs:
:return:
"""
course = self.get_course()
if course.addedBy != self.request.user:
raise Http404()
return super(CreateUnitView, self).post(request, *args, **kwargs)
def get_success_url(self):
return reverse(
'ctms:unit_edit',
kwargs={
'course_pk': self.get_course().id,
'courslet_pk': self.get_courslet().id,
'pk': self.object.unit_lesson.id
}
)
def form_valid(self, form):
courslet = self.get_courslet()
unit = courslet.unit
self.object = Lesson(title=form.cleaned_data['title'], text='',
kind=Lesson.ORCT_QUESTION, addedBy=self.request.user)
self.object.save()
self.object.treeID = self.object.pk
self.object.save()
# create UnitLesson with blank answer for this unit
unit_lesson = UnitLesson.create_from_lesson(self.object, unit, order='APPEND', addAnswer=False)
self.object.unit_lesson = unit_lesson
cache.delete(memoize.cache_key('get_units_by_courselet', courslet))
return redirect(self.get_success_url())
def get_context_data(self, **kwargs):
context = super(CreateUnitView, self).get_context_data(**kwargs)
if not self.get_courslet() or not self.get_course():
raise Http404()
context.update({
'unit_lesson': self.get_unit_lesson(),
'course': self.get_course(),
'courslet': self.get_courslet()
})
return context
def setUp(self):
self.client = Client()
self.user = User.objects.create_user('test', '*****@*****.**', 'test')
get_specs()[0].save_graph(self.user.username)
get_specs_additional()[0].save_graph(self.user.username)
get_specs_resource()[0].save_graph(self.user.username)
self.unit = Unit(title='Test title', addedBy=self.user)
self.unit.save()
self.course = Course(title='Test title',
description='test description',
access='Public',
enrollCode='111',
lockout='222',
addedBy=self.user)
self.course.save()
self.courseunit = CourseUnit(
unit=self.unit, course=self.course,
order=0, addedBy=self.user, releaseTime=timezone.now()
)
self.courseunit.save()
self.concept = Concept.new_concept('bad', 'idea', self.unit, self.user)
lesson = Lesson(title='title', text='text', addedBy=self.user)
lesson.save()
self.unitlesson = UnitLesson(
unit=self.unit, order=0, lesson=lesson, addedBy=self.user, treeID=lesson.id
)
self.unitlesson.save()
resource_lesson = Lesson(
title='title for resource', text='text for resource', addedBy=self.user
)
resource_lesson.save()
self.resource_unitlesson = UnitLesson(
unit=self.unit, lesson=resource_lesson, addedBy=self.user, treeID=resource_lesson.id
)
self.resource_unitlesson.save()
def setUp(self):
"""
Preconditions.
"""
from chat.fsm_plugin.chat import get_specs
from chat.fsm_plugin.additional import get_specs as get_specs_additional
self.client = Client()
self.user = User.objects.create_user('test', '*****@*****.**', 'test')
get_specs()[0].save_graph(self.user.username)
get_specs_additional()[0].save_graph(self.user.username)
mocked_nonce = u'135685044251684026041377608307'
mocked_timestamp = u'1234567890'
mocked_decoded_signature = u'my_signature='
self.headers = {
u'user_id': 1,
u'lis_person_name_full': u'Test Username',
u'lis_person_name_given': u'First',
u'lis_person_name_family': u'Second',
u'lis_person_contact_email_primary': u'*****@*****.**',
u'lis_person_sourcedid': u'Test_Username',
u'oauth_callback': u'about:blank',
u'launch_presentation_return_url': '',
u'lti_message_type': u'basic-lti-launch-request',
u'lti_version': 'LTI-1p0',
u'roles': u'Student',
u'context_id': 1,
u'tool_consumer_info_product_family_code': u'moodle',
u'context_title': u'Test title',
u'tool_consumer_instance_guid': u'test.dot.com',
u'resource_link_id': 'dfgsfhrybvrth',
u'lis_result_sourcedid': 'wesgaegagrreg',
u'oauth_nonce': mocked_nonce,
u'oauth_timestamp': mocked_timestamp,
u'oauth_consumer_key': u'',
u'oauth_signature_method': u'HMAC-SHA1',
u'oauth_version': u'1.0',
u'oauth_signature': mocked_decoded_signature
}
self.unit = Unit(title='Test title', addedBy=self.user)
self.unit.save()
self.course = Course(title='Test title',
description='test description',
access='Public',
enrollCode='111',
lockout='222',
addedBy=self.user)
self.course.save()
self.course_ref = CourseRef(
course=self.course,
context_id=self.headers.get('context_id'),
tc_guid=self.headers.get('tool_consumer_instance_guid'))
self.course_ref.save()
self.course_ref.instructors.add(self.user)
self.courseunit = CourseUnit(unit=self.unit,
course=self.course,
order=0,
addedBy=self.user,
releaseTime=timezone.now())
self.courseunit.save()
lesson = Lesson(title='title', text='text', addedBy=self.user)
lesson.save()
unitlesson = UnitLesson(unit=self.unit,
order=0,
lesson=lesson,
addedBy=self.user,
treeID=lesson.id)
unitlesson.save()
def setUp(self):
"""
Preconditions.
"""
from chat.fsm_plugin.chat import get_specs
from chat.fsm_plugin.additional import get_specs as get_specs_additional
self.client = Client()
self.user = User.objects.create_user('test', '*****@*****.**', 'test')
get_specs()[0].save_graph(self.user.username)
get_specs_additional()[0].save_graph(self.user.username)
mocked_nonce = u'135685044251684026041377608307'
mocked_timestamp = u'1234567890'
mocked_decoded_signature = u'my_signature='
self.headers = {
u'user_id': 1,
u'lis_person_name_full': u'Test Username',
u'lis_person_name_given': u'First',
u'lis_person_name_family': u'Second',
u'lis_person_contact_email_primary': u'*****@*****.**',
u'lis_person_sourcedid': u'Test_Username',
u'oauth_callback': u'about:blank',
u'launch_presentation_return_url': '',
u'lti_message_type': u'basic-lti-launch-request',
u'lti_version': 'LTI-1p0',
u'roles': u'Student',
u'context_id': 1,
u'tool_consumer_info_product_family_code': u'moodle',
u'context_title': u'Test title',
u'tool_consumer_instance_guid': u'test.dot.com',
u'resource_link_id': 'dfgsfhrybvrth',
u'lis_result_sourcedid': 'wesgaegagrreg',
u'oauth_nonce': mocked_nonce,
u'oauth_timestamp': mocked_timestamp,
u'oauth_consumer_key': u'consumer_key',
u'oauth_signature_method': u'HMAC-SHA1',
u'oauth_version': u'1.0',
u'oauth_signature': mocked_decoded_signature
}
self.unit = Unit(title='Test title', addedBy=self.user)
self.unit.save()
self.course = Course(title='Test title',
description='test description',
access='Public',
enrollCode='111',
lockout='222',
addedBy=self.user)
self.course.save()
self.course_ref = CourseRef(
course=self.course, context_id=self.headers.get('context_id'),
tc_guid=self.headers.get('tool_consumer_instance_guid')
)
self.course_ref.save()
self.course_ref.instructors.add(self.user)
self.role1 = Role(
role=Role.ENROLLED,
user=self.user,
course=self.course,
)
self.role1.save()
self.courseunit = CourseUnit(
unit=self.unit, course=self.course,
order=0, addedBy=self.user, releaseTime=timezone.now()
)
self.courseunit.save()
lesson = Lesson(title='title', text='text', addedBy=self.user)
lesson.save()
unitlesson = UnitLesson(
unit=self.unit, order=0, lesson=lesson, addedBy=self.user, treeID=lesson.id
)
unitlesson.save()
self.lti_consumer = LtiConsumer(
consumer_name='test',
consumer_key='consumer_key',
consumer_secret='test_key'
)
self.lti_consumer.save()
class MyCoursesTests(MyTestCase):
def setUp(self):
self.username, self.password = '******', 'test'
self.user = User.objects.create_user('test', '*****@*****.**', 'test')
self.instructor = Instructor.objects.create(user=self.user, institution='institute',
what_do_you_teach='something')
self.user2 = User.objects.create_user('test1', '*****@*****.**', 'test')
self.instructor2 = Instructor.objects.create(user=self.user2, institution='institution',
what_do_you_teach='something')
self.unit = Unit(title='Test title', addedBy=self.user)
self.unit.save()
self.course = Course(title='Test title',
description='test description',
access='Public',
enrollCode='111',
lockout='222',
addedBy=self.user)
self.course.save()
self.courseunit = CourseUnit(
unit=self.unit, course=self.course,
order=0, addedBy=self.user, releaseTime=timezone.now()
)
self.courseunit.save()
self.lesson = Lesson(title='title', text='text', addedBy=self.user)
self.lesson.save()
self.unitlesson = UnitLesson(
unit=self.unit, order=0,
lesson=self.lesson, addedBy=self.user,
treeID=self.lesson.id
)
self.unitlesson.save()
self.client.login(username=self.username, password=self.password)
self.url = reverse('ctms:my_courses')
def test_get_my_courses_page(self):
response = self.client.get(self.url)
# should contain 1 course
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'ctms/my_courses.html')
self.assertIn('my_courses', response.context)
self.assertIn(self.course, response.context['my_courses'])
def test_get_my_courses_page_instructor_role(self):
"""
Ensure Role.INSTRUCTOR granted access to a Course.
"""
course = Course(title='Instructor2 Course',
description='test description',
access='Public',
enrollCode='111',
lockout='222',
addedBy=self.user2)
course.save()
Role.objects.create(role=Role.INSTRUCTOR, course=course, user=self.user)
response = self.client.get(self.url)
# should contain 2 courses
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'ctms/my_courses.html')
self.assertIn('my_courses', response.context)
self.assertIn(self.course, response.context['my_courses'])
self.assertIn(course, response.context['my_courses'])
self.assertEqual(len(response.context['my_courses']), 2)
@data(Role.TA, Role.SELFSTUDY, Role.ENROLLED)
def test_get_my_courses_page_notinstructor_role(self, role):
"""
Ensure Role.INSTRUCTOR granted access to a Course.
"""
course = Course(title='Instructor2 Course',
description='test description',
access='Public',
enrollCode='111',
lockout='222',
addedBy=self.user2)
course.save()
Role.objects.create(role=role, course=course, user=self.user)
response = self.client.get(self.url)
# should contain 1 courses
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'ctms/my_courses.html')
self.assertIn('my_courses', response.context)
self.assertIn(self.course, response.context['my_courses'])
self.assertNotIn(course, response.context['my_courses'])
self.assertEqual(len(response.context['my_courses']), 1)
def test_my_courses_show_shared_courses(self):
self.course.addedBy = self.user2
self.course.save()
# create shared course
enroll_unit_code = EnrollUnitCode.get_code(self.courseunit, give_instance=True)
shared_course = Invite.create_new(
True, self.course, self.instructor2, self.user.email, 'tester', enroll_unit_code)
response = self.client.get(reverse('ctms:shared_courses'))
# should return shared courses
self.assertIn('shared_courses', response.context)
self.assertNotEqual(len(response.context['shared_courses']), 0)
self.assertTrue(shared_course.course.title in response.context['shared_courses'])
def my_courses_show_create_course_form(self):
self.course.delete()
response = self.client.get(self.url)
# should return Course form
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'ctms/my_courses.html')
self.assertIn('my_courses', response.context)
self.assertIn('shared_courses', response.context)
self.assertIn('course_form', response.context)
self.assertFalse(len(response.context['my_courses']) < 0)
def post_valid_create_course_form(self):
courses_cnt = Course.objects.filter(addedBy=self.user).count()
course_ids = [
i['id'] for i in
Course.objects.filter(addedBy=self.user).values('id')
]
data = {
'name': 'some course'
}
response = self.client.post(self.url, data)
new_courses = Course.objects.filter(addedBy=self.user)
new_course = new_courses.exclude(id__in=course_ids).get()
self.assertEqual(new_courses.count(), courses_cnt)
self.assertRedirects(response, reverse('ctms:course_view', kwargs={'course_id': new_course.id}))
return response
def post_invalid_create_course_form(self):
courses_cnt = Course.objects.filter(addedBy=self.user).count()
course_ids = [
i['id'] for i in
Course.obget_courslet_view_logged_out_user_testjects.filter(addedBy=self.user).values('id')
]
data = {
'name': ''
}
response = self.client.post(self.url, data)
new_courses = Course.objects.filter(addedBy=self.user)
new_course = new_courses.exclude(id__in=course_ids)
self.assertNotEqual(new_courses.count(), courses_cnt)
# course was not created
self.assertEqual(len(new_course) == 0)
self.assertTemplateUsed(response, 'ctms/my_courses.html')
return response
def post_valid_create_course_form_to_create_course_view(self):
self.url = reverse('ctms:create_course')
self.post_valid_create_course_form()
def post_invalid_create_course_form_to_create_course_view(self):
self.url = reverse('ctms:create_course')
self.post_invalid_create_course_form()
class MyTestCase(TestCase):
models_to_check = tuple()
context_should_contain_keys = tuple()
def setUp(self):
self.username, self.password = '******', 'test'
self.user = User.objects.create_user(self.username, '*****@*****.**', self.password)
self.instructor = Instructor.objects.create(user=self.user, institution='institute',
what_do_you_teach='something')
self.username2, self.password2 = 'test1', 'test'
self.user2 = User.objects.create_user(self.username2, '*****@*****.**', self.password2)
self.instructor2 = Instructor.objects.create(user=self.user2, institution='institute',
what_do_you_teach='something')
self.unit = Unit(title='Test title', addedBy=self.user)
self.unit.save()
self.course = Course(title='Test title',
description='test description',
access='Public',
enrollCode='111',
lockout='222',
addedBy=self.user)
self.course.save()
self.courseunit = CourseUnit(
unit=self.unit, course=self.course,
order=0, addedBy=self.user, releaseTime=timezone.now()
)
self.courseunit.save()
self.lesson = Lesson(title='title', text='text', addedBy=self.user)
self.lesson.save()
self.unitlesson = UnitLesson(
unit=self.unit, order=0,
lesson=self.lesson, addedBy=self.user,
treeID=self.lesson.id
)
self.unitlesson.save()
self.resp1 = Response(
unitLesson=self.unitlesson,
kind=Response.ORCT_RESPONSE,
lesson=self.lesson,
course=self.course,
text="Some text user may respond",
author=self.user,
status=NEED_HELP_STATUS,
selfeval=Response.DIFFERENT
)
self.resp1.save()
self.resp2 = Response(
unitLesson=self.unitlesson,
kind=Response.ORCT_RESPONSE,
lesson=self.lesson,
course=self.course,
text="Some text user may be responded 2",
author=self.user,
status=NEED_HELP_STATUS,
selfeval=Response.DIFFERENT
)
self.resp2.save()
self.default_data = {}
self.client.login(username=self.username, password=self.password)
self.url = reverse('ctms:course_settings', kwargs={'pk': self.course.id})
def get_page(self):
return self.client.get(self.url)
def post_data(self, data={'name': 'some test name'}):
response = self.client.post(self.url, data, follow=True)
return response
def get_client_method(self, method='post'):
client_method = getattr(self.client, method)
if not client_method:
raise KeyError('self.client has no property {}'.format(method))
return client_method
def post_valid_data(self, data={'name': 'some test name'}, method='post'):
client_method = self.get_client_method(method)
copied_data = {}
if getattr(self, 'default_data', False):
copied_data.update(self.default_data)
copied_data.update(data)
response = client_method(self.url, copied_data, follow=True)
return response
def post_invalid_data(self, data={'name': ''}, method='post'):
client_method = self.get_client_method(method)
copied_data = {}
if getattr(self, 'default_data', False):
copied_data.update(self.default_data)
copied_data.update(data)
response = client_method(self.url, copied_data, follow=True)
return response
def get_my_courses(self):
return Course.objects.filter(
models.Q(addedBy=self.user) |
models.Q(role__role=Role.INSTRUCTOR, role__user=self.user)
)
def get_test_course(self):
return Course.objects.get(id=self.course.id)
def get_test_unitlessons(self):
return self.courseunit.unit.unitlesson_set.filter(
kind=UnitLesson.COMPONENT,
order__isnull=False
).order_by('order').annotate(
responses_count=models.Count('response')
)
def get_test_unitlesson(self):
return self.courseunit.unit.unitlesson_set.filter(
kind=UnitLesson.COMPONENT,
order__isnull=False
).order_by('order').annotate(
responses_count=models.Count('response')
)[0]
get_test_courslet = get_test_unitlesson
get_test_response = lambda self: self.get_test_responses()[0]
def get_test_courseunit(self):
return CourseUnit.objects.get(id=self.courseunit.id)
def get_test_responses(self):
return Response.objects.filter(
unitLesson=self.unitlesson,
kind=Response.ORCT_RESPONSE,
lesson=self.lesson,
course=self.course,
)
def get_model_counts(self, **kwargs):
if isinstance(self.models_to_check, (list, tuple)):
return {model: model.objects.filter().count() for model in self.models_to_check}
return {self.models_to_check: self.models_to_check.objects.filter().count()}
def validate_model_counts(self, first_counts, second_counts, must_equal=False):
if isinstance(self.models_to_check, (list, tuple)):
all_models = self.models_to_check
else:
all_models = [self.models_to_check]
for model in all_models:
if must_equal:
self.assertEqual(
first_counts[model], second_counts[model],
"{} ({}) != {} ({}), with must_equal={}".format(
model, first_counts[model], model, second_counts[model], must_equal
)
)
else:
self.assertNotEqual(
first_counts[model], second_counts[model],
"{} ({}) == {} ({}), with must_equal={}".format(
model, first_counts[model], model, second_counts[model], must_equal
)
)
def check_context_keys(self, response):
for key in self.context_should_contain_keys:
self.assertIn(key, response.context)
def am_i_instructor(self, method='GET'):
methods_map = {'GET', self.client.get, 'POST', self.client.post}
client_method = methods_map.get(method)
self.assertIsNotNone(client_method)
if getattr(self, 'url'):
if getattr(self, 'NEED_INSTRUCTOR'):
response = client_method(self.url)
if getattr(self, 'instructor'):
self.assertEqual(response.status_code, 200)
self.instructor.delete()
response = client_method(self.url)
self.assertEqual(response.status_code, 403)
else:
self.assertEqual(response.status_code, 403)
else:
response = client_method(self.url)
self.assertEqual(response.status_code, 200)
class MyCoursesTests(MyTestCase):
def setUp(self):
self.username, self.password = '******', 'test'
self.user = User.objects.create_user('test', '*****@*****.**', 'test')
self.instructor = Instructor.objects.create(user=self.user, institution='institute',
what_do_you_teach='something')
self.user2 = User.objects.create_user('test1', '*****@*****.**', 'test')
self.instructor2 = Instructor.objects.create(user=self.user2, institution='institution',
what_do_you_teach='something')
self.unit = Unit(title='Test title', addedBy=self.user)
self.unit.save()
self.course = Course(title='Test title',
description='test description',
access='Public',
enrollCode='111',
lockout='222',
addedBy=self.user)
self.course.save()
self.courseunit = CourseUnit(
unit=self.unit, course=self.course,
order=0, addedBy=self.user, releaseTime=timezone.now()
)
self.courseunit.save()
self.lesson = Lesson(title='title', text='text', addedBy=self.user)
self.lesson.save()
self.unitlesson = UnitLesson(
unit=self.unit, order=0,
lesson=self.lesson, addedBy=self.user,
treeID=self.lesson.id
)
self.unitlesson.save()
self.client.login(username=self.username, password=self.password)
self.url = reverse('ctms:my_courses')
@mock.patch('ctms.views.get_onboarding_percentage')
def test_get_my_courses_page(self, onboarding_percentage):
onboarding_percentage.return_value = 100
response = self.client.get(self.url)
# should contain 1 course
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'ctms/my_courses.html')
self.assertIn('my_courses', response.context)
self.assertIn(self.course, response.context['my_courses'])
@mock.patch('ctms.views.get_onboarding_percentage')
def test_my_courses_show_shared_courses(self, onboarding_percentage):
onboarding_percentage.return_value = 100
self.course.addedBy = self.user2
self.course.save()
# create shared course
enroll_unit_code = EnrollUnitCode.get_code(self.courseunit, give_instance=True)
shared_course = Invite.create_new(True, self.course, self.instructor2, self.user.email, 'tester', enroll_unit_code)
response = self.client.get(reverse('ctms:shared_courses'))
# should return shared courses
self.assertIn('shared_courses', response.context)
self.assertNotEqual(len(response.context['shared_courses']), 0)
self.assertTrue(shared_course.course.title in response.context['shared_courses'])
def my_courses_show_create_course_form(self):
self.course.delete()
response = self.client.get(self.url)
# should return Course form
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'ctms/my_courses.html')
self.assertIn('my_courses', response.context)
self.assertIn('shared_courses', response.context)
self.assertIn('course_form', response.context)
self.assertFalse(len(response.context['my_courses']) < 0)
def post_valid_create_course_form(self):
courses_cnt = Course.objects.filter(addedBy=self.user).count()
course_ids = [
i['id'] for i in
Course.objects.filter(addedBy=self.user).values('id')
]
data = {
'name': 'some course'
}
response = self.client.post(self.url, data)
new_courses = Course.objects.filter(addedBy=self.user)
new_course = new_courses.exclude(id__in=course_ids).get()
self.assertEqual(new_courses.count(), courses_cnt)
self.assertRedirects(response, reverse('ctms:course_view', kwargs={'course_id': new_course.id}))
return response
def post_invalid_create_course_form(self):
courses_cnt = Course.objects.filter(addedBy=self.user).count()
course_ids = [
i['id'] for i in
Course.obget_courslet_view_logged_out_user_testjects.filter(addedBy=self.user).values('id')
]
data = {
'name': ''
}
response = self.client.post(self.url, data)
new_courses = Course.objects.filter(addedBy=self.user)
new_course = new_courses.exclude(id__in=course_ids)
self.assertNotEqual(new_courses.count(), courses_cnt)
# course was not created
self.assertEqual(len(new_course) == 0)
self.assertTemplateUsed(response, 'ctms/my_courses.html')
return response
def post_valid_create_course_form_to_create_course_view(self):
self.url = reverse('ctms:create_course')
self.post_valid_create_course_form()
def post_invalid_create_course_form_to_create_course_view(self):
self.url = reverse('ctms:create_course')
self.post_invalid_create_course_form()
class MyTestCase(TestCase):
models_to_check = tuple()
context_should_contain_keys = tuple()
def setUp(self):
self.username, self.password = '******', 'test'
self.user = User.objects.create_user(self.username, '*****@*****.**', self.password)
self.instructor = Instructor.objects.create(user=self.user, institution='institute',
what_do_you_teach='something')
self.username2, self.password2 = 'test1', 'test'
self.user2 = User.objects.create_user(self.username2, '*****@*****.**', self.password2)
self.instructor2 = Instructor.objects.create(user=self.user2, institution='institute',
what_do_you_teach='something')
self.unit = Unit(title='Test title', addedBy=self.user)
self.unit.save()
self.course = Course(title='Test title',
description='test description',
access='Public',
enrollCode='111',
lockout='222',
addedBy=self.user)
self.course.save()
self.courseunit = CourseUnit(
unit=self.unit, course=self.course,
order=0, addedBy=self.user, releaseTime=timezone.now()
)
self.courseunit.save()
self.lesson = Lesson(title='title', text='text', addedBy=self.user)
self.lesson.save()
self.unitlesson = UnitLesson(
unit=self.unit, order=0,
lesson=self.lesson, addedBy=self.user,
treeID=self.lesson.id
)
self.unitlesson.save()
self.resp1 = Response(
unitLesson=self.unitlesson,
kind=Response.ORCT_RESPONSE,
lesson=self.lesson,
course=self.course,
text="Some text user may respond",
author=self.user,
status=NEED_HELP_STATUS,
selfeval=Response.DIFFERENT
)
self.resp1.save()
self.resp2 = Response(
unitLesson=self.unitlesson,
kind=Response.ORCT_RESPONSE,
lesson=self.lesson,
course=self.course,
text="Some text user may be responded 2",
author=self.user,
status=NEED_HELP_STATUS,
selfeval=Response.DIFFERENT
)
self.resp2.save()
self.default_data = {}
self.client.login(username=self.username, password=self.password)
self.url = reverse('ctms:course_settings', kwargs={'pk': self.course.id})
def get_page(self):
return self.client.get(self.url)
def post_data(self, data={'name': 'some test name'}):
response = self.client.post(self.url, data, follow=True)
return response
def get_client_method(self, method='post'):
client_method = getattr(self.client, method)
if not client_method:
raise KeyError('self.client has no property {}'.format(method))
return client_method
def post_valid_data(self, data={'name': 'some test name'}, method='post'):
client_method = self.get_client_method(method)
copied_data = {}
if getattr(self, 'default_data', False):
copied_data.update(self.default_data)
copied_data.update(data)
response = client_method(self.url, copied_data, follow=True)
return response
def post_invalid_data(self, data={'name': ''}, method='post'):
client_method = self.get_client_method(method)
copied_data = {}
if getattr(self, 'default_data', False):
copied_data.update(self.default_data)
copied_data.update(data)
response = client_method(self.url, copied_data, follow=True)
return response
def get_my_courses(self):
return Course.objects.filter(addedBy=self.user)
def get_test_course(self):
return Course.objects.get(id=self.course.id)
def get_test_unitlessons(self):
return self.courseunit.unit.unitlesson_set.filter(
kind=UnitLesson.COMPONENT,
order__isnull=False
).order_by('order').annotate(
responses_count=models.Count('response')
)
def get_test_unitlesson(self):
return self.courseunit.unit.unitlesson_set.filter(
kind=UnitLesson.COMPONENT,
order__isnull=False
).order_by('order').annotate(
responses_count=models.Count('response')
)[0]
get_test_courslet = get_test_unitlesson
get_test_response = lambda self: self.get_test_responses()[0]
def get_test_courseunit(self):
return CourseUnit.objects.get(id=self.courseunit.id)
def get_test_responses(self):
return Response.objects.filter(
unitLesson=self.unitlesson,
kind=Response.ORCT_RESPONSE,
lesson=self.lesson,
course=self.course,
)
def get_model_counts(self, **kwargs):
if isinstance(self.models_to_check, (list, tuple)):
return {model: model.objects.filter().count() for model in self.models_to_check}
return {self.models_to_check: self.models_to_check.objects.filter().count()}
def validate_model_counts(self, first_counts, second_counts, must_equal=False):
if isinstance(self.models_to_check, (list, tuple)):
all_models = self.models_to_check
else:
all_models = [self.models_to_check]
for model in all_models:
if must_equal:
self.assertEqual(
first_counts[model], second_counts[model],
"{} ({}) != {} ({}), with must_equal={}".format(
model, first_counts[model], model, second_counts[model], must_equal
)
)
else:
self.assertNotEqual(
first_counts[model], second_counts[model],
"{} ({}) == {} ({}), with must_equal={}".format(
model, first_counts[model], model, second_counts[model], must_equal
)
)
def check_context_keys(self, response):
for key in self.context_should_contain_keys:
self.assertIn(key, response.context)
def am_i_instructor(self, method='GET'):
methods_map = {'GET', self.client.get, 'POST', self.client.post}
client_method = methods_map.get(method)
self.assertIsNotNone(client_method)
if getattr(self, 'url'):
if getattr(self, 'NEED_INSTRUCTOR'):
response = client_method(self.url)
if getattr(self, 'instructor'):
self.assertEqual(response.status_code, 200)
self.instructor.delete()
response = client_method(self.url)
self.assertEqual(response.status_code, 403)
else:
self.assertEqual(response.status_code, 403)
else:
response = client_method(self.url)
self.assertEqual(response.status_code, 200)
