from datetime import date

import unittest

from django import forms

from django.conf import settings

from django.contrib.admin.options import ModelAdmin, TabularInline, \

    HORIZONTAL, VERTICAL

from django.contrib.admin.sites import AdminSite

from django.contrib.admin.validation import validate

from django.contrib.admin.widgets import AdminDateWidget, AdminRadioSelect

from django.core.exceptions import ImproperlyConfigured

from django.forms.models import BaseModelFormSet

from django.forms.widgets import Select

from django.test import TestCase

from models import Band, Concert, ValidationTestModel, \

    ValidationTestInlineModel

# None of the following tests really depend on the content of the request,

# so we'll just pass in None.

request = None

class ModelAdminTests(TestCase):

    def setUp(self):

        self.band = Band.objects.create(

            name='The Doors',

            bio='',

            sign_date=date(1965, 1, 1),

        )

        self.site = AdminSite()

    # form/fields/fieldsets interaction ##############################

    def test_default_fields(self):

        ma = ModelAdmin(Band, self.site)

        self.assertEquals(ma.get_form(request).base_fields.keys(),

            ['name', 'bio', 'sign_date'])

    def test_default_fieldsets(self):

        # fieldsets_add and fieldsets_change should return a special data structure that

        # is used in the templates. They should generate the "right thing" whether we

        # have specified a custom form, the fields argument, or nothing at all.

        #

        # Here's the default case. There are no custom form_add/form_change methods,

        # no fields argument, and no fieldsets argument.

        ma = ModelAdmin(Band, self.site)

        self.assertEqual(ma.get_fieldsets(request),

            [(None, {'fields': ['name', 'bio', 'sign_date']})])

        self.assertEqual(ma.get_fieldsets(request, self.band),

            [(None, {'fields': ['name', 'bio', 'sign_date']})])

    def test_field_arguments(self):

        # If we specify the fields argument, fieldsets_add and fielsets_change should

        # just stick the fields into a formsets structure and return it.

        class BandAdmin(ModelAdmin):

             fields = ['name']

        ma = BandAdmin(Band, self.site)

        self.assertEqual( ma.get_fieldsets(request),

            [(None, {'fields': ['name']})])

        self.assertEqual(ma.get_fieldsets(request, self.band),

            [(None, {'fields': ['name']})])

    def test_field_arguments_restricted_on_form(self):

        # If we specify fields or fieldsets, it should exclude fields on the Form class

        # to the fields specified. This may cause errors to be raised in the db layer if

        # required model fields arent in fields/fieldsets, but that's preferable to

        # ghost errors where you have a field in your Form class that isn't being

        # displayed because you forgot to add it to fields/fieldsets

        # Using `fields`.

        class BandAdmin(ModelAdmin):

            fields = ['name']

        ma = BandAdmin(Band, self.site)

        self.assertEqual(ma.get_form(request).base_fields.keys(), ['name'])

        self.assertEqual(ma.get_form(request, self.band).base_fields.keys(),

            ['name'])

        # Using `fieldsets`.

        class BandAdmin(ModelAdmin):

            fieldsets = [(None, {'fields': ['name']})]

        ma = BandAdmin(Band, self.site)

        self.assertEqual(ma.get_form(request).base_fields.keys(), ['name'])

        self.assertEqual(ma.get_form(request, self.band).base_fields.keys(),

            ['name'])

        # Using `exclude`.

        class BandAdmin(ModelAdmin):

            exclude = ['bio']

        ma = BandAdmin(Band, self.site)

        self.assertEqual(ma.get_form(request).base_fields.keys(),

            ['name', 'sign_date'])

        # You can also pass a tuple to `exclude`.

        class BandAdmin(ModelAdmin):

            exclude = ('bio',)

        ma = BandAdmin(Band, self.site)

        self.assertEqual(ma.get_form(request).base_fields.keys(),

            ['name', 'sign_date'])

        # Using `fields` and `exclude`.

        class BandAdmin(ModelAdmin):

            fields = ['name', 'bio']

            exclude = ['bio']

        ma = BandAdmin(Band, self.site)

        self.assertEqual(ma.get_form(request).base_fields.keys(),

            ['name'])

    def test_custom_form_validation(self):

        # If we specify a form, it should use it allowing custom validation to work

        # properly. This won't, however, break any of the admin widgets or media.

        class AdminBandForm(forms.ModelForm):

            delete = forms.BooleanField()

            class Meta:

                model = Band

        class BandAdmin(ModelAdmin):

            form = AdminBandForm

        ma = BandAdmin(Band, self.site)

        self.assertEqual(ma.get_form(request).base_fields.keys(),

            ['name', 'bio', 'sign_date', 'delete'])

        self.assertEqual(

            type(ma.get_form(request).base_fields['sign_date'].widget),

            AdminDateWidget)

    def test_queryset_override(self):

        # If we need to override the queryset of a ModelChoiceField in our custom form

        # make sure that RelatedFieldWidgetWrapper doesn't mess that up.

        band2 = Band(name='The Beatles', bio='', sign_date=date(1962, 1, 1))

        band2.save()

        class ConcertAdmin(ModelAdmin):

            pass

        ma = ConcertAdmin(Concert, self.site)

        form = ma.get_form(request)()

        self.assertEqual(str(form["main_band"]),

            '<select name="main_band" id="id_main_band">\n'

            '<option value="" selected="selected">---------</option>\n'

            '<option value="%d">The Doors</option>\n'

            '<option value="%d">The Beatles</option>\n'

            '</select>' % (self.band.id, band2.id))

        class AdminConcertForm(forms.ModelForm):

            class Meta:

                model = Concert

            def __init__(self, *args, **kwargs):

                super(AdminConcertForm, self).__init__(*args, **kwargs)

                self.fields["main_band"].queryset = Band.objects.filter(name='The Doors')

        class ConcertAdmin(ModelAdmin):

            form = AdminConcertForm

        ma = ConcertAdmin(Concert, self.site)

        form = ma.get_form(request)()

        self.assertEqual(str(form["main_band"]),

            '<select name="main_band" id="id_main_band">\n'

            '<option value="" selected="selected">---------</option>\n'

            '<option value="%d">The Doors</option>\n'

            '</select>' % self.band.id)

    # radio_fields behavior ###########################################

    def test_default_foreign_key_widget(self):

        # First, without any radio_fields specified, the widgets for ForeignKey

        # and fields with choices specified ought to be a basic Select widget.

        # ForeignKey widgets in the admin are wrapped with RelatedFieldWidgetWrapper so

        # they need to be handled properly when type checking. For Select fields, all of

        # the choices lists have a first entry of dashes.

        cma = ModelAdmin(Concert, self.site)

        cmafa = cma.get_form(request)

        self.assertEqual(type(cmafa.base_fields['main_band'].widget.widget),

            Select)

        self.assertEqual(

            list(cmafa.base_fields['main_band'].widget.choices),

            [(u'', u'---------'), (self.band.id, u'The Doors')])

        self.assertEqual(

            type(cmafa.base_fields['opening_band'].widget.widget), Select)

        self.assertEqual(

            list(cmafa.base_fields['opening_band'].widget.choices),

            [(u'', u'---------'), (self.band.id, u'The Doors')])

        self.assertEqual(type(cmafa.base_fields['day'].widget), Select)

        self.assertEqual(list(cmafa.base_fields['day'].widget.choices),

            [('', '---------'), (1, 'Fri'), (2, 'Sat')])

        self.assertEqual(type(cmafa.base_fields['transport'].widget),

            Select)

        self.assertEqual(

            list(cmafa.base_fields['transport'].widget.choices),

            [('', '---------'), (1, 'Plane'), (2, 'Train'), (3, 'Bus')])

    def test_foreign_key_as_radio_field(self):

        # Now specify all the fields as radio_fields.  Widgets should now be

        # RadioSelect, and the choices list should have a first entry of 'None' if

        # blank=True for the model field.  Finally, the widget should have the

        # 'radiolist' attr, and 'inline' as well if the field is specified HORIZONTAL.

        class ConcertAdmin(ModelAdmin):

            radio_fields = {

                'main_band': HORIZONTAL,

                'opening_band': VERTICAL,

                'day': VERTICAL,

                'transport': HORIZONTAL,

            }

        cma = ConcertAdmin(Concert, self.site)

        cmafa = cma.get_form(request)

        self.assertEqual(type(cmafa.base_fields['main_band'].widget.widget),

            AdminRadioSelect)

        self.assertEqual(cmafa.base_fields['main_band'].widget.attrs,

            {'class': 'radiolist inline'})

        self.assertEqual(list(cmafa.base_fields['main_band'].widget.choices),

            [(self.band.id, u'The Doors')])

        self.assertEqual(

            type(cmafa.base_fields['opening_band'].widget.widget),

            AdminRadioSelect)

        self.assertEqual(cmafa.base_fields['opening_band'].widget.attrs,

            {'class': 'radiolist'})

        self.assertEqual(

            list(cmafa.base_fields['opening_band'].widget.choices),

            [(u'', u'None'), (self.band.id, u'The Doors')])

        self.assertEqual(type(cmafa.base_fields['day'].widget),

            AdminRadioSelect)

        self.assertEqual(cmafa.base_fields['day'].widget.attrs,

            {'class': 'radiolist'})

        self.assertEqual(list(cmafa.base_fields['day'].widget.choices),

            [(1, 'Fri'), (2, 'Sat')])

        self.assertEqual(type(cmafa.base_fields['transport'].widget),

            AdminRadioSelect)

        self.assertEqual(cmafa.base_fields['transport'].widget.attrs,

            {'class': 'radiolist inline'})

        self.assertEqual(list(cmafa.base_fields['transport'].widget.choices),

            [('', u'None'), (1, 'Plane'), (2, 'Train'), (3, 'Bus')])

        class AdminConcertForm(forms.ModelForm):

            class Meta:

                model = Concert

                exclude = ('transport',)

        class ConcertAdmin(ModelAdmin):

            form = AdminConcertForm

        ma = ConcertAdmin(Concert, self.site)

        self.assertEqual(ma.get_form(request).base_fields.keys(),

            ['main_band', 'opening_band', 'day'])

        class AdminConcertForm(forms.ModelForm):

            extra = forms.CharField()

            class Meta:

                model = Concert

                fields = ['extra', 'transport']

        class ConcertAdmin(ModelAdmin):

            form = AdminConcertForm

        ma = ConcertAdmin(Concert, self.site)

        self.assertEqual(ma.get_form(request).base_fields.keys(),

            ['extra', 'transport'])

        class ConcertInline(TabularInline):

            form = AdminConcertForm

            model = Concert

            fk_name = 'main_band'

            can_delete = True

        class BandAdmin(ModelAdmin):

            inlines = [

                ConcertInline

            ]

        ma = BandAdmin(Band, self.site)

        self.assertEqual(

            list(ma.get_formsets(request))[0]().forms[0].fields.keys(),

            ['extra', 'transport', 'id', 'DELETE', 'main_band'])

