Ticket #3222: 3222-newforms-admin.patch

django/contrib/admin/options.py

@@ -113 +113 @@
     prepopulated_fields = {}
     filter_vertical = ()
     filter_horizontal = ()
+    option_errors = None
 
     def __init__(self, model):
         self.model = model
@@ -117 +118 @@
     def __init__(self, model):
         self.model = model
         self.opts = model._meta
+        self.validate_options()
 
     def __call__(self, request, url):
         # Check that LogEntry, ContentType and the auth context processor are installed.
@@ -264 +266 @@
 
     def change_list_queryset(self, request):
         return self.model._default_manager.get_query_set()
+    
+    def validate_options(self):
+        """
+        Hook for validating admin options, returns a list of all errors.
+        """
+        opts = self.opts
+        cls = self.model
+        errors = self.option_errors = []
+        model_fields = [f.name for f in opts.fields + opts.many_to_many]
+        model_attr = dir(cls)
+        
+        # helper lambda functions to write out common errors
+        listError = lambda option: errors.append('"%s", if given, must be set to a list or tuple.' % option)
+        dictError = lambda option: errors.append('"%s", if given, must be a dictionary.' % option)
+        boolError = lambda option: errors.append('"%s", if given, must be set to True or False.' % option)
+        intError = lambda option: errors.append('"%s", if given, must be a positive integer.' % option)
+        twoTupleError = lambda option: errors.append('"%s", if given, must be a list or tuple of 2-tuples.' % option)
+        fieldError = lambda option, fn: errors.append('"%(opt_name)s" refers to %(field_name)r, which is not a field.' % {'opt_name': option, 'field_name': fn})
+        fieldAttrError = lambda option, fn: errors.append('"%(opt_name)s" refers to %(field_name)r, which is not an attribute, method or property.' % {'opt_name': option, 'field_name': fn})
+        dateFieldError = lambda option, fn: errors.append('"%(opt_name)s" refers to %(field_name)r, which is not a DateField or DateTimeField.' % {'opt_name': option, 'field_name': fn})
+        m2mFieldError = lambda option, fn: errors.append('"%(opt_name)s" does not support ManyToMany fields %(field_name)r.' % {'opt_name': option, 'field_name': fn})
+        listDisplayError = lambda option, fn: errors.append('"%(opt_name)s" refers to %(field_name)r, which is not defined in "list_display".' % {'opt_name': option, 'field_name': fn})
+        missingFieldOptError = lambda option: errors.append('"fields", field_options dict %r must include a fields option.' % option)
+        
+        # helper lambda functions to check if item is valid
+        checkField = lambda fn: fn in model_fields
+        checkAttrField = lambda fn: fn in (model_fields + model_attr)
+        
+        def __recursiveCheckField(item, option):
+            """Recursive helper function checks all nested lists/tuples for valid fields"""
+            if isinstance(item, (list, tuple)):
+                [__recursiveCheckField(fn, option) for fn in item]
+            elif not checkField(item):
+                fieldError(option, item)
+                        
+        # prepopulated_fields
+        if not isinstance(self.prepopulated_fields, dict):
+            dictError('prepopulated_fields')
+        else:
+            for field_name, field_list in self.prepopulated_fields.items():
+                if not checkField(field_name):
+                    fieldError('prepopulated_fields', field_name)
+                if not isinstance(field_list, (list, tuple)):
+                    listError('prepopulated_fields - dependencies')
+                else:
+                    [fieldError('prepopulated_fields', fn) for fn in field_list if not checkField(fn)]
+
+        #fields               
+        if self.fields:
+            if not isinstance(self.fields, (list, tuple)):
+                listError('fields')
+            else:
+                try:
+                    for name, options in self.fields:
+                        if not isinstance(options, dict):
+                            dictError('fields - field_options')
+                        else:
+                            field_tuple = options.get('fields', None)
+                            if not field_tuple:
+                                missingFieldOptError(options)
+                            elif not isinstance(field_tuple, (list, tuple)):
+                                listError('fields - fieldset')
+                            else:
+                                __recursiveCheckField(field_tuple, 'fields')
+                except ValueError:
+                    twoTupleError('fields')
+                    
+        #list_display
+        if not isinstance(self.list_display, (list, tuple)):
+            listError('list_display')
+        else:
+            for fn in self.list_display:
+                if not checkAttrField(fn):
+                    fieldAttrError('list_display', fn)
+                elif checkField(fn) and isinstance(opts.get_field(fn), models.ManyToManyField):
+                    m2mFieldError('list_display', fn)
+        
+        #list_display_links
+        if not isinstance(self.list_display_links, (list, tuple)):
+            listError('list_display_links')
+        else:
+            for fn in self.list_display_links:
+                if fn not in self.list_display:
+                    listDisplayError('list_display_links', fn)
 
