Merge lp:~ricardokirkner/django-configglue/770093-schema-introspection into lp:django-configglue

[Ricardo Kirkner]

changed default behaviour to automatically create a schema if the requested one is not found

Overview
========

changed default behaviour to automatically create a schema if none is found

Details
=======

The DjangoSchemaFactory class has been given a utility method to build a
schema out of a dictionary of options. Using this utility, the .get method can
dynamically create a new schema when the requested one is not found, instead
of having to fallback to previous schema versions.

The default behaviour has thus been changed to allow the DjangoSchemaFactory
to create a schema dynamically if the requested one is not found.

[lp:~ricardokirkner/django-configglue/770093-schema-introspection]

56. By Ricardo Kirkner on 2011-07-12

handle inner item type for complex types

DictOption and ListOption can be passed an item parameter to parse individual
items. Detect this item type when building a schema dynamically.

57. By Ricardo Kirkner on 2011-07-12

maintain existing default behaviour on DjangoSchemaFactory.get

58. By Ricardo Kirkner on 2011-07-14

moved helpers for tests schemas to a separate testcase

59. By Ricardo Kirkner on 2011-07-14

make sure schema is generated correctly

- added a test for comparing the generated schema for a known version against the
  defined schema for that version.
- triggered a cascade of errors which resulted in several updates to the tests
  and schema options defaults.
- fixed incorrect propagation of deprecated options due to schema inheritance

60. By Ricardo Kirkner on 2011-07-14

properly remove deprecated CACHE_BACKEND setting

61. By Ricardo Kirkner on 2011-07-14

added missing tests

[Anthony Lenton (elachuni)]

Neat!

review: Approve

=== modified file 'django_configglue/schema.py'
--- django_configglue/schema.py	2011-06-27 20:05:32 +0000
+++ django_configglue/schema.py	2011-07-14 03:16:30 +0000
@@ -1,5 +1,6 @@
 # Copyright 2010 Canonical Ltd.  This software is licensed under the
 # GNU Lesser General Public License version 3 (see the file LICENSE).
+import inspect
 import logging
 
 from configglue.pyschema.schema import (
@@ -13,6 +14,8 @@
     TupleOption,
 )
 from django import get_version
+from django.conf import global_settings
+from django.conf.project_template import settings as project_settings
 
 
 # As in django.conf.global_settings:
@@ -32,6 +35,32 @@
         return result
 
 
+def derivate_django_schema(schema, exclude=None):
+    """Return a modified version of a schema.
+
+    The source schema *must* have a 'version' attribute and
+    a 'django' section.
+
+    The resulting schema is almost a copy of the original one, except
+    for excluded options in the 'django' section.
+    """
+    if not exclude:
+        return schema
+
+    # create the schema class
+    cls = type(schema.__name__, (schema,), {'version': schema.version})
+    # include all non-excluded options
+    options = {}
+    for option in schema().django.options():
+        if option.name in exclude:
+            continue
+        options[option.name] = option
+    # create the 'django' section
+    django_section = type('django', (Section,), options)
+    setattr(cls, 'django', django_section)
+    return cls
+
+
 class BaseDjangoSchema(Schema):
     version = '1.0.2 final'
 
@@ -53,7 +82,7 @@
             help="Whether to use the 'Etag' header. This saves bandwidth but "
                  "slows down performance.")
 
