def test_config_load_unicode(self):
"""
Load configuration into the cache
"""
ConfigModel.objects.create(key="char", value="áéíóú")
registry.register(FooForm)
self.assertEqual(config.char, "áéíóú")
def test_config_load_from_database(self):
"""
Load configuration into the cache
"""
data = [ConfigModel(key='boolean', value=False),
ConfigModel(key='boolean_false', value=True),
ConfigModel(key='float_number', value=2.1),
ConfigModel(key='char', value="foo2"),
ConfigModel(key='email', value="*****@*****.**"),
ConfigModel(key='integer', value=321),
ConfigModel(key='url', value="foo2.com/")]
ConfigModel.objects.bulk_create(data)
registry.register(FooForm)
config._lazy_load()
keys = ['boolean', 'boolean_false', 'char', 'email', 'float_number', 'integer', 'url']
values = self.cache.get_many([prefixer(k) for k in keys])
self.assertDictEqual(values, {prefixer('boolean'): False,
prefixer('boolean_false'): True,
prefixer('float_number'): 2.1,
prefixer('char'): "foo2",
prefixer('email'): "*****@*****.**",
prefixer('integer'): 321,
prefixer('url'): "http://foo2.com/"})
# use initial if the field is not found in the db
ConfigModel.objects.get(key='char').delete()
config._reset()
config._lazy_load()
self.assertEqual(self.cache.get(prefixer('char')), "foo")
def test_config_middleware_process_request(self):
"""
config middleware, reload cache
"""
ConfigModel.objects.create(key="char", value="foo")
registry.register(BarForm)
config._lazy_load()
config._set('char', None)
cache = config._cache
# Should not reload since _updated_at does not exists (form was not saved)
middleware = DjConfigMiddleware()
middleware.process_request(request=None)
self.assertIsNone(cache.get('char'))
# Changing _updated_at should make it reload
ConfigModel.objects.create(key="_updated_at", value="111")
middleware.process_request(request=None)
self.assertEqual(cache.get('char'), "foo")
self.assertEqual(cache.get("_updated_at"), "111")
# It does not update again, since _updated_at has not changed
ConfigModel.objects.filter(key="char").update(value="bar")
middleware.process_request(request=None)
self.assertNotEqual(cache.get('char'), "bar")
self.assertEqual(cache.get("_updated_at"), "111")
# Changing _updated_at should make it reload
ConfigModel.objects.filter(key="_updated_at").update(value="222")
middleware.process_request(request=None)
self.assertEqual(cache.get('char'), "bar")
self.assertEqual(cache.get("_updated_at"), "222")
def test_config_load_from_database_invalid(self):
"""
Load initial if the db value is invalid
"""
ConfigModel.objects.create(key="integer", value="string")
registry.register(FooForm)
self.assertEqual(config.integer, 123)
def test_config_reload_in_keys(self):
"""
Load the config the first time you access an attribute
"""
registry.register(FooForm)
self.assertTrue("char" in config._cache)
self.assertEqual(config.char, "foo")
def test_config_reload_in_keys(self):
"""
Load the config the first time you access an attribute
"""
registry.register(FooForm)
self.assertTrue('char' in config._cache)
self.assertEqual(config.char, "foo")
def test_config_load_from_database_invalid(self):
"""
Load initial if the db value is invalid
"""
ConfigModel.objects.create(key='integer', value="string")
registry.register(FooForm)
self.assertEqual(config.integer, 123)
def test_config_load_unicode(self):
"""
Load configuration into the cache
"""
ConfigModel.objects.create(key='char', value=u"áéíóú")
registry.register(FooForm)
self.assertEqual(config.char, u"áéíóú")
def test_config_middleware_process_request(self):
"""
config middleware, reload cache
"""
ConfigModel.objects.create(key="char", value="foo")
registry.register(BarForm)
config._lazy_load()
config._set("char", None)
cache = config._cache
# Should not reload since _updated_at does not exists (form was not saved)
middleware = DjConfigMiddleware()
middleware.process_request(request=None)
self.assertIsNone(cache.get("char"))
# Changing _updated_at should make it reload
ConfigModel.objects.create(key="_updated_at", value="111")
middleware.process_request(request=None)
self.assertEqual(cache.get("char"), "foo")
self.assertEqual(cache.get("_updated_at"), "111")
# It does not update again, since _updated_at has not changed
ConfigModel.objects.filter(key="char").update(value="bar")
middleware.process_request(request=None)
self.assertNotEqual(cache.get("char"), "bar")
self.assertEqual(cache.get("_updated_at"), "111")
# Changing _updated_at should make it reload
ConfigModel.objects.filter(key="_updated_at").update(value="222")
middleware.process_request(request=None)
self.assertEqual(cache.get("char"), "bar")
self.assertEqual(cache.get("_updated_at"), "222")
def test_register(self):
"""
register forms
"""
registry.register(FooForm)
self.assertSetEqual(registry._registered_forms, {
FooForm,
})
def test_config_load_from_database_invalid(self):
"""
Load initial if the db value is invalid
"""
ConfigModel.objects.create(key='integer', value="string")
registry.register(FooForm)
config._lazy_load()
self.assertEqual(self.cache.get(prefixer('integer')), 123)
def test_config_load_unicode(self):
"""
Load configuration into the cache
"""
ConfigModel.objects.create(key='char', value=u"áéíóú")
registry.register(FooForm)
config._lazy_load()
self.assertEqual(self.cache.get(prefixer('char')), u"áéíóú")
def test_config_lazy_load(self):
"""
Load the config the first time you access an attribute
"""
self.assertRaises(AttributeError, lambda: config.char)
registry.register(FooForm)
self.assertRaises(AttributeError, lambda: config.char)
config._reset()
self.assertEqual(config.char, "foo")
def test_config_lazy_load(self):
"""
Load the config the first time you access an attribute
"""
self.assertRaises(AttributeError, lambda: config.char)
registry.register(FooForm)
self.assertRaises(AttributeError, lambda: config.char)
config._reset()
self.assertEqual(config.char, "foo")
def test_config_load_updated_at(self):
"""
Load updated_at
"""
registry.register(FooForm)
self.assertIsNone(config._updated_at)
ConfigModel.objects.create(key="_updated_at", value="string")
config._reset()
self.assertEqual(config._updated_at, "string")
def test_config_form_allow_initial_overwrite(self):
"""
config form, allow user to pass initial data
"""
registry.register(BarForm)
config._set("char", "foo2")
config._is_loaded = True
form = BarForm(initial={"char": "bar"})
self.assertEqual(form.initial["char"], "bar")
def test_config_lazy_load(self):
"""
Load the config the first time you access an attribute
"""
registry.register(FooForm)
# registry.load()
value = self.cache.get(prefixer("char"))
self.assertIsNone(value)
self.assertEqual(config.char, "foo")
def test_config_load_updated_at(self):
"""
Load updated_at
"""
registry.register(FooForm)
self.assertIsNone(config._updated_at)
ConfigModel.objects.create(key="_updated_at", value="string")
config._reset()
self.assertEqual(config._updated_at, "string")
def test_config_form_cache_update(self):
"""
config form, update cache on form save
"""
registry.register(BarForm)
form = BarForm(data={"char": "foo2"})
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(config.char, "foo2")
def test_config_form_allow_initial_overwrite(self):
"""
config form, allow user to pass initial data
"""
registry.register(BarForm)
config._set("char", "foo2")
config._is_loaded = True
form = BarForm(initial={
'char': 'bar',
})
self.assertEqual(form.initial['char'], 'bar')
def test_config_form_cache_update(self):
"""
config form, update cache on form save
"""
registry.register(BarForm)
form = BarForm(data={"char": "foo2", })
self.assertTrue(form.is_valid())
form.save()
cache = get_cache(djconfig_settings.BACKEND)
self.assertEqual(cache.get(prefixer('char')), "foo2")
def test_config_form_cache_update(self):
"""
config form, update cache on form save
"""
registry.register(BarForm)
form = BarForm(data={
"char": "foo2",
})
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(config.char, "foo2")
def test_config_form_populate_if_loaded(self):
"""
config form, populate initial data only if the config is loaded
"""
registry.register(BarForm)
config._set("char", "foo2")
form = BarForm()
self.assertTrue("char" not in form.initial)
config._is_loaded = True
form = BarForm()
self.assertEqual(form.initial["char"], "foo2")
def test_config_form_populate_if_loaded(self):
"""
config form, populate initial data only if the config is loaded
"""
registry.register(BarForm)
config._set("char", "foo2")
form = BarForm()
self.assertTrue('char' not in form.initial)
config._is_loaded = True
form = BarForm()
self.assertEqual(form.initial['char'], 'foo2')
def test_config_load_updated_at(self):
"""
Load updated_at
"""
registry.register(FooForm)
config._lazy_load()
value = self.cache.get(prefixer("_updated_at"))
self.assertIsNone(value)
ConfigModel.objects.create(key="_updated_at", value="string")
config._reset()
config._lazy_load()
value = self.cache.get(prefixer("_updated_at"))
self.assertEqual(value, "string")
def test_config_load(self):
"""
Load initial configuration into the cache
"""
registry.register(FooForm)
config._lazy_load()
keys = ['boolean', 'boolean_false', 'char', 'email', 'float_number', 'integer', 'url']
values = self.cache.get_many([prefixer(k) for k in keys])
self.assertDictEqual(values, {prefixer('boolean'): True,
prefixer('boolean_false'): False,
prefixer('char'): "foo",
prefixer('email'): "*****@*****.**",
prefixer('float_number'): 1.23,
prefixer('integer'): 123,
prefixer('url'): "foo.com/"})
def test_config_load(self):
"""
Load initial configuration into the cache
"""
registry.register(FooForm)
keys = ["boolean", "boolean_false", "char", "email", "float_number", "integer", "url"]
values = {k: getattr(config, k) for k in keys}
self.assertDictEqual(
values,
{
"boolean": True,
"boolean_false": False,
"char": "foo",
"email": "*****@*****.**",
"float_number": 1.23,
"integer": 123,
"url": "foo.com/",
},
)
def test_config_load(self):
"""
Load initial configuration into the cache
"""
registry.register(FooForm)
keys = [
'boolean', 'boolean_false', 'char', 'email', 'float_number',
'integer', 'url'
]
values = {k: getattr(config, k) for k in keys}
self.assertDictEqual(
values, {
'boolean': True,
'boolean_false': False,
'char': "foo",
'email': "*****@*****.**",
'float_number': 1.23,
'integer': 123,
'url': "foo.com/"
})
def test_config_load_from_database(self):
"""
Load configuration into the cache
"""
data = [
ConfigModel(key='boolean', value=False),
ConfigModel(key='boolean_false', value=True),
ConfigModel(key='float_number', value=2.1),
ConfigModel(key='char', value="foo2"),
ConfigModel(key='email', value="*****@*****.**"),
ConfigModel(key='integer', value=321),
ConfigModel(key='url', value="foo2.com/")
]
ConfigModel.objects.bulk_create(data)
registry.register(FooForm)
keys = [
'boolean', 'boolean_false', 'char', 'email', 'float_number',
'integer', 'url'
]
values = {k: getattr(config, k) for k in keys}
self.assertDictEqual(
values, {
'boolean': False,
'boolean_false': True,
'float_number': 2.1,
'char': "foo2",
'email': "*****@*****.**",
'integer': 321,
'url': "http://foo2.com/"
})
# use initial if the field is not found in the db
ConfigModel.objects.get(key='char').delete()
config._reset()
config._lazy_load()
self.assertEqual(config.char, "foo")
def test_config_load_from_database(self):
"""
Load configuration into the cache
"""
data = [
ConfigModel(key="boolean", value=False),
ConfigModel(key="boolean_false", value=True),
ConfigModel(key="float_number", value=2.1),
ConfigModel(key="char", value="foo2"),
ConfigModel(key="email", value="*****@*****.**"),
ConfigModel(key="integer", value=321),
ConfigModel(key="url", value="foo2.com/"),
]
ConfigModel.objects.bulk_create(data)
registry.register(FooForm)
keys = ["boolean", "boolean_false", "char", "email", "float_number", "integer", "url"]
values = {k: getattr(config, k) for k in keys}
self.assertDictEqual(
values,
{
"boolean": False,
"boolean_false": True,
"float_number": 2.1,
"char": "foo2",
"email": "*****@*****.**",
"integer": 321,
"url": "http://foo2.com/",
},
)
# use initial if the field is not found in the db
ConfigModel.objects.get(key="char").delete()
config._reset()
config._lazy_load()
self.assertEqual(config.char, "foo")
def test_register(self):
"""
register forms
"""
registry.register(FooForm)
self.assertSetEqual(registry._registered_forms, {FooForm})