+        #list_filter
+        if not isinstance(self.list_filter, (list, tuple)):
+            listError('list_filter')
+        else:
+            [fieldError('list_filter', fn) for fn in self.list_filter if not checkField(fn)]
+        
+        #date_hierarchy
+        if self.date_hierarchy:
+            if not checkField(self.date_hierarchy):
+                fieldError('date_hierarchy', self.date_hierarchy)
+            elif not isinstance(opts.get_field(self.date_hierarchy), (models.DateField, models.DateTimeField)):
+                dateFieldError('date_hierarchy', self.date_hierarchy)
+        
+        #search_fields
+        if not isinstance(self.search_fields, (list, tuple)):
+            listError('search_fields')
+        else:
+            # search_fields can use the related lookup API 'follow' notation.
+            [fieldError('search_fields', fn) for fn in self.search_fields if not checkField(fn.split('__')[0])]
+        
+        #raw_id_fields
+        if not isinstance(self.raw_id_fields, (list, tuple)):
+            listError('raw_id_fields')
+        else:
+            [fieldError('raw_id_fields', fn) for fn in self.raw_id_fields if not checkField(fn)]
+        
+        #filter_vertical
+        if not isinstance(self.filter_vertical, (list, tuple)):
+            listError('filter_vertical')
+        else:
+            [fieldError('filter_vertical', fn) for fn in self.filter_vertical if not checkField(fn)]
+                   
+        #filter_horizontal
+        if not isinstance(self.filter_horizontal, (list, tuple)):
+            listError('filter_horizontal')
+        else:
+            [fieldError('filter_horizontal', fn) for fn in self.filter_horizontal if not checkField(fn)]
+                   
+        #js
+        if self.js and not isinstance(self.js, (list, tuple)):
+            listError('js')
+        
+        #save_as
+        if self.save_as not in (True, False):
+            boolError('save_as')
+        
+        #save_on_top
+        if self.save_on_top not in (True, False):
+            boolError('save_on_top')
+            
+        #list_select_related
+        if self.list_select_related not in (True, False):
+            boolError('list_select_related')
+            
+        #list_per_page
+        try:
+            if int(self.list_per_page) < 0:
+                intError('list_per_page')
+        except ValueError:
+            intError('list_per_page')
+        
+        #ordering
+        if self.ordering:
+            if not isinstance(self.ordering, (list, tuple)):
+                listError('ordering')
+            else:
+                for fn in self.ordering:
+                    if fn.startswith('-'):
+                        fn = fn.split('-')[1]
+                    if not checkField(fn):
+                        fieldError('ordering', fn)
+        
     def add_view(self, request, form_url='', post_url_continue='../%s/'):
         "The 'add' admin view for this model."
         from django.contrib.admin.views.main import render_change_form

django/core/management.py

@@ -977 +977 @@
 
         # Check admin attribute.
         if opts.admin is not None:
