diff options
author | Evgeny Fadeev <evgeny.fadeev@gmail.com> | 2010-06-12 22:51:11 -0400 |
---|---|---|
committer | Evgeny Fadeev <evgeny.fadeev@gmail.com> | 2010-06-12 22:51:11 -0400 |
commit | 3a3a11d32c72ab79ce94679aae7a549230c7104f (patch) | |
tree | 3ac36a302b85d5497b3d335238044c8f481ac0fd /forum/deps/livesettings/tests.py | |
parent | 8b6a10ead45bcd915f5da223de2b3fd3c30fc7b5 (diff) | |
download | askbot-3a3a11d32c72ab79ce94679aae7a549230c7104f.tar.gz askbot-3a3a11d32c72ab79ce94679aae7a549230c7104f.tar.bz2 askbot-3a3a11d32c72ab79ce94679aae7a549230c7104f.zip |
moved livesettings and django_authopenid into forum/deps
Diffstat (limited to 'forum/deps/livesettings/tests.py')
-rw-r--r-- | forum/deps/livesettings/tests.py | 545 |
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") |