-        admins = ListOption(item=TupleOption(2), default=[],
+        admins = ListOption(item=TupleOption(length=2), default=[],
             help="People who get code error notifications. In the format "
                  "(('Full Name', '[e-mail]'), "
                  "('Full Name', '[e-mail]'))")
@@ -136,7 +165,7 @@
         locale_paths = ListOption(item=StringOption())
         language_cookie_name = StringOption(default='django_language')
 
-        managers = ListOption(item=TupleOption(2), default=[],
+        managers = ListOption(item=TupleOption(length=2), default=[],
             help="Not-necessarily-technical managers of the site. They get broken "
                  "link notifications and other various e-mails")
 
@@ -464,14 +493,18 @@
         ####################
 
         site_id = IntOption(default=1)
-        root_urlconf = StringOption(default='urls')
-
-
-class Django112Schema(BaseDjangoSchema):
+        root_urlconf = StringOption(default='{{ project_name }}.urls')
+
+
+Django112Base = derivate_django_schema(
+    BaseDjangoSchema, exclude=['jing_path'])
+
+
+class Django112Schema(Django112Base):
     version = '1.1.2'
 
     # sections
-    class django(BaseDjangoSchema.django):
+    class django(Django112Base.django):
 
         ################
         # CORE         #
@@ -483,7 +516,7 @@
             help="Languages we provide translations for, out of the box. "
                  "The language name should be the utf-8 encoded local name "
                  "for the language",
-            default = [
+            default=[
                 ('ar', gettext_noop('Arabic')),
                 ('bg', gettext_noop('Bulgarian')),
                 ('bn', gettext_noop('Bengali')),
@@ -558,7 +591,7 @@
             help="Languages we provide translations for, out of the box. "
                  "The language name should be the utf-8 encoded local name "
                  "for the language",
-            default = [
+            default=[
                 ('ar', gettext_noop('Arabic')),
                 ('bg', gettext_noop('Bulgarian')),
                 ('bn', gettext_noop('Bengali')),
@@ -637,6 +670,16 @@
                 'host': StringOption(),
                 'port': StringOption(),
             }),
+            default={
+                'default': {
+                    'ENGINE': 'django.db.backends.',
+                    'NAME': '',
+                    'USER': '',
+                    'PASSWORD': '',
+                    'HOST': '',
+                    'PORT': '',
+                }
+            }
         )
         database_routers = ListOption(
             item=StringOption(),
@@ -651,7 +694,7 @@
 
         installed_apps = ListOption(item=StringOption(),
             help="List of strings representing installed apps",
-            default = [
+            default=[
                 'django.contrib.auth',
                 'django.contrib.contenttypes',
                 'django.contrib.sessions',
@@ -662,7 +705,7 @@
         template_loaders = ListOption(item=StringOption(),
             help="List of callables that know how to import templates from "
                  "various sources",
-            default = [
+            default=[
                 'django.template.loaders.filesystem.Loader',
                 'django.template.loaders.app_directories.Loader',
             ])
@@ -673,7 +716,7 @@
                  "context. Each one should be a callable that takes the request "
                  "object as its only parameter and returns a dictionary to add to "
                  "the context",
-            default = [
+            default=[
                 'django.contrib.auth.context_processors.auth',
                 'django.core.context_processors.debug',
                 'django.core.context_processors.i18n',
@@ -696,34 +739,34 @@
         date_input_formats = ListOption(
             item=StringOption(),
             default=[
-                '%%Y-%%m-%%d', '%%m/%%d/%%Y', '%%m/%%d/%%y', # '2006-10-25', '10/25/2006', '10/25/06'
-                '%%b %%d %%Y', '%%b %%d, %%Y',               # 'Oct 25 2006', 'Oct 25, 2006'
-                '%%d %%b %%Y', '%%d %%b, %%Y',               # '25 Oct 2006', '25 Oct, 2006'
-                '%%B %%d %%Y', '%%B %%d, %%Y',               # 'October 25 2006', 'October 25, 2006'
-                '%%d %%B %%Y', '%%d %%B, %%Y',               # '25 October 2006', '25 October, 2006'
+                '%Y-%m-%d', '%m/%d/%Y', '%m/%d/%y', # '2006-10-25', '10/25/2006', '10/25/06'
+                '%b %d %Y', '%b %d, %Y',               # 'Oct 25 2006', 'Oct 25, 2006'
+                '%d %b %Y', '%d %b, %Y',               # '25 Oct 2006', '25 Oct, 2006'
+                '%B %d %Y', '%B %d, %Y',               # 'October 25 2006', 'October 25, 2006'
+                '%d %B %Y', '%d %B, %Y',               # '25 October 2006', '25 October, 2006'
             ],
             help="Default formats to be used when parsing dates from input "
                 "boxes, in order")
         time_input_formats = ListOption(
             item=StringOption(),
             default=[
-                '%%H:%%M:%%S',     # '14:30:59'
-                '%%H:%%M',         # '14:30'
+                '%H:%M:%S',     # '14:30:59'
+                '%H:%M',         # '14:30'
             ],
             help="Default formats to be used when parsing times from input "
                 "boxes, in order")
         datetime_input_formats = ListOption(
             item=StringOption(),
             default=[
-                '%%Y-%%m-%%d %%H:%%M:%%S',     # '2006-10-25 14:30:59'
-                '%%Y-%%m-%%d %%H:%%M',         # '2006-10-25 14:30'
-                '%%Y-%%m-%%d',                 # '2006-10-25'
-                '%%m/%%d/%%Y %%H:%%M:%%S',     # '10/25/2006 14:30:59'
-                '%%m/%%d/%%Y %%H:%%M',         # '10/25/2006 14:30'
-                '%%m/%%d/%%Y',                 # '10/25/2006'
-                '%%m/%%d/%%y %%H:%%M:%%S',     # '10/25/06 14:30:59'
-                '%%m/%%d/%%y %%H:%%M',         # '10/25/06 14:30'
-                '%%m/%%d/%%y',                 # '10/25/06'
+                '%Y-%m-%d %H:%M:%S',      # '2006-10-25 14:30:59'
+                '%Y-%m-%d %H:%M',         # '2006-10-25 14:30'
+                '%Y-%m-%d',               # '2006-10-25'
+                '%m/%d/%Y %H:%M:%S',      # '10/25/2006 14:30:59'
+                '%m/%d/%Y %H:%M',         # '10/25/2006 14:30'
+                '%m/%d/%Y',               # '10/25/2006'
+                '%m/%d/%y %H:%M:%S',      # '10/25/06 14:30:59'
+                '%m/%d/%y %H:%M',         # '10/25/06 14:30'
+                '%m/%d/%y',               # '10/25/06'
             ],
             help="Default formats to be used when parsing dates and times "
                 "from input boxes, in order")
@@ -757,7 +800,7 @@
                  "request phase, these middleware classes will be applied in the "
                  "order given, and in the response phase the middleware will be "
                  "applied in reverse order",
-            default = [
+            default=[
                 'django.middleware.common.CommonMiddleware',
                 'django.contrib.sessions.middleware.SessionMiddleware',
                 'django.middleware.csrf.CsrfViewMiddleware',
@@ -798,11 +841,15 @@
             help="The name of the class to use to run the test suite")
 
 
-class Django13Schema(Django125Schema):
+Django13Base = derivate_django_schema(
+    Django125Schema, exclude=['cache_backend'])
+
+
+class Django13Schema(Django13Base):
     version = '1.3'
 
     # sections
-    class django(Django125Schema.django):
+    class django(Django13Base.django):
 
         ################
         # CORE         #
@@ -814,7 +861,7 @@
             help="Languages we provide translations for, out of the box. "
                  "The language name should be the utf-8 encoded local name "
                  "for the language",
-            default = [
+            default=[
                 ('ar', gettext_noop('Arabic')),
                 ('az', gettext_noop('Azerbaijani')),
                 ('bg', gettext_noop('Bulgarian')),
@@ -884,13 +931,24 @@
                 ('zh-tw', gettext_noop('Traditional Chinese')),
             ])
 
+        installed_apps = ListOption(item=StringOption(),
+            help="List of strings representing installed apps",
+            default=[
+                'django.contrib.auth',
+                'django.contrib.contenttypes',
+                'django.contrib.sessions',
+                'django.contrib.sites',
+                'django.contrib.messages',
+                'django.contrib.staticfiles',
+            ])
+
         template_context_processors = ListOption(
             item=StringOption(),
             help="List of processors used by RequestContext to populate the "
                  "context. Each one should be a callable that takes the request "
                  "object as its only parameter and returns a dictionary to add to "
                  "the context",
-            default = [
+            default=[
                 'django.contrib.auth.context_processors.auth',
                 'django.core.context_processors.debug',
                 'django.core.context_processors.i18n',
@@ -904,7 +962,7 @@
             help='Absolute path to the directory that holds static files.')
 
         static_url = StringOption(
-            null=True, default=None,
+            null=True, default='/static/',
             help='URL that handles the static files served from STATIC_ROOT.')
 
         ############
@@ -919,9 +977,6 @@
         # CACHE #
         #########
 
-        # remove obsoleted setting
-        cache_backend = None
-
         caches = DictOption()
         cache_middleware_alias = StringOption(default='default')
 
@@ -1010,25 +1065,84 @@
         self._schemas[version] = schema_cls
 
     def get(self, version, strict=True):
-        if version not in self._schemas:
-            msg = "No schema registered for version %r" % version
-            if strict:
-                raise ValueError(msg)
+        if version in self._schemas:
+            return self._schemas[version]
+
+        msg = "No schema registered for version %r" % version
+        if strict:
+            raise ValueError(msg)
+        else:
+            logging.warn(msg)
+
+        logging.warn("Dynamically creating schema for version %r" % version)
+        schema = self.build(version)
+        return schema
+
+    def build(self, version_string=None, options=None):
+        if version_string is None:
+            version_string = get_version()
+        if options is None:
+            options = dict([(name.lower(), value) for (name, value) in
+                inspect.getmembers(global_settings) if name.isupper()])
+            project_options = dict([(name.lower(), value) for (name, value) in
+                inspect.getmembers(project_settings) if name.isupper()])
+            options.update(project_options)
+
+        class DjangoSchema(Schema):
+            version = version_string
+
+            class django(Section):
+                pass
+
+        def get_option_type(name, value):
+            type_mappings = {
+                int: IntOption,
+                bool: BoolOption,
+                list: ListOption,
+                tuple: TupleOption,
+                dict: DictOption,
+                str: StringOption,
+                unicode: StringOption,
+            }
+            if value is None:
+                return StringOption(name=name, default=value, null=True)
             else:
-                logging.warn(msg)
-
-            versions = sorted(self._schemas.keys())
-            if not versions:
-                raise ValueError("No schemas registered")
-
-            last = versions[0]
-            for v in sorted(self._schemas.keys()):
-                if version < v:
-                    break
-                last = v
-            version = last
-            logging.warn("Falling back to schema for version %r" % version)
-        return self._schemas[version]
+                option_type = type_mappings[type(value)]
+                kwargs = {'name': name, 'default': value}
+
+                if option_type in (DictOption, ListOption):
+                    # get inner item type
+                    if option_type == DictOption:
+                        items = value.values()
+                    else:
+                        items = value
+
+                    item_type = None
+                    if items:
+                        item_type = type_mappings.get(type(items[0]), None)
+                        # make sure all items have a consistent type
+                        for item in items:
+                            current_item_type = type_mappings.get(
+                                type(item), None)
+                            if current_item_type != item_type:
+                                item_type = None
+                                # mismatching types found. fallback to default
+                                # item type
+                                break
+                    if item_type is not None:
+                        kwargs['item'] = item_type()
+
+                return option_type(**kwargs)
+
+        for name, value in options.items():
+            if name == '__CONFIGGLUE_PARSER__':
+                continue
+            option = get_option_type(name, value)
+            setattr(DjangoSchema.django, name, option)
+
+        # register schema for it to be available during next query
+        self.register(DjangoSchema, version_string)
+        return DjangoSchema
 
 
 schemas = DjangoSchemaFactory()

=== modified file 'django_configglue/tests/helpers.py'
--- django_configglue/tests/helpers.py	2011-04-13 17:06:30 +0000
+++ django_configglue/tests/helpers.py	2011-07-14 03:16:30 +0000
@@ -11,6 +11,12 @@
 from django.conf import settings
 from django.test import TestCase
 
+from configglue.pyschema.schema import (
+    ListOption,
+    TupleOption,
+    Schema,
+)
+
 
 class ConfigGlueDjangoCommandTestCase(TestCase):
     COMMAND = ''
@@ -118,3 +124,54 @@
         finally:
             self.end_capture()
 
+
+class SchemaHelperTestCase(TestCase):
+    def assert_schema_structure(self, schema_cls, version, options):
+        self.assertTrue(issubclass(schema_cls, Schema))
+        self.assertEqual(schema_cls.version, 'bogus')
+
+        schema = schema_cls()
+
+        # assert sections
+        section_names = [section.name for section in schema.sections()]
+        self.assertEqual(section_names, ['django'])
+        # assert options for django section
+        option_names = [option.name for option in schema.options('django')]
+        self.assertEqual(option_names, options.keys())
+        # assert options
+        for name, value in options.items():
+            option = schema.section('django').option(name)
+            self.assertEqual(type(option), type(value))
+            self.assertEqual(option.default, value.default)
+
+    def assert_schemas_equal(self, this, other):
+        # compare schemas
+        this_sections = sorted(
+            [section.name for section in this.sections()])
+        other_sections = sorted(
+            [section.name for section in other.sections()])
+        self.assertEqual(this_sections, other_sections)
+        self.assertEqual(this_sections, ['django'])
+
+        # compare options
+        section = this.section('django')
+        expected_section = other.section('django')
+        options = section.options()
+
+        this_options = sorted(
+            [option.name for option in options])
+        other_options = sorted(
+            [option.name for option in expected_section.options()])
+        self.assertEqual(this_options, other_options)
+
+        for option in options:
+            expected_option = expected_section.option(option.name)
+            # handle special case for list/tuple
+            # django defaults to tuples for options it defines as lists
+            if (isinstance(option, (ListOption, TupleOption)) or
+                    isinstance(expected_option, (ListOption, TupleOption))):
+                self.assertEqual(list(option.default),
+                    list(expected_option.default))
+            else:
+                self.assertEqual(option.default,
+                    expected_option.default)

=== modified file 'django_configglue/tests/test_configglue.py'
--- django_configglue/tests/test_configglue.py	2011-07-10 15:16:26 +0000
+++ django_configglue/tests/test_configglue.py	2011-07-14 03:16:30 +0000
@@ -2,22 +2,29 @@
 # Copyright 2010 Canonical Ltd.  This software is licensed under the
 # GNU Lesser General Public License version 3 (see the file LICENSE).
 
+import inspect
 import textwrap
 from cStringIO import StringIO
 from unittest import TestCase
 
 import django
 from configglue.pyschema.schema import (
+    BoolOption,
     DictOption,
     IntOption,
+    ListOption,
     Schema,
+    Section,
     StringOption,
+    TupleOption,
 )
 from configglue.pyschema.parser import (
     CONFIG_FILE_ENCODING,
     SchemaConfigParser,
 )
 from django.conf import settings
+from django.conf import global_settings
+from django.conf.project_template import settings as project_settings
 from mock import patch
 
 from django_configglue.management import GlueManagementUtility
@@ -32,11 +39,15 @@
     DjangoSchemaFactory,
     UpperCaseDictOption,
     schemas,
-)
-from django_configglue.tests.helpers import ConfigGlueDjangoCommandTestCase
-
-
-class DjangoSupportTestCase(TestCase):
+    derivate_django_schema,
+)
+from django_configglue.tests.helpers import (
+    ConfigGlueDjangoCommandTestCase,
+    SchemaHelperTestCase,
+)
+
+
+class DjangoSupportTestCase(SchemaHelperTestCase):
     def test_get_django_settings(self):
         class MySchema(Schema):
             foo = IntOption()
@@ -79,62 +90,11 @@
 
     def test_schemafactory_get(self):
         # test get valid version
-        self.assertEqual(schemas.get('1.0.2 final'), BaseDjangoSchema)
+        self.assertEqual(schemas.get('1.0.2 final', strict=True),
+            BaseDjangoSchema)
 
         # test get invalid version
-        self.assertRaises(ValueError, schemas.get, '1.1')
-
-    @patch('django_configglue.schema.logging')
-    def test_schemafactory_get_nonexisting_too_old(self, mock_logging):
-        schema = schemas.get('0.96', strict=False)
-
-        django_102 = schemas.get('1.0.2 final')
-        self.assertEqual(schema, django_102)
-        self.assertRaises(ValueError, schemas.get, '0.96')
-
-        self.assertEqual(mock_logging.warn.call_args_list[0][0][0],
-            "No schema registered for version '0.96'")
-        self.assertEqual(mock_logging.warn.call_args_list[1][0][0],
-            "Falling back to schema for version '1.0.2 final'")
-
-    @patch('django_configglue.schema.logging')
-    def test_schemafactory_get_nonexisting(self, mock_logging):
-        schema = schemas.get('1.0.3', strict=False)
-
-        django_102 = schemas.get('1.0.2 final')
-        self.assertEqual(schema, django_102)
-        self.assertRaises(ValueError, schemas.get, '1.0.3')
-
-        self.assertEqual(mock_logging.warn.call_args_list[0][0][0],
-            "No schema registered for version '1.0.3'")
-        self.assertEqual(mock_logging.warn.call_args_list[1][0][0],
-            "Falling back to schema for version '1.0.2 final'")
-
-    @patch('django_configglue.schema.logging')
-    def test_schemafactory_get_nonexisting_too_new(self, mock_logging):
-        schema = schemas.get('1.2.0', strict=False)
-
-        django_112 = schemas.get('1.1.4')
-        self.assertEqual(schema, django_112)
-        self.assertRaises(ValueError, schemas.get, '1.2.0')
-
-        self.assertEqual(mock_logging.warn.call_args_list[0][0][0],
-            "No schema registered for version '1.2.0'")
-        self.assertEqual(mock_logging.warn.call_args_list[1][0][0],
-            "Falling back to schema for version '1.1.4'")
-
-    @patch('django_configglue.schema.logging')
-    def test_schemafactory_get_no_versions_registered(self, mock_logging):
-        schemas = DjangoSchemaFactory()
-        try:
-            schemas.get('1.0.2 final', strict=False)
-        except ValueError, e:
-            self.assertEqual(str(e), "No schemas registered")
-        else:
-            self.fail("ValueError not raised")
-
-        mock_logging.warn.assert_called_with(
-            "No schema registered for version '1.0.2 final'")
+        self.assertRaises(ValueError, schemas.get, '1.1', strict=True)
 
     def test_schema_versions(self):
         django_102 = schemas.get('1.0.2 final')()
@@ -176,6 +136,133 @@
         mock_update_settings.assert_called_with(
             MockSchemaConfigParser.return_value, target)
 
+    def test_schemafactory_build(self):
+        schemas = DjangoSchemaFactory()
+
+        data = [
+            (IntOption, 1),
+            (BoolOption, True),
+            (TupleOption, (1, 2)),
+            (ListOption, [1, 2]),
+            (DictOption, {'a': 1}),
+            (StringOption, 'foo'),
+        ]
+
+        for opt_type, default in data:
+            schema_cls = schemas.build('bogus', {'foo': default})
+            # do common checks
+            self.assert_schema_structure(schema_cls, 'bogus',
+                {'foo': opt_type(name='foo', default=default)})
+
+    def test_schemafactory_build_django(self):
+        schemas = DjangoSchemaFactory()
+
+        schema = schemas.build()
+        # get known django schema
+        # fail for unknown versions of django
+        django_schema = schemas.get(django.get_version(), strict=True)
+
+        self.assert_schemas_equal(schema(), django_schema())
+
+    def test_schemafactory_get_django(self):
+        schemas = DjangoSchemaFactory()
+
+        # build a django schema
+        # get only django settings
+        options = dict([(name, value) for (name, value) in
+            inspect.getmembers(settings) if name.isupper()])
+        schema = schemas.build(django.get_version(), options)
+        # get known django schema
+        # fail for unknown versions of django
+        django_schema = schemas.get(django.get_version(), strict=True)
+
+        self.assert_schemas_equal(schema(), django_schema())
+
+    def test_schemafactory_build_complex_options(self):
+        schemas = DjangoSchemaFactory()
+
+        options = {
+            'dict1': {'foo': 1, 'bar': '2'},
+            'dict2': {'foo': {'bar': 2, 'baz': 3}},
+            'list1': ['1', '2', '3'],
+            'list2': [1, 2, 3],
+        }
+        expected = {
+            'dict1': DictOption(name='dict1', default=options['dict1'],
+                                item=StringOption()),
+            'dict2': DictOption(name='dict2', default=options['dict2'],
+                                item=DictOption()),
+            'list1': ListOption(name='list1', default=options['list1'],
+                                item=StringOption()),
+            'list2': ListOption(name='list2', default=options['list2'],
+                                item=IntOption()),
+        }
+
+        schema = schemas.build('foo', options)()
+
+        sections = sorted(
+            [section.name for section in schema.sections()])
+        section = schema.section('django')
+        self.assertEqual(sections, ['django'])
+
+        for name in options:
+            option = expected[name]
+            option.section = section
+            self.assertEqual(section.option(name), option)
+            self.assertEqual(section.option(name).item, option.item)
+
+    @patch('django_configglue.schema.logging')
+    def test_schemafactory_get_unknown_build(self, mock_logging):
+        schemas = DjangoSchemaFactory()
+        version_string = django.get_version()
+        self.assertFalse(version_string in schemas._schemas)
+
+        # build schema
+        schema = schemas.get(version_string, strict=False)()
+        # get expected schema
+        options = dict([(name.lower(), value) for (name, value) in
+            inspect.getmembers(global_settings) if name.isupper()])
+        project_options = dict([(name.lower(), value) for (name, value) in
+            inspect.getmembers(project_settings) if name.isupper()])
+        options.update(project_options)
+        expected = schemas.build(django.get_version(), options)()
+
+        # compare schemas
+        self.assert_schemas_equal(schema, expected)
+
+        self.assertEqual(mock_logging.warn.call_args_list[0][0][0],
+            "No schema registered for version '{0}'".format(version_string))
+        self.assertEqual(mock_logging.warn.call_args_list[1][0][0],
+            "Dynamically creating schema for version '{0}'".format(
+                version_string))
+
+    def test_derivate_django_schema(self):
+        class Parent(Schema):
+            version = 'parent'
+
+            class django(Section):
+                foo = IntOption()
+                bar = IntOption()
+
+        class Child(Parent):
+            version = 'parent'
+
+            class django(Section):
+                bar = IntOption()
+
+        derivated = derivate_django_schema(Parent, exclude=['foo'])
+        self.assert_schemas_equal(derivated(), Child())
+
+    def test_derivate_django_schema_no_exclude(self):
+        class Parent(Schema):
+            version = 'parent'
+
+            class django(Section):
+                foo = IntOption()
+
+        derivated = derivate_django_schema(Parent)
+        self.assertEqual(derivated, Parent)
+
 
 class GlueManagementUtilityTestCase(ConfigGlueDjangoCommandTestCase):
     def setUp(self):

=== modified file 'django_configglue/tests/test_settings.py'
--- django_configglue/tests/test_settings.py	2011-04-13 17:06:30 +0000
+++ django_configglue/tests/test_settings.py	2011-07-14 03:16:30 +0000
@@ -9,7 +9,10 @@
 from django.core.management import ManagementUtility
 
 from django_configglue.utils import SETTINGS_ENCODING
-from django_configglue.tests.helpers import ConfigGlueDjangoCommandTestCase
+from django_configglue.tests.helpers import (
+    ConfigGlueDjangoCommandTestCase,
+    SchemaHelperTestCase,
+)
 
 
 class SettingsCommandTestCase(ConfigGlueDjangoCommandTestCase):
@@ -31,7 +34,7 @@
 
     def test_show(self):
         expected_values = [
-            "ROOT_URLCONF = 'urls'",
+            "ROOT_URLCONF = '{{ project_name }}.urls'",
             "SITE_ID = 1",
             "SETTINGS_MODULE = 'django_configglue.tests.settings'",
             "SETTINGS_ENCODING = '%s'" % SETTINGS_ENCODING,
@@ -39,8 +42,6 @@
         django_version = django.VERSION[:2]
         if django_version == (1, 1):
             expected_values.append("DATABASE_SUPPORTS_TRANSACTIONS = True")
-        if django_version >= (1, 1):
-            expected_values.append("JING_PATH = '/usr/bin/jing'")
         self.call_command(show_current=True)
         output_lines = self.capture['stdout'].strip().split('\n')
         self.assertEqual(set(expected_values), set(output_lines))
@@ -108,6 +109,34 @@
         self.assertEqual(self.wrapped_settings, expected)
 
 
+class GeneratedSettingsTestCase(ConfigGlueDjangoCommandTestCase,
+        SchemaHelperTestCase):
+    def setUp(self):
+        from django_configglue.schema import schemas
+        from mock import patch, Mock
+
+        self.expected_schema = schemas.get(
+            django.get_version(), strict=True)()
+
+        mock_get_version = Mock(return_value='foo')
+        self.patch = patch(
+            'django_configglue.tests.settings.django.get_version',
+            mock_get_version)
+        self.patch.start()
+        super(GeneratedSettingsTestCase, self).setUp()
+
+    def tearDown(self):
+        self.patch.stop()
+        super(GeneratedSettingsTestCase, self).tearDown()
+
+    def test_generated_schema(self):
+        # import here so that the necessary modules can be mocked before
+        # being required
+        from django.conf import settings
+        schema = settings.__CONFIGGLUE_PARSER__.schema
+        self.assert_schemas_equal(schema, self.expected_schema)
+
+
 class ValidateCommandTestCase(ConfigGlueDjangoCommandTestCase):
     COMMAND = 'settings'