-            # prepopulated_fields
-            if not isinstance(opts.admin.prepopulated_fields, dict):
-                e.add(opts, '"%s": prepopulated_fields should be a dictionary.' % f.name)
-            else:
-                for field_name, field_list in opts.admin.prepopulated_fields.items():
-                    if not isinstance(field_list, (list, tuple)):
-                        e.add(opts, '"%s": prepopulated_fields "%s" value should be a list or tuple.' % (f.name, field_name))
-
-            # list_display
-            if not isinstance(opts.admin.list_display, (list, tuple)):
-                e.add(opts, '"admin.list_display", if given, must be set to a list or tuple.')
-            else:
-                for fn in opts.admin.list_display:
-                    try:
-                        f = opts.get_field(fn)
-                    except models.FieldDoesNotExist:
-                        if not hasattr(cls, fn):
-                            e.add(opts, '"admin.list_display" refers to %r, which isn\'t an attribute, method or property.' % fn)
-                    else:
-                        if isinstance(f, models.ManyToManyField):
-                            e.add(opts, '"admin.list_display" doesn\'t support ManyToManyFields (%r).' % fn)
-            # list_display_links
-            if opts.admin.list_display_links and not opts.admin.list_display:
-                e.add(opts, '"admin.list_display" must be defined for "admin.list_display_links" to be used.')
-            if not isinstance(opts.admin.list_display_links, (list, tuple)):
-                e.add(opts, '"admin.list_display_links", if given, must be set to a list or tuple.')
-            else:
-                for fn in opts.admin.list_display_links:
-                    try:
-                        f = opts.get_field(fn)
-                    except models.FieldDoesNotExist:
-                        if not hasattr(cls, fn):
-                            e.add(opts, '"admin.list_display_links" refers to %r, which isn\'t an attribute, method or property.' % fn)
-                    if fn not in opts.admin.list_display:
-                        e.add(opts, '"admin.list_display_links" refers to %r, which is not defined in "admin.list_display".' % fn)
-            # list_filter
-            if not isinstance(opts.admin.list_filter, (list, tuple)):
-                e.add(opts, '"admin.list_filter", if given, must be set to a list or tuple.')
-            else:
-                for fn in opts.admin.list_filter:
-                    try:
-                        f = opts.get_field(fn)
-                    except models.FieldDoesNotExist:
-                        e.add(opts, '"admin.list_filter" refers to %r, which isn\'t a field.' % fn)
-            # date_hierarchy
-            if opts.admin.date_hierarchy:
-                try:
-                    f = opts.get_field(opts.admin.date_hierarchy)
-                except models.FieldDoesNotExist:
-                    e.add(opts, '"admin.date_hierarchy" refers to %r, which isn\'t a field.' % opts.admin.date_hierarchy)
+            for error in opts.admin(cls).option_errors:
+                e.add(opts, error)
 
         # Check ordering attribute.
         if opts.ordering:

tests/modeltests/invalid_models/models.py

@@ -10 +10 @@
     charfield = models.CharField()
     floatfield = models.FloatField()
     filefield = models.FileField()
-    prepopulate = models.CharField(maxlength=10, prepopulate_from='bad')
     choices = models.CharField(maxlength=10, choices='bad')
     choices2 = models.CharField(maxlength=10, choices=[(1,2,3),(1,2,3)])
     index = models.CharField(maxlength=10, db_index='bad')
@@ -101 +100 @@
 invalid_models.fielderrors: "floatfield": FloatFields require a "decimal_places" attribute.
 invalid_models.fielderrors: "floatfield": FloatFields require a "max_digits" attribute.
 invalid_models.fielderrors: "filefield": FileFields require an "upload_to" attribute.
-invalid_models.fielderrors: "prepopulate": prepopulate_from should be a list or tuple.
 invalid_models.fielderrors: "choices": "choices" should be iterable (e.g., a tuple or list).
 invalid_models.fielderrors: "choices2": "choices" should be a sequence of two-tuples.
 invalid_models.fielderrors: "choices2": "choices" should be a sequence of two-tuples.

tests/regressiontests/invalid_admin_options/models.py

@@ -15 +15 @@
     class Admin:
         list_display = 'first_name'
 
-model_errors += """invalid_admin_options.listdisplaybadone: "admin.list_display", if given, must be set to a list or tuple.
+model_errors += """invalid_admin_options.listdisplaybadone: "list_display", if given, must be set to a list or tuple.
 """
 
 class ListDisplayBadTwo(models.Model):
@@ -25 +25 @@
     class Admin:
         list_display = ['first_name','nonexistent']
 
-model_errors += """invalid_admin_options.listdisplaybadtwo: "admin.list_display" refers to 'nonexistent', which isn't an attribute, method or property.
+model_errors += """invalid_admin_options.listdisplaybadtwo: "list_display" refers to 'nonexistent', which is not an attribute, method or property.
 """        
 class ListDisplayBadThree(models.Model):
     "Test list_display, list_display items can not be a ManyToManyField."
