From 72411a175fadbde84576c072fc76e67ef14f7cc4 Mon Sep 17 00:00:00 2001 From: Will Daly Date: Wed, 6 Mar 2013 09:41:26 -0500 Subject: [PATCH] Added jnater's unit tests, cleaned up broken tests, ran pep8fix --- .../courseware/tests/test_grades.py | 161 +++++++++ lms/djangoapps/courseware/tests/test_tabs.py | 334 ++++++++++++++++++ .../tests/test_models.py | 55 +++ .../tests/test_mustache_helpers.py | 48 ++- .../tests/test_permissions.py | 130 +++++++ 5 files changed, 711 insertions(+), 17 deletions(-) create mode 100644 lms/djangoapps/courseware/tests/test_grades.py create mode 100644 lms/djangoapps/courseware/tests/test_tabs.py create mode 100644 lms/djangoapps/django_comment_client/tests/test_models.py create mode 100644 lms/djangoapps/django_comment_client/tests/test_permissions.py diff --git a/lms/djangoapps/courseware/tests/test_grades.py b/lms/djangoapps/courseware/tests/test_grades.py new file mode 100644 index 0000000000..cc54064ac6 --- /dev/null +++ b/lms/djangoapps/courseware/tests/test_grades.py @@ -0,0 +1,161 @@ +from django.test import TestCase +from courseware import grades +from mock import MagicMock + +# from __future__ import division + +# import random +# import logging + +from collections import defaultdict +from django.conf import settings +from django.contrib.auth.models import User + +# from models import StudentModuleCache +from courseware.module_render import get_module as get_module +from courseware.module_render import get_instance_module as get_instance_module +# from xmodule import graders +from xmodule.capa_module import CapaModule +# from xmodule.course_module import CourseDescriptor +# from xmodule.graders import Score +# from models import StudentModule + + +class test_grades(TestCase): + + def test_yield_module_descendents(self): + mock_module = MagicMock() + a = MagicMock() + b = MagicMock() + c = MagicMock() + z = MagicMock() + y = MagicMock() + mock_module.get_display_items.return_value = [a, b, c] + a.get_display_items.return_value = [y, z] + b.get_display_items.return_value = [] + c.get_display_items.return_value = [] + z.get_display_items.return_value = [] + y.get_display_items.return_value = [] + dummy = list(grades.yield_module_descendents(mock_module)) + self.assertEqual(dummy, [a,z,y,b, c]) + + def test_yield_dynamic_descriptor_descendents(self): + descriptor_true_mock = MagicMock() + a = MagicMock() + b = MagicMock() + b.has_dynamic_children.return_value = False + b.get_children.return_value = 'b' + c = MagicMock() + c.has_dynamic_children.return_value = False + c.get_children.return_value = 'c' + e = MagicMock() + e.has_dynamic_children.return_value = False + e.get_children.return_value = None + + descriptor_true_mock.return_value = a + descriptor_true_mock.has_dynamic_children.return_value = True + module_creator_mock = MagicMock() + module_mock = MagicMock() + module_creator_mock(descriptor_true_mock).return_value = module_mock + child_locations_mock = MagicMock() + module_mock.get_children_locations.__iter__.return_value = [b, c] + print descriptor_true_mock.system.load_item(b) + + + descriptor_true_mock.system.load_item(b).return_value = b + descriptor_true_mock.system.load_item(c).return_value = c + + descriptor_false_mock = MagicMock() + descriptor_false_mock.has_dynamic_children.return_value = False + descriptor_false_mock.get_children.return_value = e + + true_descriptor_children_list = [descriptor_true_mock] + self.assertEqual(list(grades.yield_dynamic_descriptor_descendents(descriptor_true_mock, module_creator_mock)),true_descriptor_children_list) + self.assertEqual(list(grades.yield_dynamic_descriptor_descendents(descriptor_false_mock, module_creator_mock)),[descriptor_false_mock]) + + def test_yield_problems(self): + course_mock = MagicMock() + # course = course_mock + grading_context_mock = MagicMock() + # mock for grading context + course_mock.grading_context.return_value = grading_context_mock + + # mock for course.id + course_id_mock = MagicMock() + course_mock.id.return_value = course_id_mock + + # mock for student + student_mock = MagicMock() + student = student_mock() + + grading_context_mock['all_descriptors'] = MagicMock() + sec_form1 = MagicMock() + sec_form2 = MagicMock() + sec1 = MagicMock() + sec1['section_descriptor'].return_value = "sec1 descriptor" + sec2 = MagicMock() + sec2['section_descriptor'].return_value = "sec2 descriptor" + sec3 = MagicMock() + sec3['section_descriptor'].return_value = "sec3 descriptor" + sec4 = MagicMock() + sec4['section_descriptor'].return_value = "sec4 descriptor" + grading_context_mock['all_descriptors'].__iter__.return_value = [(sec_form1, [sec1, sec2]), (sec_form2, [sec3, sec4])] + StudentModuleCache_mock = MagicMock() + student_module_cache_mock = MagicMock() + StudentModuleCache_mock(course_id_mock, student_mock, grading_context_mock['all_descriptors']).return_value = student_module_cache_mock + + sec1_xmod = MagicMock() + sec2_xmod = MagicMock() + sec3_xmod = MagicMock() + sec4_xmod = MagicMock() + sec1['xmoduledescriptors'].return_value = [sec1_xmod] + sec2['xmoduledescriptors'].return_value = [sec2_xmod] + sec3['xmoduledescriptors'].return_value = [sec3_xmod] + sec4['xmoduledescriptors'].return_value = [sec4_xmod] + sec1_xmod_category = MagicMock() + sec2_xmod_category = MagicMock() + sec3_xmod_category = MagicMock() + sec4_xmod_category = MagicMock() + sec1_xmod.category.return_value = sec1_xmod_category + sec2_xmod.category.return_value = sec2_xmod_category + sec3_xmod.category.return_value = sec3_xmod_category + sec4_xmod.category.return_value = sec4_xmod_category + sec1_xmod_location_url = MagicMock() + sec2_xmod_location_url = MagicMock() + sec3_xmod_location_url = MagicMock() + sec4_xmod_location_url = MagicMock() + sec1_xmod.location.url.return_value = sec1_xmod_location_url + sec2_xmod.location.url.return_value = sec2_xmod_location_url + sec3_xmod.location.url.return_value = sec3_xmod_location_url + sec4_xmod.location.url.return_value = sec4_xmod_location_url + student_module_cache_mock.lookup(course_id_mock, sec1_xmod, sec1_xmod.location.url()).return_value = True + student_module_cache_mock.lookup(course_id_mock, sec2_xmod, sec2_xmod.location.url()).return_value = True + student_module_cache_mock.lookup(course_id_mock, sec3_xmod, sec3_xmod.location.url()).return_value = False + student_module_cache_mock.lookup(course_id_mock, sec4_xmod, sec4_xmod.location.url()).return_value = False + + student_mock = MagicMock() + request_mock = MagicMock() + sec1_module_mock = MagicMock() + sec2_module_mock = MagicMock() + sec3_module_mock = MagicMock() + sec4_module_mock = MagicMock() + get_module_mock = MagicMock() + get_module_mock(student_mock, request_mock, sec1_xmod.location, student_module_cache_mock, course_id_mock).return_value = sec1_module_mock + get_module_mock(student_mock, request_mock, sec2_xmod.location, student_module_cache_mock, course_id_mock).return_value = sec2_module_mock + get_module_mock(student_mock, request_mock, sec3_xmod.location, student_module_cache_mock, course_id_mock).return_value = sec3_module_mock + get_module_mock(student_mock, request_mock, sec4_xmod.location, student_module_cache_mock, course_id_mock).return_value = sec4_module_mock + prob1 = MagicMock() + prob2 = MagicMock() + prob3 = MagicMock() + prob4 = MagicMock() + prob5 = MagicMock() + prob6 = MagicMock() + prob7 = MagicMock() + prob8 = MagicMock() + yield_module_descendents_mock = MagicMock() + yield_module_descendents_mock(sec1_module_mock).return_value = [prob1, prob2] + yield_module_descendents_mock(sec2_module_mock).return_value = [prob3, prob4] + yield_module_descendents_mock(sec3_module_mock).return_value = [prob5, prob6] + yield_module_descendents_mock(sec4_module_mock).return_value = [prob7, prob8] + + self.assertEqual(list(grades.yield_problems(request_mock, course_mock, student_mock)), []) diff --git a/lms/djangoapps/courseware/tests/test_tabs.py b/lms/djangoapps/courseware/tests/test_tabs.py new file mode 100644 index 0000000000..e005ff4d35 --- /dev/null +++ b/lms/djangoapps/courseware/tests/test_tabs.py @@ -0,0 +1,334 @@ +from django.test import TestCase +from mock import patch, MagicMock + +import courseware.tabs as tabs +from courseware.access import has_access + +from django.test.utils import override_settings + +from collections import namedtuple +import logging + +from django.conf import settings +from django.core.urlresolvers import reverse + +from fs.errors import ResourceNotFoundError + +from courseware.access import has_access +from xmodule.error_module import ErrorDescriptor +from xmodule.x_module import XModule, XModuleDescriptor +from xmodule.modulestore import Location + +############################################################################### + + +class ProgressTestCase(TestCase): + + def setUp(self): + + self.mockuser1 = MagicMock() + self.mockuser0 = MagicMock() + self.course = MagicMock() + self.mockuser1.is_authenticated.return_value = True + self.mockuser0.is_authenticated.return_value = False + self.course.id = 'edX/full/6.002_Spring_2012' + self.tab = {'name': 'same'} + self.active_page1 = 'progress' + self.active_page0 = 'stagnation' + + def test_progress(self): + + self.assertEqual(tabs._progress(self.tab, self.mockuser0, self.course, + self.active_page0), + []) + + self.assertEqual(tabs._progress(self.tab, self.mockuser1, self.course, + self.active_page1)[0].name, + 'same') + + self.assertEqual(tabs._progress(self.tab, self.mockuser1, self.course, + self.active_page1)[0].link, + reverse('progress', args = [self.course.id])) + + self.assertEqual(tabs._progress(self.tab, self.mockuser1, self.course, + self.active_page0)[0].is_active, + False) + + self.assertEqual(tabs._progress(self.tab, self.mockuser1, self.course, + self.active_page1)[0].is_active, + True) + +############################################################################### + + +class WikiTestCase(TestCase): + + def setUp(self): + + self.user = MagicMock() + self.course = MagicMock() + self.course.id = 'edX/full/6.002_Spring_2012' + self.tab = {'name': 'same'} + self.active_page1 = 'wiki' + self.active_page0 = 'miki' + + @override_settings(WIKI_ENABLED=True) + def test_wiki_enabled(self): + + self.assertEqual(tabs._wiki(self.tab, self.user, + self.course, self.active_page1)[0].name, + 'same') + + self.assertEqual(tabs._wiki(self.tab, self.user, + self.course, self.active_page1)[0].link, + reverse('course_wiki', args=[self.course.id])) + + self.assertEqual(tabs._wiki(self.tab, self.user, + self.course, self.active_page1)[0].is_active, + True) + + self.assertEqual(tabs._wiki(self.tab, self.user, + self.course, self.active_page0)[0].is_active, + False) + + @override_settings(WIKI_ENABLED=False) + def test_wiki_enabled_false(self): + + self.assertEqual(tabs._wiki(self.tab, self.user, + self.course, self.active_page1), + []) + +############################################################################### + + +class ExternalLinkTestCase(TestCase): + + def setUp(self): + + self.user = MagicMock() + self.course = MagicMock() + self.tabby = {'name': 'same', 'link': 'blink'} + self.active_page0 = None + self.active_page00 = True + + def test_external_link(self): + + self.assertEqual(tabs._external_link(self.tabby, self.user, + self.course, self.active_page0)[0].name, + 'same') + + self.assertEqual(tabs._external_link(self.tabby, self.user, + self.course, self.active_page0)[0].link, + 'blink') + + self.assertEqual(tabs._external_link(self.tabby, self.user, + self.course, self.active_page0)[0].is_active, + False) + + self.assertEqual(tabs._external_link(self.tabby, self.user, + self.course, self.active_page00)[0].is_active, + False) + +############################################################################### + + +class StaticTabTestCase(TestCase): + + def setUp(self): + + self.user = MagicMock() + self.course = MagicMock() + self.tabby = {'name': 'same', 'url_slug': 'schmug'} + self.course.id = 'edX/full/6.002_Spring_2012' + self.active_page1 = 'static_tab_schmug' + self.active_page0 = 'static_tab_schlug' + + def test_static_tab(self): + + self.assertEqual(tabs._static_tab(self.tabby, self.user, + self.course, self.active_page1)[0].name, + 'same') + + self.assertEqual(tabs._static_tab(self.tabby, self.user, + self.course, self.active_page1)[0].link, + reverse('static_tab', args = [self.course.id, + self.tabby['url_slug']])) + + self.assertEqual(tabs._static_tab(self.tabby, self.user, + self.course, self.active_page1)[0].is_active, + True) + + + self.assertEqual(tabs._static_tab(self.tabby, self.user, + self.course, self.active_page0)[0].is_active, + False) + +############################################################################### + + +class TextbooksTestCase(TestCase): + + def setUp(self): + + self.mockuser1 = MagicMock() + self.mockuser0 = MagicMock() + self.course = MagicMock() + self.tab = MagicMock() + A = MagicMock() + T = MagicMock() + self.mockuser1.is_authenticated.return_value = True + self.mockuser0.is_authenticated.return_value = False + self.course.id = 'edX/full/6.002_Spring_2012' + self.active_page0 = 'textbook/0' + self.active_page1 = 'textbook/1' + self.active_pageX = 'you_shouldnt_be_seein_this' + A.title = 'Algebra' + T.title = 'Topology' + self.course.textbooks = [A, T] + + @override_settings(MITX_FEATURES={'ENABLE_TEXTBOOK': True}) + def test_textbooks1(self): + + self.assertEqual(tabs._textbooks(self.tab, self.mockuser1, + self.course, self.active_page0)[0].name, + 'Algebra') + + self.assertEqual(tabs._textbooks(self.tab, self.mockuser1, + self.course, self.active_page0)[0].link, + reverse('book', args=[self.course.id, 0])) + + self.assertEqual(tabs._textbooks(self.tab, self.mockuser1, + self.course, self.active_page0)[0].is_active, + True) + + self.assertEqual(tabs._textbooks(self.tab, self.mockuser1, + self.course, self.active_pageX)[0].is_active, + False) + + self.assertEqual(tabs._textbooks(self.tab, self.mockuser1, + self.course, self.active_page1)[1].name, + 'Topology') + + self.assertEqual(tabs._textbooks(self.tab, self.mockuser1, + self.course, self.active_page1)[1].link, + reverse('book', args=[self.course.id, 1])) + + self.assertEqual(tabs._textbooks(self.tab, self.mockuser1, + self.course, self.active_page1)[1].is_active, + True) + + self.assertEqual(tabs._textbooks(self.tab, self.mockuser1, + self.course, self.active_pageX)[1].is_active, + False) + + @override_settings(MITX_FEATURES={'ENABLE_TEXTBOOK': False}) + def test_textbooks0(self): + + self.assertEqual(tabs._textbooks(self.tab, self.mockuser1, + self.course, self.active_pageX), []) + + self.assertEqual(tabs._textbooks(self.tab, self.mockuser0, + self.course, self.active_pageX), []) + +############################################################################### +# +#class StaffGradingTestCase(TestCase): +# +# def setUp(self): +# +# self.tab = MagicMock() +# self.user = MagicMock() +# self.course = MagicMock() +# self.active_page1 = 'staff_grading' +# self.activate_page0 = 'shadowfax' +# self.course.id = 'edX/full/6.002_Spring_2012' +# self.link = reverse('staff_grading', args = [self.course.id]) +# +# +# def test_staff_grading(self): +# +# self.assertEqual(tabs._staff_grading(self.tab, self.user, +# self.course, self.active_page1)[0].name, +# 'Staff grading') +# +# self.assertEqual(tabs._staff_grading(self.tab, self.user, +# self.course, self.active_page1)[0].link, +# self.link) +# +# self.assertEqual(tabs._staff_grading(self.tab, self.user, +# self.course, self.active_page1)[0].is_active, +# True) +# +# +############################################################################### + + +class KeyCheckerTestCase(TestCase): + + def setUp(self): + + self.expected_keys1 = ['a', 'b'] + self.expected_keys0 = ['a', 'v', 'g'] + self.dictio = {'a': 1, 'b': 2, 'c': 3} + + def test_key_checker(self): + + self.assertIsNone(tabs.key_checker(self.expected_keys1)(self.dictio)) + self.assertRaises(tabs.InvalidTabsException, + tabs.key_checker(self.expected_keys0), self.dictio) + + +############################################################################### + +class NullValidatorTestCase(TestCase): + + def setUp(self): + + self.d = {} + + def test_null_validator(self): + + self.assertIsNone(tabs.null_validator(self.d)) + +############################################################################### + + +class ValidateTabsTestCase(TestCase): + + def setUp(self): + + self.course0 = MagicMock() + self.course1 = MagicMock() + self.course2 = MagicMock() + self.course3 = MagicMock() + self.course4 = MagicMock() + self.course5 = MagicMock() + self.course0.tabs = None + self.course1.tabs = [{'type':'courseware'}, {'type': 'fax'}] + self.course2.tabs = [{'type':'shadow'}, {'type': 'course_info'}] + self.course3.tabs = [{'type': 'set'}] + self.course4.tabs = [{'type':'courseware'},{'type':'course_info', 'name': 'alice'}, + {'type': 'wiki', 'name':'alice'}, {'type':'discussion', 'name': 'alice'}, + {'type':'external_link', 'name': 'alice', 'link':'blink'}, + {'type':'textbooks'}, {'type':'progress', 'name': 'alice'}, + {'type':'static_tab', 'name':'alice', 'url_slug':'schlug'}, + {'type': 'staff_grading'}] + + self.course5.tabs = [{'type':'courseware'},{'type': 'course_info'}, {'type': 'flying'}] + + + def test_validate_tabs(self): + + self.assertIsNone(tabs.validate_tabs(self.course0)) + + self.assertRaises(tabs.InvalidTabsException, tabs.validate_tabs, self.course3) + + self.assertRaises(tabs.InvalidTabsException, tabs.validate_tabs, self.course2) + + self.assertRaises(tabs.InvalidTabsException, tabs.validate_tabs, self.course1) + + self.assertRaises(tabs.InvalidTabsException, tabs.validate_tabs, self.course5) + + self.assertIsNone(tabs.validate_tabs(self.course4)) + + self.assertRaises(tabs.InvalidTabsException, tabs.validate_tabs, self.course5) diff --git a/lms/djangoapps/django_comment_client/tests/test_models.py b/lms/djangoapps/django_comment_client/tests/test_models.py new file mode 100644 index 0000000000..6f90b3c4b8 --- /dev/null +++ b/lms/djangoapps/django_comment_client/tests/test_models.py @@ -0,0 +1,55 @@ +import django_comment_client.models as models +import django_comment_client.permissions as permissions +from django.test import TestCase + + +class RoleClassTestCase(TestCase): + def setUp(self): + # For course ID, syntax edx/classname/classdate is important + # because xmodel.course_module.id_to_location looks for a string to split + + self.course_id = "edX/toy/2012_Fall" + self.student_role = models.Role.objects.get_or_create(name="Student", \ + course_id=self.course_id)[0] + self.student_role.add_permission("delete_thread") + self.student_2_role = models.Role.objects.get_or_create(name="Student", \ + course_id=self.course_id)[0] + self.TA_role = models.Role.objects.get_or_create(name="Community TA",\ + course_id=self.course_id)[0] + self.course_id_2 = "edx/6.002x/2012_Fall" + self.TA_role_2 = models.Role.objects.get_or_create(name="Community TA",\ + course_id=self.course_id_2)[0] + class Dummy(): + def render_template(): + pass + d = {"data": { + "textbooks": [], + 'wiki_slug': True, + } + } + + def testHasPermission(self): + # Whenever you add a permission to student_role, + # Roles with the same FORUM_ROLE in same class also receives the same + # permission. + # Is this desirable behavior? + self.assertTrue(self.student_role.has_permission("delete_thread")) + self.assertTrue(self.student_2_role.has_permission("delete_thread")) + self.assertFalse(self.TA_role.has_permission("delete_thread")) + + def testInheritPermissions(self): + + self.TA_role.inherit_permissions(self.student_role) + self.assertTrue(self.TA_role.has_permission("delete_thread")) + # Despite being from 2 different courses, TA_role_2 can still inherit + # permissions from TA_role without error + self.TA_role_2.inherit_permissions(self.TA_role) + + +class PermissionClassTestCase(TestCase): + + def setUp(self): + self.permission = permissions.Permission.objects.get_or_create(name="test")[0] + + def testUnicode(self): + self.assertEqual(str(self.permission), "test") diff --git a/lms/djangoapps/django_comment_client/tests/test_mustache_helpers.py b/lms/djangoapps/django_comment_client/tests/test_mustache_helpers.py index 5b788b3cc4..7db3ba6e86 100644 --- a/lms/djangoapps/django_comment_client/tests/test_mustache_helpers.py +++ b/lms/djangoapps/django_comment_client/tests/test_mustache_helpers.py @@ -3,26 +3,40 @@ import random import collections from django.test import TestCase +from mock import MagicMock +from django.test.utils import override_settings +import django.core.urlresolvers as urlresolvers import django_comment_client.mustache_helpers as mustache_helpers - -class PluralizeTestCase(TestCase): - - def test_pluralize(self): - self.text1 = '0 goat' - self.text2 = '1 goat' - self.text3 = '7 goat' - self.content = 'unused argument' - self.assertEqual(mustache_helpers.pluralize(self.content, self.text1), 'goats') - self.assertEqual(mustache_helpers.pluralize(self.content, self.text2), 'goat') - self.assertEqual(mustache_helpers.pluralize(self.content, self.text3), 'goats') +######################################################################################### -class CloseThreadTextTestCase(TestCase): +class PluralizeTest(TestCase): + + def setUp(self): + self.text1 = '0 goat' + self.text2 = '1 goat' + self.text3 = '7 goat' + self.content = 'unused argument' + + def test_pluralize(self): + self.assertEqual(mustache_helpers.pluralize(self.content, self.text1), 'goats') + self.assertEqual(mustache_helpers.pluralize(self.content, self.text2), 'goat') + self.assertEqual(mustache_helpers.pluralize(self.content, self.text3), 'goats') + +######################################################################################### + + +class CloseThreadTextTest(TestCase): + + def setUp(self): + self.contentClosed = {'closed': True} + self.contentOpen = {'closed': False} + + def test_close_thread_text(self): + self.assertEqual(mustache_helpers.close_thread_text(self.contentClosed), 'Re-open thread') + self.assertEqual(mustache_helpers.close_thread_text(self.contentOpen), 'Close thread') + +######################################################################################### - def test_close_thread_text(self): - self.contentClosed = {'closed': True} - self.contentOpen = {'closed': False} - self.assertEqual(mustache_helpers.close_thread_text(self.contentClosed), 'Re-open thread') - self.assertEqual(mustache_helpers.close_thread_text(self.contentOpen), 'Close thread') diff --git a/lms/djangoapps/django_comment_client/tests/test_permissions.py b/lms/djangoapps/django_comment_client/tests/test_permissions.py new file mode 100644 index 0000000000..b79d3a5194 --- /dev/null +++ b/lms/djangoapps/django_comment_client/tests/test_permissions.py @@ -0,0 +1,130 @@ +import string +import random +import collections + +from django.contrib.auth.models import User +from django.test import TestCase + +import django_comment_client.models as models + +import student.models + +import django_comment_client.permissions as permissions + +############################################################################### + + +class PermissionsTestCase(TestCase): + def random_str(self, length=15, chars=string.ascii_uppercase + string.digits): + return ''.join(random.choice(chars) for x in range(length)) + + def setUp(self): + + self.course_id = "edX/toy/2012_Fall" + + self.moderator_role = models.Role.objects.get_or_create(name="Moderator", + course_id=self.course_id)[0] + self.student_role = models.Role.objects.get_or_create(name="Student", + course_id=self.course_id)[0] + + self.student = User.objects.create(username=self.random_str(), + password="123456", email="john@yahoo.com") + self.moderator = User.objects.create(username=self.random_str(), + password="123456", email="staff@edx.org") + self.moderator.is_staff = True + self.moderator.save() + self.student_enrollment = student.models.CourseEnrollment.objects.create(user=self.student, + course_id=self.course_id) + self.moderator_enrollment = student.models.CourseEnrollment.objects.create(user=self.moderator, + course_id=self.course_id) + #Fake json files + self.empty_data = {"content": { + } + } + self.open_data = {"content": { + "closed": False, + "user_id": str(self.student.id) + } + } + self.closed_data = {"content": { + "closed": True, + "user_id": str(self.student.id) + } + } + + def tearDown(self): + self.student_enrollment.delete() + self.moderator_enrollment.delete() + +# Do we need to have this? We shouldn't be deleting students, ever +# self.student.delete() +# self.moderator.delete() + + + def testDefaultRoles(self): + self.assertTrue(self.student_role in self.student.roles.all()) + self.assertTrue(self.moderator_role in self.moderator.roles.all()) + + def testPermission(self): + name = self.random_str() + self.moderator_role.add_permission(name) + self.assertTrue(permissions.has_permission(self.moderator, name, self.course_id)) + # Moderators do not have student priveleges unless explicitly added + + self.student_role.add_permission(name) + self.assertTrue(permissions.has_permission(self.student, name, self.course_id)) + + # Students don't have moderator priveleges + name2 = self.random_str() + self.student_role.add_permission(name2) + self.assertFalse(permissions.has_permission(self.moderator, name2, self.course_id)) + + def testCachedPermission(self): + # Cache miss returns None + # Don't really understand how this works? What's in Cache? + self.assertFalse(permissions.cached_has_permission(self.student, self.moderator, + course_id=None)) + self.assertFalse(permissions.cached_has_permission(self.student, "update_thread", + course_id=None)) + + def testCheckCondition(self): + # Checks whether something? is open, or whether the author is user + self.assertFalse(permissions.check_condition(self.student, 'is_open', + self.course_id, self.empty_data)) + self.assertFalse(permissions.check_condition(self.student, 'is_author', + self.course_id, self.empty_data)) + self.assertTrue(permissions.check_condition(self.student, 'is_open', + self.course_id, self.open_data)) + self.assertTrue(permissions.check_condition(self.student, 'is_author', + self.course_id, self.open_data)) + self.assertFalse(permissions.check_condition(self.student,'is_open', + self.course_id, self.closed_data)) + + def testCheckConditionsPermissions(self): + #Function does not seem to return True + self.assertFalse(permissions.check_conditions_permissions(self.student, 'is_open', + self.course_id, + data=self.open_data)) + self.assertFalse(permissions.check_conditions_permissions(self.student, 'is_open', + self.course_id, + data=self.empty_data)) + + self.assertFalse(permissions.check_conditions_permissions(self.student, + ['is_open', 'is_author'], + self.course_id, + data=self.open_data)) + self.assertFalse(permissions.check_conditions_permissions(self.student, + ['is_open', 'is_author'], + self.course_id, + data=self.open_data, + operator='and')) + self.assertFalse(permissions.check_conditions_permissions(self.student, 'update_thread', + self.course_id, data=self.open_data)) + + def testCheckPermissionsByView(self): + # kwargs is the data entered in check_condition, which is json? + self.assertRaises(UnboundLocalError, permissions.check_permissions_by_view, + self.student, self.course_id, self.empty_data, + "nonexistant") + self.assertFalse(permissions.check_permissions_by_view(self.student,self.course_id, + self.empty_data, 'update_thread'))