1 files changed, 545 insertions, 0 deletions
diff --git a/forum/deps/livesettings/tests.py b/forum/deps/livesettings/tests.py
new file mode 100644
index 00000000..f604af99
--- /dev/null
+++ b/forum/deps/livesettings/tests.py
@@ -0,0 +1,545 @@
+from django.conf import settings as djangosettings
+from django.test import TestCase
+import keyedcache
+from forum.deps.livesettings import *
+import logging
+log = logging.getLogger('test');
+
+class ConfigurationFunctionTest(TestCase):
+
+    def testSetSingleConfigItem(self):
+        value = IntegerValue(BASE_GROUP, 'SingleItem')
+        config_register(value)
+        self.assert_(config_exists(BASE_GROUP, 'SingleItem'))
+
+    def testSetTwoConfigItems(self):
+        s = [IntegerValue(BASE_GROUP, 'testTwoA'), StringValue(BASE_GROUP, 'testTwoB')]
+        config_register_list(*s)
+
+        self.assert_(config_exists(BASE_GROUP, 'testTwoA'))
+        self.assert_(config_exists(BASE_GROUP, 'testTwoB'))
+
+    def testSetGroup(self):
+        g1 = ConfigurationGroup('test1','test1')
+        value = IntegerValue(g1, 'SingleGroupedItem')
+        config_register(value)
+        self.assertFalse(config_exists(BASE_GROUP, 'SingleGroupedItem'))
+        self.assert_(config_exists(g1, 'SingleGroupedItem'))
+
+
+class ConfigurationTestSettings(TestCase):
+
+    def setUp(self):
+        # clear out cache from previous runs
+        keyedcache.cache_delete()
+        g = ConfigurationGroup('test2','test2')
+        self.g = g
+        config_register(StringValue(g, 's1'))
+        config_register(IntegerValue(g, 's2', default=10))
+        config_register(IntegerValue(g, 's3', default=10))
+
+    def testSetSetting(self):
+        c = config_get('test2', 's1')
+        c.update('test')
+
+        self.assertEqual(c.value, 'test')
+        self.assertEqual(c.setting.value, 'test')
+
+    def testSettingDefault(self):
+        c = config_get('test2', 's2')
+        self.assertEqual(c.value, 10)
+
+    def testSetAndReset(self):
+        """Test setting one value and then updating"""
+        c = config_get('test2', 's1')
+        c.update('test1')
+
+        self.assertEqual(c.value, 'test1')
+
+        # should be true, since it is an update
+        self.assert_(c.update('test2'))
+        self.assertEqual(c.value, 'test2')
+
+    def testTwice(self):
+        """Config items should respond False to duplicate requests to update."""
+
+        c = config_get('test2', 's1')
+        c.update('test1')
+
+        self.assertFalse(c.update('test1'))
+
+
+    def testDeletesDefault(self):
+        c = config_get('test2', 's3')
+        # false because it isn't saving a default value
+        self.assertFalse(c.update(10))
+
+        self.assert_(c.update(20))
+        self.assertEqual(c.value, 20)
+        try:
+            s = c.setting
+        except SettingNotSet:
+            self.fail("Should have a setting now")
+
+        # now delete and go back to no setting by setting the default
+        self.assert_(c.update(10))
+        self.assertEqual(c.value, 10)
+
+        try:
+            s = c.setting
+            self.fail('Should throw SettingNotSet')
+        except SettingNotSet:
+            pass
+
+
+class ConfigTestDotAccess(TestCase):
+    def setUp(self):
+        # clear out cache from previous runs
+        keyedcache.cache_delete()
+
+        g = ConfigurationGroup('test3','test3')
+        self.g = g
+        c1 = config_register(BooleanValue(g, 's1', default=True))
+        c2 = config_register(IntegerValue(g, 's2', default=10))
+        c2.update(100)
+
+    def testDotAccess(self):
+        self.assert_(ConfigurationSettings().test3.s1.value)
+        self.assertEqual(ConfigurationSettings().test3.s2.value, 100)
+
+    def testSettingProperty(self):
+        c = config_get('test3','s2')
+        s = c.setting
+        self.assert_(s.value, 100)
+
+    def testDictValues(self):
+        d = self.g.dict_values()
+        self.assertEqual(d, {'s1': True, 's2' : 100})
+
+class ConfigTestModuleValue(TestCase):
+    def setUp(self):
+        # clear out cache from previous runs
+        keyedcache.cache_delete()
+
+        g = ConfigurationGroup('modules','module test')
+        self.g = g
+        self.c = config_register(ModuleValue(g, 'test'))
+
+    # def testModule(self):
+    #     c = config_get('modules', 'test')
+    #     c.update('satchmo_store')
+
+    #     self.assert_(hasattr(self.c.value, 'get_version'))
+
+class ConfigTestSortOrder(TestCase):
+    def setUp(self):
+        # clear out cache from previous runs
+        keyedcache.cache_delete()
+
+        g1 = ConfigurationGroup('group1', 'Group 1', ordering=-1001)
+        g2 = ConfigurationGroup('group2', 'Group 2', ordering=-1002)
+        g3 = ConfigurationGroup('group3', 'Group 3', ordering=-1003)
+
+        self.g1 = g1
+        self.g2 = g2
+        self.g3 = g3
+
+        self.g1c1 = config_register(IntegerValue(g1, 'c1'))
+        self.g1c2 = config_register(IntegerValue(g1, 'c2'))
+        self.g1c3 = config_register(IntegerValue(g1, 'c3'))
+
+        self.g2c1 = config_register(IntegerValue(g2, 'c1'))
+        self.g2c2 = config_register(IntegerValue(g2, 'c2'))
+        self.g2c3 = config_register(IntegerValue(g2, 'c3'))
+
+        self.g3c1 = config_register(IntegerValue(g3, 'c1'))
+        self.g3c2 = config_register(IntegerValue(g3, 'c2'))
+        self.g3c3 = config_register(IntegerValue(g3, 'c3'))
+
+    def testGroupOrdering(self):
+        mgr = ConfigurationSettings()
+        self.assertEqual(mgr[2].key, self.g1.key)
+        self.assertEqual(mgr[1].key, self.g2.key)
+        self.assertEqual(mgr[0].key, self.g3.key)
+
+
+class TestMultipleValues(TestCase):
+
+    def setUp(self):
+        # clear out cache from previous runs
+        keyedcache.cache_delete()
+
+        g1 = ConfigurationGroup('m1', 'Multiple Group 1', ordering=1000)
+        self.g1 = g1
+
+        self.g1c1 = config_register(MultipleStringValue(g1,
+            'c1',
+            choices=((1,'one'),(2,'two'),(3,'three'))))
+
+    def testSave(self):
+
+        c = config_get('m1','c1')
+        c.update([1,2])
+        self.assertEqual(c.value, [1,2])
+
+    def testAddChoice(self):
+
+        config_add_choice('m1','c1',(4, 'four'))
+        c = config_get('m1','c1')
+        self.assertEqual(c.choices, ((1,'one'),(2,'two'),(3,'three'),(4,'four')))
+
+    def testChoiceValues(self):
+        self.g1c1.update([1,2])
+
+        self.assertEqual(self.g1c1.value, [1,2])
+        self.assertEqual(self.g1c1.choice_values, [(1, 'one'),(2, 'two')])
+
+        choices = config_choice_values('m1', 'c1')
+        self.assertEqual(choices, [(1, 'one'),(2, 'two')])
+
+class TestMultipleValuesWithDefault(TestCase):
+
+    def setUp(self):
+        # clear out cache from previous runs
+        keyedcache.cache_delete()
+
+        g1 = ConfigurationGroup('mv2', 'Multiple Group 2', ordering=1000)
+        self.g1 = g1
+
+        self.g1c1 = config_register(MultipleStringValue(g1,
+            'c1',
+            choices=((1,'one'),(2,'two'),(3,'three')),
+            default=[1,2]))
+
+    def testDefault(self):
+
+        c = config_get('mv2','c1')
+        self.assertEqual(c.value, [1,2])
+
+        c.update([1,2,3])
+        self.assertEqual(c.value, [1,2,3])
+
+class ConfigTestChoices(TestCase):
+
+    def testAddPreregisteredChoice(self):
+        """Test that we can register choices before the config is actually set up."""
+        config_add_choice('ctg1', 'c1', ('a', 'Item A'))
+        config_add_choice('ctg1', 'c1', ('b', 'Item B'))
+        config_add_choice('ctg1', 'c1', ('c', 'Item C'))
+
+        g1 = ConfigurationGroup('ctg1', 'Choice 1', ordering=1000)
+        config_register(StringValue(g1, 'c1'))
+
+        c = config_get('ctg1','c1')
+
+        self.assertEqual(c.choices, [('a','Item A'), ('b','Item B'), ('c','Item C')])
+
+
+class ConfigTestRequires(TestCase):
+
+    def setUp(self):
+        # clear out cache from previous runs
+        keyedcache.cache_delete()
+
+        g1 = ConfigurationGroup('req1', 'Requirements 1', ordering=1000)
+
+        self.g1 = g1
+
+        bool1 = config_register(BooleanValue(g1, 'bool1', default=False, ordering=1))
+        bool2 = config_register(BooleanValue(g1, 'bool2', ordering=2))
+
+        self.g1c1 = config_register(IntegerValue(g1, 'c1', requires=bool1, ordering=3))
+
+        self.g1c2 = config_register(IntegerValue(g1, 'c2', requires=bool2, ordering=4))
+        self.g1c3 = config_register(IntegerValue(g1, 'c3', ordering=5))
+
+        bool2.update(True)
+
+    def testSimpleRequires(self):
+
+        v = config_value('req1', 'bool2')
+        self.assertTrue(v)
+
+        keys = [cfg.key for cfg in self.g1]
+        self.assertEqual(keys, ['bool1', 'bool2', 'c2','c3'])
+
+        c = config_get('req1','bool1')
+        c.update(True)
+
+        keys = [cfg.key for cfg in self.g1]
+        self.assertEqual(keys, ['bool1', 'bool2', 'c1', 'c2', 'c3'])
+
+class ConfigTestRequiresChoices(TestCase):
+
+    def setUp(self):
+        # clear out cache from previous runs
+        keyedcache.cache_delete()
+
+        g1 = ConfigurationGroup('req2', 'Requirements 2', ordering=1000)
+
+        self.g1 = g1
+
+        choices1 = config_register(MultipleStringValue(BASE_GROUP, 'rc1', ordering=1))
+
+        self.g1c1 = config_register(IntegerValue(g1, 'c1', requires=choices1, ordering=3))
+        self.g1c2 = config_register(IntegerValue(g1, 'c2', requires=choices1, ordering=4))
+        self.g1c3 = config_register(IntegerValue(g1, 'c3', ordering=5))
+
+        choices1.update('c1')
+
+        g2 = ConfigurationGroup('req3', 'Requirements 3', ordering=1000)
+
+        self.g2 = g2
+
+        choices2 = config_register(StringValue(BASE_GROUP, 'choices2', ordering=1))
+
+        self.g2c1 = config_register(IntegerValue(g2, 'c1', requires=choices2, ordering=3))
+        self.g2c2 = config_register(IntegerValue(g2, 'c2', requires=choices2, ordering=4))
+        self.g2c3 = config_register(IntegerValue(g2, 'c3', requires=choices2, ordering=5))
+
+        choices2.update('c1')
+
+    def testSimpleRequiresChoices(self):
+
+        v = config_value('BASE', 'rc1')
+        self.assertEquals(v, ['c1'])
+
+        g = config_get_group('req2')
+        keys = [cfg.key for cfg in g]
+        self.assertEqual(keys, ['c1','c3'])
+
+        c = config_get('BASE', 'rc1')
+        c.update(['c1','c2'])
+
+        g = config_get_group('req2')
+        keys = [cfg.key for cfg in g]
+        self.assertEqual(keys, ['c1', 'c2', 'c3'])
+
+    def testRequiresSingleValue(self):
+        v = config_value('BASE', 'choices2')
+        self.assertEquals(v, 'c1')
+
+        keys = [cfg.key for cfg in self.g2]
+        self.assertEqual(keys, ['c1'])
+
+        c = config_get('BASE', 'choices2')
+        c.update('c2')
+
+        keys = [cfg.key for cfg in self.g2]
+        self.assertEqual(keys, ['c2'])
+
+class ConfigTestRequiresValue(TestCase):
+
+    def setUp(self):
+        # clear out cache from previous runs
+        keyedcache.cache_delete()
+
+        g1 = ConfigurationGroup('reqval', 'Requirements 3', ordering=1000)
+
+        self.g1 = g1
+
+        choices1 = config_register(MultipleStringValue(BASE_GROUP, 'valchoices', ordering=1))
+
+        self.g1c1 = config_register(IntegerValue(g1, 'c1', requires=choices1, requiresvalue='foo', ordering=3))
+        self.g1c2 = config_register(IntegerValue(g1, 'c2', requires=choices1, requiresvalue='bar', ordering=4))
+        self.g1c3 = config_register(IntegerValue(g1, 'c3', ordering=5))
+
+        choices1.update('foo')
+
+        g2 = ConfigurationGroup('reqval2', 'Requirements 4', ordering=1000)
+
+        self.g2 = g2
+
+        choices2 = config_register(StringValue(BASE_GROUP, 'valchoices2', ordering=1,
+            choices=(('a','test a'),('b', 'test b'),('c', 'test c'))))
+
+        self.g2c1 = config_register(IntegerValue(g2, 'c1', requires=choices2, requiresvalue='a', ordering=3))
+        self.g2c2 = config_register(IntegerValue(g2, 'c2', requires=choices2, requiresvalue='b', ordering=4))
+        self.g2c3 = config_register(IntegerValue(g2, 'c3', requires=choices2, requiresvalue='c', ordering=5))
+
+        choices2.update('a')
+
+    def testRequiresValue(self):
+        v = config_value('BASE', 'valchoices')
+        self.assertEquals(v, ['foo'])
+
+        g = config_get_group('reqval')
+
+        keys = [cfg.key for cfg in g]
+        self.assertEqual(keys, ['c1','c3'])
+
+        c = config_get('BASE', 'valchoices')
+        c.update(['foo','bar'])
+
+        g = config_get_group('reqval')
+        keys = [cfg.key for cfg in g]
+        self.assertEqual(keys, ['c1', 'c2', 'c3'])
+
+    def testRequiresSingleValue(self):
+        v = config_value('BASE', 'valchoices2')
+        self.assertEquals(v, 'a')
+
+        keys = [cfg.key for cfg in self.g2]
+        self.assertEqual(keys, ['c1'])
+
+        c = config_get('BASE', 'valchoices2')
+        c.update('b')
+
+        keys = [cfg.key for cfg in self.g2]
+        self.assertEqual(keys, ['c2'])
+
+class ConfigTestGroupRequires(TestCase):
+    def setUp(self):
+        # clear out cache from previous runs
+        keyedcache.cache_delete()
+
+        choices1 = config_register(MultipleStringValue(BASE_GROUP, 'groupchoice', ordering=1))
+        choices2 = config_register(MultipleStringValue(BASE_GROUP, 'groupchoice2', ordering=1))
+
+        g1 = ConfigurationGroup('groupreq', 'Requirements 4', ordering=1000, requires=choices1)
+        self.g1 = g1
+
+        self.g1c1 = config_register(IntegerValue(g1, 'c1', ordering=3))
+        self.g1c2 = config_register(IntegerValue(g1, 'c2', requires=choices2, requiresvalue='bar', ordering=4))
+        self.g1c3 = config_register(IntegerValue(g1, 'c3', ordering=5))
+
+    def testRequiresValue(self):
+        c = config_get('BASE', 'groupchoice')
+        self.assertEquals(c.value, [])
+
+        keys = [cfg.key for cfg in self.g1]
+        self.assertEqual(keys, [])
+
+        c2 = config_get('BASE', 'groupchoice2')
+        c2.update('bar')
+
+        keys = [cfg.key for cfg in self.g1]
+        self.assertEqual(keys, ['c2'])
+
+        c.update(['groupreq'])
+
+        keys = [cfg.key for cfg in self.g1]
+        self.assertEqual(keys, ['c1', 'c2', 'c3'])
+
+class ConfigCollectGroup(TestCase):
+    def setUp(self):
+        keyedcache.cache_delete()
+        choices = config_register(MultipleStringValue(BASE_GROUP, 'collect', ordering=1))
+        self.choices = choices
+
+        g1 = ConfigurationGroup('coll1', 'Collection 1')
+        g2 = ConfigurationGroup('coll2', 'Collection 2')
+        g3 = ConfigurationGroup('coll3', 'Collection 3')
+
+        g1c1 = config_register(StringValue(g1, 'test'))
+        g1c2 = config_register(StringValue(g1, 'test1'))
+        g2c1 = config_register(StringValue(g2, 'test'))
+        g3c1 = config_register(StringValue(g3, 'test'))
+
+        g1c1.update('set a')
+        g1c2.update('set b')
+        g2c1.update('set a')
+        g3c1.update('set d')
+
+        choices.update(['coll1','coll3'])
+
+    def testCollectSimple(self):
+        v = config_collect_values('BASE', 'collect', 'test')
+
+        self.assertEqual(v, ['set a', 'set d'])
+
+    def testCollectUnique(self):
+        self.choices.update(['coll1','coll2','coll3'])
+
+        v = config_collect_values('BASE', 'collect', 'test', unique=False)
+
+        self.assertEqual(v, ['set a', 'set a', 'set d'])
+
+        v = config_collect_values('BASE', 'collect', 'test', unique=True)
+
+        self.assertEqual(v, ['set a', 'set d'])
+
+class LongSettingTest(TestCase):
+    def setUp(self):
+        keyedcache.cache_delete()
+        wide = config_register(LongStringValue(BASE_GROUP, 'LONG', ordering=1, default="woot"))
+        self.wide = wide
+        self.wide.update('*' * 1000)
+
+    def testLongStorage(self):
+        w = config_value('BASE', 'LONG')
+        self.assertEqual(len(w), 1000)
+        self.assertEqual(w, '*'*1000)
+
+    def testShortInLong(self):
+        self.wide.update("test")
+        w = config_value('BASE', 'LONG')
+        self.assertEqual(len(w), 4)
+        self.assertEqual(w, 'test')
+
+    def testDelete(self):
+        remember = self.wide.setting.id
+        self.wide.update('woot')
+
+        try:
+            q = LongSetting.objects.get(pk = remember)
+            self.fail("Should be deletec")
+        except LongSetting.DoesNotExist:
+            pass
+
+class OverrideTest(TestCase):
+    """Test settings overrides"""
+    def setUp(self):
+        # clear out cache from previous runs
+        keyedcache.cache_delete()
+
+        djangosettings.LIVESETTINGS_OPTIONS = {
+            1 : {
+                'DB' : False,
+                'SETTINGS' : {
+                        'overgroup' : {
+                            's2' : '100',
+                            'choices' : '["one","two","three"]'
+                        }
+                    }
+                }
+            }
+
+        g = ConfigurationGroup('overgroup','Override Group')
+        self.g = g
+        config_register(StringValue(g, 's1'))
+        config_register(IntegerValue(g, 's2', default=10))
+        config_register(IntegerValue(g, 's3', default=10))
+        config_register(MultipleStringValue(g, 'choices'))
+
+    def tearDown(self):
+        djangosettings.LIVESETTINGS_OPTIONS = {}
+
+    def testOverriddenSetting(self):
+        """Accessing an overridden setting should give the override value."""
+        c = config_get('overgroup', 's2')
+        self.assertEquals(c.value, 100)
+
+    def testCantChangeSetting(self):
+        """When overridden, setting a value should not work, should get the overridden value"""
+        c = config_get('overgroup', 's2')
+        c.update(1)
+
+        c = config_get('overgroup', 's2')
+        self.assertEquals(c.value, 100)
+
+    def testNotOverriddenSetting(self):
+        """Settings which are not overridden should return their defaults"""
+        c = config_get('overgroup', 's3')
+
+        self.assertEquals(c.value, 10)
+
+    def testOverriddenListSetting(self):
+        """Make sure lists work when overridden"""
+
+        c = config_get('overgroup', 'choices')
+        v = c.value
+        self.assertEqual(len(v), 3)
+        self.assertEqual(v[0], "one")
+        self.assertEqual(v[1], "two")
+        self.assertEqual(v[2], "three")