@@ -35 +35 @@
     class Admin:
         list_display = ['first_name','nick_names']
         
-model_errors += """invalid_admin_options.listdisplaybadthree: "admin.list_display" doesn't support ManyToManyFields ('nick_names').
+model_errors += """invalid_admin_options.listdisplaybadthree: "list_display" does not support ManyToMany fields 'nick_names'.
 """ 
       
 class ListDisplayGood(models.Model):
@@ -61 +61 @@
         list_display = ['last_name']
         list_display_links = ['first_name']
 
-model_errors += """invalid_admin_options.listdisplaylinksbadone: "admin.list_display_links" refers to 'first_name', which is not defined in "admin.list_display".
+model_errors += """invalid_admin_options.listdisplaylinksbadone: "list_display_links" refers to 'first_name', which is not defined in "list_display".
 """
 
 class ListDisplayLinksBadTwo(models.Model):
@@ -73 +73 @@
         list_display = ['first_name','last_name']
         list_display_links = 'last_name'    
 
-model_errors += """invalid_admin_options.listdisplaylinksbadtwo: "admin.list_display_links", if given, must be set to a list or tuple.
+model_errors += """invalid_admin_options.listdisplaylinksbadtwo: "list_display_links", if given, must be set to a list or tuple.
 """
-
-# TODO: Fix list_display_links validation or remove the check for list_display
-## This is failing but the validation which should fail is not.
-#class ListDisplayLinksBadThree(models.Model):
-#    "Test list_display_links, must define list_display to use list_display_links."
-#    first_name = models.CharField(maxlength=30)
-#    last_name = models.CharField(maxlength=30)
-#    
-#    class Admin:
-#        list_display_links = ('first_name',)
-#
-#model_errors += """invalid_admin_options.listdisplaylinksbadthree: "admin.list_display" must be defined for "admin.list_display_links" to be used.
-#"""
         
 class ListDisplayLinksGood(models.Model):
     "Test list_display_links, Admin list_display_list can be a attribute, method or property."
@@ -111 +98 @@
     class Admin:
         list_filter = 'first_name'     
 
-model_errors += """invalid_admin_options.listfilterbadone: "admin.list_filter", if given, must be set to a list or tuple.
+model_errors += """invalid_admin_options.listfilterbadone: "list_filter", if given, must be set to a list or tuple.
 """
 
 class ListFilterBadTwo(models.Model):
@@ -128 +115 @@
     class Admin:
         list_filter = ['first_name','last_name','full_name']
 
-model_errors += """invalid_admin_options.listfilterbadtwo: "admin.list_filter" refers to 'last_name', which isn't a field.
-invalid_admin_options.listfilterbadtwo: "admin.list_filter" refers to 'full_name', which isn't a field.
+model_errors += """invalid_admin_options.listfilterbadtwo: "list_filter" refers to 'last_name', which is not a field.
+invalid_admin_options.listfilterbadtwo: "list_filter" refers to 'full_name', which is not a field.
 """
 
 class DateHierarchyBadOne(models.Model):
@@ -140 +127 @@
     class Admin:
         date_hierarchy = 'first_name'
         
-# TODO: Date Hierarchy needs to check if field is a date/datetime field.
-#model_errors += """invalid_admin_options.datehierarchybadone: "admin.date_hierarchy" refers to 'first_name', which isn't a date field or datetime field.
-#"""
+model_errors += """invalid_admin_options.datehierarchybadone: "date_hierarchy" refers to 'first_name', which is not a DateField or DateTimeField.
+"""
 
 class DateHierarchyBadTwo(models.Model):
     "Test date_hieracrhy, must be a field."
@@ -152 +138 @@
     class Admin:
         date_hierarchy = 'nonexistent'          
 
-model_errors += """invalid_admin_options.datehierarchybadtwo: "admin.date_hierarchy" refers to 'nonexistent', which isn't a field.
+model_errors += """invalid_admin_options.datehierarchybadtwo: "date_hierarchy" refers to 'nonexistent', which is not a field.
 """
 
 class DateHierarchyGood(models.Model):
@@ -170 +156 @@
     class Admin:
         search_fields = ('nonexistent')         
 
-# TODO: Add search_fields validation
-#model_errors += """invalid_admin_options.seacrhfieldsbadone: "admin.search_fields", if given, must be set to a list or tuple.
-#"""
+model_errors += """invalid_admin_options.searchfieldsbadone: "search_fields", if given, must be set to a list or tuple.
+"""
       
 class SearchFieldsBadTwo(models.Model):
     "Test search_fields, must be a field."