class ValidationTests(unittest.TestCase):

    def assertRaisesErrorWithMessage(self, error, message, callable, *args, **kwargs):

        self.assertRaises(error, callable, *args, **kwargs)

        try:

            callable(*args, **kwargs)

        except error, e:

            self.assertEqual(message, str(e))

    def test_validation_only_runs_in_debug(self):

        # Ensure validation only runs when DEBUG = True

        try:

            settings.DEBUG = True

            class ValidationTestModelAdmin(ModelAdmin):

                raw_id_fields = 10

            site = AdminSite()

            self.assertRaisesErrorWithMessage(

                ImproperlyConfigured,

                "'ValidationTestModelAdmin.raw_id_fields' must be a list or tuple.",

                site.register,

                ValidationTestModel,

                ValidationTestModelAdmin,

            )

        finally:

            settings.DEBUG = False

        site = AdminSite()

        site.register(ValidationTestModel, ValidationTestModelAdmin)

    def test_raw_id_fields_validation(self):

        class ValidationTestModelAdmin(ModelAdmin):

            raw_id_fields = 10

        self.assertRaisesErrorWithMessage(

            ImproperlyConfigured,

            "'ValidationTestModelAdmin.raw_id_fields' must be a list or tuple.",

            validate,

            ValidationTestModelAdmin,

            ValidationTestModel,

        )

        class ValidationTestModelAdmin(ModelAdmin):

            raw_id_fields = ('non_existent_field',)

        self.assertRaisesErrorWithMessage(

            ImproperlyConfigured,

            "'ValidationTestModelAdmin.raw_id_fields' refers to field 'non_existent_field' that is missing from model 'ValidationTestModel'.",

            validate,

            ValidationTestModelAdmin,

            ValidationTestModel,

        )

        class ValidationTestModelAdmin(ModelAdmin):

            raw_id_fields = ('name',)

        self.assertRaisesErrorWithMessage(

            ImproperlyConfigured,

            "'ValidationTestModelAdmin.raw_id_fields[0]', 'name' must be either a ForeignKey or ManyToManyField.",

            validate,

            ValidationTestModelAdmin,

            ValidationTestModel,

        )

        class ValidationTestModelAdmin(ModelAdmin):

            raw_id_fields = ('users',)

        validate(ValidationTestModelAdmin, ValidationTestModel)

    def test_fieldsets_validation(self):

        class ValidationTestModelAdmin(ModelAdmin):

            fieldsets = 10

        self.assertRaisesErrorWithMessage(

            ImproperlyConfigured,

            "'ValidationTestModelAdmin.fieldsets' must be a list or tuple.",

            validate,

            ValidationTestModelAdmin,

            ValidationTestModel,

        )

        class ValidationTestModelAdmin(ModelAdmin):

            fieldsets = ({},)

        self.assertRaisesErrorWithMessage(

            ImproperlyConfigured,

            "'ValidationTestModelAdmin.fieldsets[0]' must be a list or tuple.",

            validate,

            ValidationTestModelAdmin,

            ValidationTestModel,

        )

        class ValidationTestModelAdmin(ModelAdmin):

            fieldsets = ((),)

        self.assertRaisesErrorWithMessage(

            ImproperlyConfigured,

            "'ValidationTestModelAdmin.fieldsets[0]' does not have exactly two elements.",

            validate,

            ValidationTestModelAdmin,

            ValidationTestModel,

        )

        class ValidationTestModelAdmin(ModelAdmin):

            fieldsets = (("General", ()),)

        self.assertRaisesErrorWithMessage(

            ImproperlyConfigured,

            "'ValidationTestModelAdmin.fieldsets[0][1]' must be a dictionary.",

            validate,

            ValidationTestModelAdmin,

            ValidationTestModel,

        )

        class ValidationTestModelAdmin(ModelAdmin):

            fieldsets = (("General", {}),)

        self.assertRaisesErrorWithMessage(

            ImproperlyConfigured,

            "'fields' key is required in ValidationTestModelAdmin.fieldsets[0][1] field options dict.",

            validate,

            ValidationTestModelAdmin,

            ValidationTestModel,

        )

        class ValidationTestModelAdmin(ModelAdmin):

            fieldsets = (("General", {"fields": ("non_existent_field",)}),)

        self.assertRaisesErrorWithMessage(

            ImproperlyConfigured,

            "'ValidationTestModelAdmin.fieldsets[0][1]['fields']' refers to field 'non_existent_field' that is missing from the form.",

            validate,

            ValidationTestModelAdmin,

            ValidationTestModel,

        )

        class ValidationTestModelAdmin(ModelAdmin):

            fieldsets = (("General", {"fields": ("name",)}),)

        validate(ValidationTestModelAdmin, ValidationTestModel)

        class ValidationTestModelAdmin(ModelAdmin):

            fieldsets = (("General", {"fields": ("name",)}),)

            fields = ["name",]

        self.assertRaisesErrorWithMessage(

            ImproperlyConfigured,

            "Both fieldsets and fields are specified in ValidationTestModelAdmin.",

            validate,

            ValidationTestModelAdmin,

            ValidationTestModel,

        )

        class ValidationTestModelAdmin(ModelAdmin):

            fieldsets = [(None, {'fields': ['name', 'name']})]

        self.assertRaisesErrorWithMessage(

            ImproperlyConfigured,

            "There are duplicate field(s) in ValidationTestModelAdmin.fieldsets",

            validate,

            ValidationTestModelAdmin,

            ValidationTestModel,

        )

        class ValidationTestModelAdmin(ModelAdmin):

            fields = ["name", "name"]

        self.assertRaisesErrorWithMessage(

            ImproperlyConfigured,

            "There are duplicate field(s) in ValidationTestModelAdmin.fields",

            validate,

            ValidationTestModelAdmin,

            ValidationTestModel,

        )

    def test_form_validation(self):

        class FakeForm(object):

            pass

        class ValidationTestModelAdmin(ModelAdmin):

            form = FakeForm

        self.assertRaisesErrorWithMessage(

            ImproperlyConfigured,

            "ValidationTestModelAdmin.form does not inherit from BaseModelForm.",

            validate,

            ValidationTestModelAdmin,

            ValidationTestModel,

        )

    def test_fieldsets_with_custom_form_validation(self):

        class BandAdmin(ModelAdmin):

            fieldsets = (

                ('Band', {

                    'fields': ('non_existent_field',)

                }),

            )

        self.assertRaisesErrorWithMessage(

            ImproperlyConfigured,

            "'BandAdmin.fieldsets[0][1]['fields']' refers to field 'non_existent_field' that is missing from the form.",

            validate,

            BandAdmin,

            Band,

        )

        class BandAdmin(ModelAdmin):

            fieldsets = (

                ('Band', {

                    'fields': ('name',)

                }),

            )

        validate(BandAdmin, Band)

        class AdminBandForm(forms.ModelForm):

            class Meta:

                model = Band