def test_config_middleware_process_request(self):
"""
config middleware, reload cache
"""
ConfigModel.objects.create(key="char", value="foo")
djconfig.register(BarForm)
djconfig.reload_maybe()
config._set('char', None)
# Should not reload since _updated_at does not exists (form was not saved)
middleware = DjConfigMiddleware()
middleware.process_request(request=None)
self.assertIsNone(config._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(config._cache.get('char'), "foo")
self.assertEqual(config._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(config._cache.get('char'), "bar")
self.assertEqual(config._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(config._cache.get('char'), "bar")
self.assertEqual(config._cache.get("_updated_at"), "222")
def test_config_load(self):
"""
Load initial configuration into the cache
"""
djconfig.register(FooForm)
djconfig.reload_maybe()
keys = ['boolean', 'boolean_false', 'char', 'email', 'float_number',
'integer', 'url', 'choices', 'model_choices', 'model_m_choices',
'image', 'file']
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/",
'choices': None,
'model_choices': None,
'model_m_choices': None,
'image': None,
'file': None
}
)
def test_config_middleware_process_request(self):
"""
config middleware, reload cache
"""
ConfigModel.objects.create(key="char", value="foo")
djconfig.register(BarForm)
djconfig.reload_maybe()
config._set('char', None)
# Should not reload since _updated_at does not exists (form was not saved)
middleware = DjConfigMiddleware()
middleware.process_request(request=None)
self.assertIsNone(config._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(config._cache.get('char'), "foo")
self.assertEqual(config._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(config._cache.get('char'), "bar")
self.assertEqual(config._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(config._cache.get('char'), "bar")
self.assertEqual(config._cache.get("_updated_at"), "222")
def test_config_form_updated_at(self):
"""
updated_at should get update on every save() call
"""
now = djconfig_forms.timezone.now()
class TZMock:
@classmethod
def now(cls):
return now
orig_djconfig_forms_timezone, djconfig_forms.timezone = djconfig_forms.timezone, TZMock
try:
djconfig.register(BarForm)
form = BarForm(data={"char": "foo2", })
self.assertTrue(form.is_valid())
form.save()
updated_at_a = ConfigModel.objects.get(key="_updated_at").value
now += datetime.timedelta(seconds=1)
form = BarForm(data={"char": "foo2", })
self.assertTrue(form.is_valid())
form.save()
updated_at_b = ConfigModel.objects.get(key="_updated_at").value
self.assertNotEqual(updated_at_a, updated_at_b)
finally:
djconfig_forms.timezone = orig_djconfig_forms_timezone
def test_config_form_updated_at(self):
"""
updated_at should get update on every save() call
"""
now = djconfig_forms.timezone.now()
class TZMock:
@classmethod
def now(cls):
return now
orig_djconfig_forms_timezone, djconfig_forms.timezone = djconfig_forms.timezone, TZMock
try:
djconfig.register(BarForm)
form = BarForm(data={"char": "foo2", })
self.assertTrue(form.is_valid())
form.save()
updated_at_a = ConfigModel.objects.get(key="_updated_at").value
now += datetime.timedelta(seconds=1)
form = BarForm(data={"char": "foo2", })
self.assertTrue(form.is_valid())
form.save()
updated_at_b = ConfigModel.objects.get(key="_updated_at").value
self.assertNotEqual(updated_at_a, updated_at_b)
finally:
djconfig_forms.timezone = orig_djconfig_forms_timezone
def test_config_form_initial(self):
"""
config form, populate initial data
"""
djconfig.register(BarForm)
djconfig.reload_maybe()
form = BarForm()
self.assertEqual(form.initial['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")
djconfig.register(FooForm)
djconfig.reload_maybe()
self.assertEqual(config.integer, 123)
def test_config_form_initial(self):
"""
config form, populate initial data
"""
djconfig.register(BarForm)
djconfig.reload_maybe()
form = BarForm()
self.assertEqual(form.initial['char'], 'foo')
def test_config_load_unicode(self):
"""
Load configuration into the cache
"""
ConfigModel.objects.create(key='char', value=u"áéíóú")
djconfig.register(FooForm)
djconfig.reload_maybe()
self.assertEqual(config.char, u"áéíóú")
def test_config_load_unicode(self):
"""
Load configuration into the cache
"""
ConfigModel.objects.create(key='char', value=u"áéíóú")
djconfig.register(FooForm)
djconfig.reload_maybe()
self.assertEqual(config.char, u"áéíóú")
def test_config_load_from_database_invalid(self):
"""
Load initial if the db value is invalid
"""
ConfigModel.objects.create(key='integer', value="string")
djconfig.register(FooForm)
djconfig.reload_maybe()
self.assertEqual(config.integer, 123)
def test_config_reload_maybe(self):
"""
Reload if not loaded
"""
self.assertRaises(AttributeError, lambda: config.char)
djconfig.register(FooForm)
self.assertRaises(AttributeError, lambda: config.char)
djconfig.reload_maybe()
self.assertEqual(config.char, "foo")
def ready(self):
import sewingworld.tasks # noqa: F401
import djconfig
from .forms import SWConfigForm
djconfig.register(SWConfigForm)
from .admin import configure_admin
configure_admin()
def test_config_reload_maybe(self):
"""
Reload if not loaded
"""
self.assertRaises(AttributeError, lambda: config.char)
djconfig.register(FooForm)
self.assertRaises(AttributeError, lambda: config.char)
djconfig.reload_maybe()
self.assertEqual(config.char, "foo")
def test_config_form_auto_populate(self):
"""
config form, populate initial data,
load the config if it's not loaded
"""
ConfigModel.objects.create(key="char", value="foo2")
djconfig.register(BarForm)
djconfig.reload_maybe()
form = BarForm()
self.assertEqual(form.initial['char'], 'foo2')
def test_config_form_cache_update(self):
"""
config form, update cache on form save
"""
djconfig.register(BarForm)
form = BarForm(data={"char": "foo2", })
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(config.char, "foo2")
def test_config_form(self):
"""
config form
"""
djconfig.register(BarForm)
form = BarForm(data={"char": "foo2", })
self.assertTrue(form.is_valid())
form.save()
qs = ConfigModel.objects.get(key="char")
self.assertEqual(qs.value, "foo2")
def test_config_form_auto_populate(self):
"""
config form, populate initial data,
load the config if it's not loaded
"""
ConfigModel.objects.create(key="char", value="foo2")
djconfig.register(BarForm)
djconfig.reload_maybe()
form = BarForm()
self.assertEqual(form.initial['char'], 'foo2')
def test_config_load_from_database(self):
"""
Load configuration into the cache
"""
model_choice = ChoiceModel.objects.create(name='A')
model_choice_b = ChoiceModel.objects.create(name='B')
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(key='choices', value='1'),
ConfigModel(key='model_choices', value=model_choice.pk),
ConfigModel(key='model_m_choices', value=utils.serialize(
ChoiceModel.objects.filter(pk=model_choice_b.pk),
forms.ModelMultipleChoiceField(None))),
ConfigModel(key='image', value='path/image.gif'),
ConfigModel(key='file', value='path/file.zip')
]
ConfigModel.objects.bulk_create(data)
djconfig.register(FooForm)
djconfig.reload_maybe()
keys = ['boolean', 'boolean_false', 'char', 'email', 'float_number',
'integer', 'url', 'choices', 'model_choices', 'model_m_choices',
'image', 'file']
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/",
'choices': '1',
'model_choices': model_choice,
'model_m_choices': [model_choice_b],
'image': 'path/image.gif',
'file': 'path/file.zip'
}
)
# use initial if the field is not found in the db
ConfigModel.objects.get(key='char').delete()
config._reset()
djconfig.register(FooForm)
djconfig.reload_maybe()
self.assertEqual(config.char, "foo")
def test_config_form_cache_update(self):
"""
config form, update cache on form save
"""
djconfig.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
"""
djconfig.register(BarForm)
djconfig.reload_maybe()
config._set("char", "foo2")
form = BarForm(initial={'char': 'bar', 'email': '*****@*****.**'})
self.assertEqual(form.initial['char'], 'foo2')
self.assertEqual(form.initial['email'], '*****@*****.**')
def test_config_form(self):
"""
config form
"""
djconfig.register(BarForm)
form = BarForm(data={"char": "foo2", })
self.assertTrue(form.is_valid())
form.save()
qs = ConfigModel.objects.get(key="char")
self.assertEqual(qs.value, "foo2")
def test_config_form_allow_initial_overwrite(self):
"""
config form, allow user to pass initial data
"""
djconfig.register(BarForm)
djconfig.reload_maybe()
config._set("char", "foo2")
form = BarForm(initial={'char': 'bar', 'email': '*****@*****.**'})
self.assertEqual(form.initial['char'], 'foo2')
self.assertEqual(form.initial['email'], '*****@*****.**')
def test_config_form_model_choice_pk(self):
"""
Saves ModelChoiceField
"""
djconfig.register(ModelChoicePKForm)
model_choice = ChoiceModel.objects.create(name='foo')
form = ModelChoicePKForm(data={"model_choice": str(model_choice.pk), })
self.assertTrue(form.is_valid())
form.save()
qs = ConfigModel.objects.get(key="model_choice")
self.assertEqual(qs.value, str(model_choice.pk))
def test_config_form_model_choice_pk(self):
"""
Saves ModelChoiceField
"""
djconfig.register(ModelChoicePKForm)
model_choice = ChoiceModel.objects.create(name='foo')
form = ModelChoicePKForm(data={"model_choice": str(model_choice.pk), })
self.assertTrue(form.is_valid())
form.save()
qs = ConfigModel.objects.get(key="model_choice")
self.assertEqual(qs.value, str(model_choice.pk))
def test_config_form_update(self):
"""
Should update the form with the supplied data when saving
"""
ConfigModel.objects.create(key="char", value="bar")
djconfig.register(BarForm)
form = BarForm(data={"char": "foo2", })
self.assertTrue(form.is_valid())
form.save()
qs = ConfigModel.objects.get(key="char")
self.assertEqual(qs.value, "foo2")
def test_image_save_form_conf(self):
"""
Should save the path after storing the image
"""
djconfig.register(ImageForm)
djconfig.reload_maybe()
self.assertFalse(ConfigModel.objects.filter(key="image").exists())
form = ImageForm(files={'image': make_dummy_image()})
self.assertTrue(form.is_valid())
form.save_image()
form.save()
qs = ConfigModel.objects.get(key="image")
self.assertEqual(qs.value, "foo_saved.gif")
def test_config_form_update(self):
"""
Should update the form with the supplied data when saving
"""
ConfigModel.objects.create(key="char", value="bar")
djconfig.register(BarForm)
form = BarForm(data={"char": "foo2", })
self.assertTrue(form.is_valid())
form.save()
qs = ConfigModel.objects.get(key="char")
self.assertEqual(qs.value, "foo2")
def test_config_load_updated_at(self):
"""
Load updated_at
"""
djconfig.register(FooForm)
djconfig.reload_maybe()
self.assertIsNone(config._updated_at)
ConfigModel.objects.create(key="_updated_at", value="string")
config._reset()
djconfig.register(FooForm)
djconfig.reload_maybe()
self.assertEqual(config._updated_at, "string")
def test_config_load_updated_at(self):
"""
Load updated_at
"""
djconfig.register(FooForm)
djconfig.reload_maybe()
self.assertIsNone(config._updated_at)
ConfigModel.objects.create(key="_updated_at", value="string")
config._reset()
djconfig.register(FooForm)
djconfig.reload_maybe()
self.assertEqual(config._updated_at, "string")
def test_file_form_conf(self):
"""
Should save the file path
"""
djconfig.register(FileForm)
djconfig.reload_maybe()
self.assertFalse(ConfigModel.objects.filter(key="file").exists())
form = FileForm(files={'file': make_dummy_image()})
self.assertTrue(form.is_valid())
form.save()
qs = ConfigModel.objects.get(key="file")
self.assertEqual(qs.value, "image.gif")
form = FileForm(files={'file': None})
self.assertTrue(form.is_valid())
qs = ConfigModel.objects.get(key="file")
self.assertEqual(qs.value, "image.gif")
def test_config_form_model_multi_choice(self):
"""
Saves ModelMultipleChoiceField
"""
djconfig.register(ModelMultipleChoiceForm)
model_choice_a = ChoiceModel.objects.create(name='foo')
model_choice_b = ChoiceModel.objects.create(name='bar')
form = ModelMultipleChoiceForm(data={
"model_choices": [
str(model_choice_a.pk),
str(model_choice_b.pk)]})
self.assertTrue(form.is_valid())
form.save()
qs = ConfigModel.objects.get(key="model_choices")
self.assertEqual(qs.value, '[1, 2]')
self.assertEqual(list(config.model_choices), [model_choice_a, model_choice_b])
def test_config_check_backend_new_middleware(self):
"""
Should try both MIDDLEWARE and MIDDLEWARE_CLASS
"""
mids = settings.MIDDLEWARE_CLASSES
with override_settings(MIDDLEWARE_CLASSES=mids[:-1], MIDDLEWARE=[]):
self.assertRaises(ValueError, djconfig.register, FooForm)
with override_settings(MIDDLEWARE_CLASSES=[], MIDDLEWARE=mids[:-1]):
self.assertRaises(ValueError, djconfig.register, FooForm)
with override_settings(MIDDLEWARE_CLASSES=mids, MIDDLEWARE=[]):
self.assertIsNone(djconfig.register(FooForm))
with override_settings(MIDDLEWARE_CLASSES=[], MIDDLEWARE=mids):
self.assertIsNone(djconfig.register(FooForm))
def test_config_check_backend_new_middleware(self):
"""
Should try both MIDDLEWARE and MIDDLEWARE_CLASS
"""
mids = settings.MIDDLEWARE_CLASSES
with override_settings(MIDDLEWARE_CLASSES=mids[:-1], MIDDLEWARE=[]):
self.assertRaises(ValueError, djconfig.register, FooForm)
with override_settings(MIDDLEWARE_CLASSES=[], MIDDLEWARE=mids[:-1]):
self.assertRaises(ValueError, djconfig.register, FooForm)
with override_settings(MIDDLEWARE_CLASSES=mids, MIDDLEWARE=[]):
self.assertIsNone(djconfig.register(FooForm))
with override_settings(MIDDLEWARE_CLASSES=[], MIDDLEWARE=mids):
self.assertIsNone(djconfig.register(FooForm))
def test_register(self):
"""
register forms
"""
djconfig.register(FooForm)
self.assertSetEqual(config._registry, {FooForm, })
def setUp(self):
config._reset()
djconfig.register(BarConfigAdminForm)
djconfig.register(BazConfigAdminForm)
self.user = User.objects.create_superuser(
'foo', '*****@*****.**', 'bar')
def register_config(self):
import djconfig
from .forms import HackerspaceConfigForm
djconfig.register(HackerspaceConfigForm)
def test_register(self):
"""
register forms
"""
djconfig.register(FooForm)
self.assertSetEqual(config._registry, {FooForm, })
def ready(self):
# needed for using Admin in runserver
from .tests import BarConfigAdminForm, BazConfigAdminForm
djconfig.register(BarConfigAdminForm)
djconfig.register(BazConfigAdminForm)
def register_config():
import djconfig
from .forms import WifiForm
djconfig.register(WifiForm)
def register_config(self):
import djconfig
from spirit.forms.admin import BasicConfigForm
djconfig.register(BasicConfigForm)
def register_config(self):
import djconfig
from .forms import BasicConfigForm
djconfig.register(BasicConfigForm)
def register_config(self):
import djconfig
from .forms import HackerspaceConfigForm
djconfig.register(HackerspaceConfigForm)
#-*- coding: utf-8 -*-
from django.conf.urls import patterns, include, url
import djconfig
from spirit.forms.admin import BasicConfigForm
# TODO: use app loader in django 1.7
djconfig.register(BasicConfigForm)
urlpatterns = patterns('',
url(r'^$', 'spirit.views.topic.topics_active', name='index'),
url(r'^st/admin/', include('spirit.urls.admin')),
url(r'^category/', include('spirit.urls.category')),
url(r'^topic/', include('spirit.urls.topic')),
url(r'^topic/unread/', include('spirit.urls.topic_unread')),
url(r'^topic/notification/', include('spirit.urls.topic_notification')),
url(r'^topic/favorite/', include('spirit.urls.topic_favorite')),
url(r'^topic/private/', include('spirit.urls.topic_private')),
url(r'^comment/', include('spirit.urls.comment')),
url(r'^comment/bookmark/', include('spirit.urls.comment_bookmark')),
url(r'^comment/flag/', include('spirit.urls.comment_flag')),
url(r'^comment/history/', include('spirit.urls.comment_history')),
url(r'^comment/like/', include('spirit.urls.comment_like')),
url(r'^user/', include('spirit.urls.user')),
url(r'^search/', include('spirit.urls.search')),
)
def ready(self):
# needed for using Admin in runserver
from .tests import BarConfigAdminForm, BazConfigAdminForm
djconfig.register(BarConfigAdminForm)
djconfig.register(BazConfigAdminForm)