@@ -185 +170 @@
     class Admin:
         search_fields = ['first_name','last_name']         
 
-# TODO: Add search_fields validation
-#model_errors += """invalid_admin_options.seacrhfieldsbadone: "admin.search_fields" refers to 'last_name', which isn't a field.
-#"""
+model_errors += """invalid_admin_options.searchfieldsbadtwo: "search_fields" refers to 'last_name', which is not a field.
+"""
 
 class SearchFieldsGood(models.Model):
     "Test search_fields, must be a list or tuple."
@@ -197 +181 @@
     class Admin:
         search_fields = ['first_name','last_name']
 
+class SearchFieldsGoodTwo(models.Model):
+    "Test search_fields, related lookup API 'follow' syntax allowed."
+    first_name = models.CharField(maxlength=30)
+    last = models.ForeignKey(SearchFieldsGood)
+    
+    class Admin:
+        search_fields = ['first_name','last__last_name']
 
 class JsBadOne(models.Model):
     "Test js, must be a list or tuple"
@@ -204 +195 @@
     
     class Admin:
         js = 'test.js'
-        
-# TODO: Add a js validator
-#model_errors += """invalid_admin_options.jsbadone: "admin.js", if given, must be set to a list or tuple.
-#"""
+
+model_errors += """invalid_admin_options.jsbadone: "js", if given, must be set to a list or tuple.
+"""
 
 class SaveAsBad(models.Model):
     "Test save_as, should be True or False"
@@ -215 +205 @@
     
     class Admin:
         save_as = 'not True or False'
-
-# TODO: Add a save_as validator.       
-#model_errors += """invalid_admin_options.saveasbad: "admin.save_as", if given, must be set to True or False.
-#"""
+       
+model_errors += """invalid_admin_options.saveasbad: "save_as", if given, must be set to True or False.
+"""
 
 class SaveOnTopBad(models.Model):
     "Test save_on_top, should be True or False"
@@ -226 +215 @@
     
     class Admin:
         save_on_top = 'not True or False'
-
-# TODO: Add a save_on_top validator.       
-#model_errors += """invalid_admin_options.saveontopbad: "admin.save_on_top", if given, must be set to True or False.
-#"""
+          
+model_errors += """invalid_admin_options.saveontopbad: "save_on_top", if given, must be set to True or False.
+"""
 
 class ListSelectRelatedBad(models.Model):
     "Test list_select_related, should be True or False"
@@ -237 +225 @@
     
     class Admin:
         list_select_related = 'not True or False'
-
-# TODO: Add a list_select_related validator.       
-#model_errors += """invalid_admin_options.listselectrelatebad: "admin.list_select_related", if given, must be set to True or False.
-#"""
+     
+model_errors += """invalid_admin_options.listselectrelatedbad: "list_select_related", if given, must be set to True or False.
+"""
 
 class ListPerPageBad(models.Model):
     "Test list_per_page, should be a positive integer value."
@@ -247 +234 @@
     name = models.CharField(maxlength=30)
     
     class Admin:
-        list_per_page = 89.3
+        list_per_page = -89.3
+      
+model_errors += """invalid_admin_options.listperpagebad: "list_per_page", if given, must be a positive integer.
+"""
 
-# TODO: Add a list_per_page validator.       
-#model_errors += """invalid_admin_options.listperpagebad: "admin.list_per_page", if given, must be a positive integer.
-#"""
+class ListPerPageBadTwo(models.Model):
+    "Test list_per_page, should be a positive integer value."
+    name = models.CharField(maxlength=30)
+    
+    class Admin:
+        list_per_page = "not a number"
+      
+model_errors += """invalid_admin_options.listperpagebadtwo: "list_per_page", if given, must be a positive integer.
+"""
 
 class FieldsBadOne(models.Model):
     "Test fields, should be a tuple"
