Merge pull request #1603 from MITx/fix/will/merge_jnater_unittests

Fix/will/merge jnater unittests

lms/djangoapps/courseware/tests/test_tabs.py

+from django.test import TestCase
+from mock import MagicMock
+
+import courseware.tabs as tabs
+
+from django.test.utils import override_settings
+from django.core.urlresolvers import reverse
+
+
+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 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.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.courses[4].tabs = [{'type':'courseware'},{'type': 'course_info'}, {'type': 'flying'}]
+
+
+    def test_validate_tabs(self):
+
+        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])

lms/djangoapps/django_comment_client/tests/test_models.py

+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")

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 PluralizeTest(TestCase):
 
+    def setUp(self):
+        self.text1 = '0 goat'
+        self.text2 = '1 goat'
+        self.text3 = '7 goat'
+        self.content = 'unused argument'
 
-class CloseThreadTextTestCase(TestCase):
+    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')