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_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_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_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_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_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_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_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_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_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 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)
#-*- 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')), )