@@ -260 +256 @@
     
     class Admin:
         fields = 'not a tuple'
-
-# TODO: Add a fields validator.       
-#model_errors += """invalid_admin_options.fieldsbadone: "admin.fields", if given, must be a tuple.
-#"""
+       
+model_errors += """invalid_admin_options.fieldsbadone: "fields", if given, must be set to a list or tuple.
+"""
 
 class FieldsBadTwo(models.Model):
     """Test fields, 'fields' dict option is required."""
@@ -271 +266 @@
     last_name = models.CharField(maxlength=30)
     
     class Admin:
-        fields = ('Name', {'description': 'this fieldset needs fields'})
-        
-# TODO: Add a fields validator.       
-#model_errors += """invalid_admin_options.fieldsbadtwo: "admin.fields" each fieldset must include a 'fields' dict.
-#"""
+        fields = (('Name', {'description': 'this fieldset needs fields'}),)
+      
+model_errors += """invalid_admin_options.fieldsbadtwo: "fields", field_options dict {'description': 'this fieldset needs fields'} must include a fields option.
+"""
 
 class FieldsBadThree(models.Model):
-    """Test fields, 'classes' and 'description' are the only allowable extra dict options."""
+    """Test fields, must be a list or tuple of 2-tuples."""
     first_name = models.CharField(maxlength=30)
     last_name = models.CharField(maxlength=30)
     
@@ -283 +277 @@
     last_name = models.CharField(maxlength=30)
     
     class Admin:
-        fields = ('Name', {'fields': ('first_name','last_name'),'badoption': 'verybadoption'})
+        fields = (('Name', {'fields': ('first_name','last_name')},'badoption'),)
+       
+model_errors += """invalid_admin_options.fieldsbadthree: "fields", if given, must be a list or tuple of 2-tuples.
+"""
 
-# TODO: Add a fields validator.       
-#model_errors += """invalid_admin_options.fieldsbadthree: "admin.fields" fieldset options must be either 'classes' or 'description'.
-#"""
+class FieldsBadFour(models.Model):
+    """Test fields, 'fields' dict option must be fields."""
+    first_name = models.CharField(maxlength=30)
+    last_name = models.CharField(maxlength=30)
+    
+    class Admin:
+        fields = (
+                  ('Name', {'fields': ('first_name','nonexistent')}),
+                  (None, {'fields': ('first_name', ('also_bad','last_name'))}),
+                  (None, {'fields': ((('last_name','bad3'),'bad2'),'bad1')}),
+                  )
+       
+model_errors += """invalid_admin_options.fieldsbadfour: "fields" refers to 'nonexistent', which is not a field.
+invalid_admin_options.fieldsbadfour: "fields" refers to 'also_bad', which is not a field.
+invalid_admin_options.fieldsbadfour: "fields" refers to 'bad3', which is not a field.
+invalid_admin_options.fieldsbadfour: "fields" refers to 'bad2', which is not a field.
+invalid_admin_options.fieldsbadfour: "fields" refers to 'bad1', which is not a field.
+"""
+
+class FieldsBadFive(models.Model):
+    """Test fields, field_options must be a dict"""
+    first_name = models.CharField(maxlength=30)
+    last_name = models.CharField(maxlength=30)
+    
+    class Admin:
+        fields = (('Name', ('first_name','last_name')),)
+       
+model_errors += """invalid_admin_options.fieldsbadfive: "fields - field_options", if given, must be a dictionary.
+"""
 
 class FieldsGood(models.Model):
     "Test fields, working example"
@@ -297 +320 @@
     
     class Admin:
         fields = (
-                  ('Name', {'fields': ('first_name','last_name'),'classes': 'collapse'}),
+                  ('Name', {'fields': ('first_name','last_name'),'classes': 'collapse wide'}),
                   (None, {'fields': ('birth_day',),'description': 'enter your b-day'})
                   )
                   
@@ -302 +325 @@
                   )
                   
 class OrderingBad(models.Model):
+    "Test ordering, must be a list or tuple"
+    first_name = models.CharField(maxlength=30)
+    last_name = models.CharField(maxlength=30)
+    
+    class Admin:
+        ordering = 'not_a_list'
+       
+model_errors += """invalid_admin_options.orderingbad: "ordering", if given, must be set to a list or tuple.
+"""
+
+class OrderingBadTwo(models.Model):
     "Test ordering, must be a field."
     first_name = models.CharField(maxlength=30)
     last_name = models.CharField(maxlength=30)
