From 72411a175fadbde84576c072fc76e67ef14f7cc4 Mon Sep 17 00:00:00 2001 From: Will Daly Date: Wed, 6 Mar 2013 09:41:26 -0500 Subject: [PATCH 1/4] 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')) From 0d1b3800089406f405c2856daadf74a7e231091a Mon Sep 17 00:00:00 2001 From: Will Daly Date: Wed, 6 Mar 2013 09:44:53 -0500 Subject: [PATCH 2/4] Removed test_grades.py in courseware django app. --- .../courseware/tests/test_grades.py | 161 ------------------ 1 file changed, 161 deletions(-) delete mode 100644 lms/djangoapps/courseware/tests/test_grades.py diff --git a/lms/djangoapps/courseware/tests/test_grades.py b/lms/djangoapps/courseware/tests/test_grades.py deleted file mode 100644 index cc54064ac6..0000000000 --- a/lms/djangoapps/courseware/tests/test_grades.py +++ /dev/null @@ -1,161 +0,0 @@ -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)), []) From 2f5ea630e7adcb854b0abb341741797cd55d9ddf Mon Sep 17 00:00:00 2001 From: Will Daly Date: Wed, 6 Mar 2013 10:16:43 -0500 Subject: [PATCH 3/4] Cleaned up courseware test_tabs unittests --- lms/djangoapps/courseware/tests/test_tabs.py | 117 ++++--------------- 1 file changed, 21 insertions(+), 96 deletions(-) diff --git a/lms/djangoapps/courseware/tests/test_tabs.py b/lms/djangoapps/courseware/tests/test_tabs.py index e005ff4d35..928b9ae0df 100644 --- a/lms/djangoapps/courseware/tests/test_tabs.py +++ b/lms/djangoapps/courseware/tests/test_tabs.py @@ -1,26 +1,11 @@ from django.test import TestCase -from mock import patch, MagicMock +from mock import 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): @@ -39,26 +24,20 @@ class ProgressTestCase(TestCase): def test_progress(self): self.assertEqual(tabs._progress(self.tab, self.mockuser0, self.course, - self.active_page0), - []) + self.active_page0), []) self.assertEqual(tabs._progress(self.tab, self.mockuser1, self.course, - self.active_page1)[0].name, - 'same') + 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.active_page0)[0].is_active, False) self.assertEqual(tabs._progress(self.tab, self.mockuser1, self.course, - self.active_page1)[0].is_active, - True) - -############################################################################### + self.active_page1)[0].is_active, True) class WikiTestCase(TestCase): @@ -95,10 +74,7 @@ class WikiTestCase(TestCase): def test_wiki_enabled_false(self): self.assertEqual(tabs._wiki(self.tab, self.user, - self.course, self.active_page1), - []) - -############################################################################### + self.course, self.active_page1), []) class ExternalLinkTestCase(TestCase): @@ -129,8 +105,6 @@ class ExternalLinkTestCase(TestCase): self.course, self.active_page00)[0].is_active, False) -############################################################################### - class StaticTabTestCase(TestCase): @@ -163,8 +137,6 @@ class StaticTabTestCase(TestCase): self.course, self.active_page0)[0].is_active, False) -############################################################################### - class TextbooksTestCase(TestCase): @@ -230,39 +202,6 @@ class TextbooksTestCase(TestCase): 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): @@ -278,8 +217,6 @@ class KeyCheckerTestCase(TestCase): tabs.key_checker(self.expected_keys0), self.dictio) -############################################################################### - class NullValidatorTestCase(TestCase): def setUp(self): @@ -290,45 +227,33 @@ class NullValidatorTestCase(TestCase): 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'}, + self.courses = [MagicMock() for i in range(0,5)] + + self.courses[0].tabs = None + + self.courses[1].tabs = [{'type':'courseware'}, {'type': 'fax'}] + + self.courses[2].tabs = [{'type':'shadow'}, {'type': 'course_info'}] + + self.courses[3].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'}] + self.courses[4].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) + self.assertIsNone(tabs.validate_tabs(self.courses[0])) + self.assertRaises(tabs.InvalidTabsException, tabs.validate_tabs, self.courses[1]) + self.assertRaises(tabs.InvalidTabsException, tabs.validate_tabs, self.courses[2]) + self.assertIsNone(tabs.validate_tabs(self.courses[3])) + self.assertRaises(tabs.InvalidTabsException, tabs.validate_tabs, self.courses[4]) From e1b99186ef4e24a89349eea718d2d6a64c40a891 Mon Sep 17 00:00:00 2001 From: Will Daly Date: Wed, 6 Mar 2013 10:20:02 -0500 Subject: [PATCH 4/4] Removed test_permissions.py --- .../tests/test_permissions.py | 130 ------------------ 1 file changed, 130 deletions(-) delete mode 100644 lms/djangoapps/django_comment_client/tests/test_permissions.py diff --git a/lms/djangoapps/django_comment_client/tests/test_permissions.py b/lms/djangoapps/django_comment_client/tests/test_permissions.py deleted file mode 100644 index b79d3a5194..0000000000 --- a/lms/djangoapps/django_comment_client/tests/test_permissions.py +++ /dev/null @@ -1,130 +0,0 @@ -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'))