@@ -307 +341 @@
     last_name = models.CharField(maxlength=30)
     
     class Admin:
-        ordering = 'nonexistent'
+        ordering = ['nonexistent']
+       
+model_errors += """invalid_admin_options.orderingbadtwo: "ordering" refers to 'nonexistent', which is not a field.
+"""
 
-# TODO: Add a ordering validator.       
-#model_errors += """invalid_admin_options.orderingbad: "admin.ordering" refers to 'nonexistent', which isn't a field.
-#"""
+class OrderingGood(models.Model):
+    "Test ordering, can reverse sort by prepending a '-' to the fieldname."
+    first_name = models.CharField(maxlength=30)
+    last_name = models.CharField(maxlength=30)
+    
+    class Admin:
+        ordering = ['-first_name']
 
-## TODO: Add a manager validator, this should fail gracefully.
-#class ManagerBad(models.Model):
-#    "Test manager, must be a manager object."
-#    first_name = models.CharField(maxlength=30)
-#    
-#    class Admin:
-#        manager = 'nonexistent'
-#       
-#model_errors += """invalid_admin_options.managerbad: "admin.manager" refers to 'nonexistent', which isn't a Manager().
-#"""
+class PrepopulatedFieldsBadOne(models.Model):
+    "Test prepopulated_fields, must be a dictionary"
+    first_name = models.CharField(maxlength=30)
+    last_name = models.CharField(maxlength=30)
+    slug = models.SlugField()
+    
+    class Admin:
+        prepopulated_fields = ('slug',('first_name','last_name'))
+        
+model_errors += """invalid_admin_options.prepopulatedfieldsbadone: "prepopulated_fields", if given, must be a dictionary.
+"""
+
+class PrepopulatedFieldsBadTwo(models.Model):
+    "Test prepopulated_fields, must be fields"
+    first_name = models.CharField(maxlength=30)
+    last_name = models.CharField(maxlength=30)
+    slug = models.SlugField()
+    
+    class Admin:
+        prepopulated_fields = {'slug': ('first_name','last_name'),
+                               'nonexistent': ('bad1','bad2')}
+
+model_errors += """invalid_admin_options.prepopulatedfieldsbadtwo: "prepopulated_fields" refers to 'nonexistent', which is not a field.
+invalid_admin_options.prepopulatedfieldsbadtwo: "prepopulated_fields" refers to 'bad1', which is not a field.
+invalid_admin_options.prepopulatedfieldsbadtwo: "prepopulated_fields" refers to 'bad2', which is not a field.
+"""
+
+class PrepopulatedFieldsBadThree(models.Model):
+    "Test prepopulated_fields, dependencies must be a list or tuple of fields"
+    first_name = models.CharField(maxlength=30)
+    last_name = models.CharField(maxlength=30)
+    slug = models.SlugField()
+    
+    class Admin:
+        prepopulated_fields = {'slug': 'not a list or tuple'}
+
+model_errors += """invalid_admin_options.prepopulatedfieldsbadthree: "prepopulated_fields - dependencies", if given, must be set to a list or tuple.
+"""               
+class PrepopulatedFieldsGood(models.Model):
+    "Test prepopulated_fields, must be fields"
+    first_name = models.CharField(maxlength=30)
+    last_name = models.CharField(maxlength=30)
+    slug = models.SlugField()
+    
+    class Admin:
+        prepopulated_fields = {'slug': ('first_name','last_name')}
+
+class RawIdFieldsBadOne(models.Model):
+    "Test raw_id_fields, must be a list or tuple of fields"
+    user = models.ForeignKey(PrepopulatedFieldsGood)
+    widget_id = models.PositiveIntegerField()
+    
+    class Admin:
+        raw_id_fields = 'user'
+
+model_errors += """invalid_admin_options.rawidfieldsbadone: "raw_id_fields", if given, must be set to a list or tuple.
+"""
+
+class RawIdFieldsBadTwo(models.Model):
+    "Test raw_id_fields, must be fields"
+    user = models.ForeignKey(PrepopulatedFieldsGood)
+    widget_id = models.PositiveIntegerField()
+    
+    class Admin:
+        raw_id_fields = ('bad1','bad2')
+
+model_errors += """invalid_admin_options.rawidfieldsbadtwo: "raw_id_fields" refers to 'bad1', which is not a field.
+invalid_admin_options.rawidfieldsbadtwo: "raw_id_fields" refers to 'bad2', which is not a field.
+"""
+
+class RawIdFieldsGood(models.Model):
+    "Test raw_id_fields, must be fields"
+    user = models.ForeignKey(PrepopulatedFieldsGood)
+    widget_id = models.PositiveIntegerField()
+    
+    class Admin:
+        raw_id_fields = ('user','widget_id')
+
+class FilterHVBadOne(models.Model):
+    "Test filter_horizontal and filter_vertical, must be a list or tuple of fields."
+    name = models.CharField(maxlength=30)
+    widgets = models.ManyToManyField(RawIdFieldsGood)
+    other_widgets = models.ManyToManyField(RawIdFieldsBadTwo)
+    
+    class Admin:
+        filter_horizontal = 'widgets'
+        filter_vertical = 'other_widgets'
+
+model_errors += """invalid_admin_options.filterhvbadone: "filter_horizontal", if given, must be set to a list or tuple.
+invalid_admin_options.filterhvbadone: "filter_vertical", if given, must be set to a list or tuple.
+"""
+
+class FilterHVBadTwo(models.Model):
+    "Test filter_horizontal, must be a list or tuple of fields."
+    name = models.CharField(maxlength=30)
+    widgets = models.ManyToManyField(RawIdFieldsGood)
+    other_widgets = models.ManyToManyField(RawIdFieldsBadTwo)
+    
+    class Admin:
+        filter_horizontal = ('nonexistent',)
+        filter_vertical = ('also_nonexistent',)
+
+model_errors += """invalid_admin_options.filterhvbadtwo: "filter_horizontal" refers to 'nonexistent', which is not a field.
+invalid_admin_options.filterhvbadtwo: "filter_vertical" refers to 'also_nonexistent', which is not a field.
+"""
+
+class FilterHVGood(models.Model):
+    "Test filter_horizontal"
+    name = models.CharField(maxlength=30)
+    widgets = models.ManyToManyField(RawIdFieldsGood)
+    other_widgets = models.ManyToManyField(RawIdFieldsBadTwo)
+    
+    class Admin:
+        filter_horizontal = ('widgets',)
+        filter_vertical = ('other_widgets',)
+        
+class MuiltpleAdminErrors(models.Model):
+    "Test multiple errors, all errors should be collected"
+    name = models.CharField(maxlength=30)
+    
+    class Admin:
+        list_display = 'name'
+        list_filter = 'name'
+        fields = (("wrong", {'fields': 'name'}),)
+        search_fields = 'name'
+        date_hierarchy = 'name'
+        ordering = 'name'
+
+model_errors += """invalid_admin_options.muiltpleadminerrors: "fields - fieldset", if given, must be set to a list or tuple.
+invalid_admin_options.muiltpleadminerrors: "list_display", if given, must be set to a list or tuple.
+invalid_admin_options.muiltpleadminerrors: "list_filter", if given, must be set to a list or tuple.
+invalid_admin_options.muiltpleadminerrors: "date_hierarchy" refers to 'name', which is not a DateField or DateTimeField.
+invalid_admin_options.muiltpleadminerrors: "search_fields", if given, must be set to a list or tuple.
+invalid_admin_options.muiltpleadminerrors: "ordering", if given, must be set to a list or tuple.
+"""
+
+class IgnoreMultipleErrors(models.Model):
+    "validate_options can be overridden to change its behavior"
+    name = models.CharField(maxlength=30)
+    
+    class Admin:
+        list_display = 'name'
+        list_filter = 'name'
+        fields = (("wrong", {'fields': 'name'}),)
+        search_fields = 'name'
+        date_hierarchy = 'name'
+        ordering = 'name'
+        def validate_options(self):
+            # Don't validate any options and allow the model to be created.
+            self.option_errors = []
+ No newline at end of file