1 import unittest

     2 import datetime

     3 from django.conf import settings

     4 from django.db import connection

     5 from models import CustomPKModel, UniqueTogetherModel, UniqueFieldsModel, UniqueForDateModel, ModelToValidate

     6 

     7 

     8 class GetUniqueCheckTests(unittest.TestCase):

     9     def test_unique_fields_get_collected(self):

    10         m = UniqueFieldsModel()

    11         self.assertEqual(

    12             ([(UniqueFieldsModel, ('id',)),

    13               (UniqueFieldsModel, ('unique_charfield',)),

    14               (UniqueFieldsModel, ('unique_integerfield',))],

    15              []),

    16             m._get_unique_checks()

    17         )

    18 

    19     def test_unique_together_gets_picked_up_and_converted_to_tuple(self):

    20         m = UniqueTogetherModel()

    21         self.assertEqual(

    22             ([(UniqueTogetherModel, ('ifield', 'cfield',)),

    23               (UniqueTogetherModel, ('ifield', 'efield')),

    24               (UniqueTogetherModel, ('id',)), ],

    25              []),

    26             m._get_unique_checks()

    27         )

    28 

    29     def test_primary_key_is_considered_unique(self):

    30         m = CustomPKModel()

    31         self.assertEqual(([(CustomPKModel, ('my_pk_field',))], []), m._get_unique_checks())

    32 

    33     def test_unique_for_date_gets_picked_up(self):

    34         m = UniqueForDateModel()

    35         self.assertEqual((

    36             [(UniqueForDateModel, ('id',))],

    37             [(UniqueForDateModel, 'date', 'count', 'start_date'),

    38              (UniqueForDateModel, 'year', 'count', 'end_date'),

    39              (UniqueForDateModel, 'month', 'order', 'end_date')]

    40             ), m._get_unique_checks()

    41         )

    42 

    43     def test_unique_for_date_exclusion(self):

    44         m = UniqueForDateModel()

    45         self.assertEqual((

    46             [(UniqueForDateModel, ('id',))],

    47             [(UniqueForDateModel, 'year', 'count', 'end_date'),

    48              (UniqueForDateModel, 'month', 'order', 'end_date')]

    49             ), m._get_unique_checks(exclude='start_date')

    50         )

    51 

    52 class PerformUniqueChecksTest(unittest.TestCase):

    53     def setUp(self):

    54         # Set debug to True to gain access to connection.queries.

    55         self._old_debug, settings.DEBUG = settings.DEBUG, True

    56         super(PerformUniqueChecksTest, self).setUp()

    57 

    58     def tearDown(self):

    59         # Restore old debug value.

    60         settings.DEBUG = self._old_debug

    61         super(PerformUniqueChecksTest, self).tearDown()

    62 

    63     def test_primary_key_unique_check_not_performed_when_adding_and_pk_not_specified(self):

    64         # Regression test for #12560

    65         query_count = len(connection.queries)

    66         mtv = ModelToValidate(number=10, name='Some Name')

    67         setattr(mtv, '_adding', True)

    68         mtv.full_clean()

    69         self.assertEqual(query_count, len(connection.queries))

    70 

    71     def test_primary_key_unique_check_performed_when_adding_and_pk_specified(self):

    72         # Regression test for #12560

    73         query_count = len(connection.queries)

    74         mtv = ModelToValidate(number=10, name='Some Name', id=123)

    75         setattr(mtv, '_adding', True)

    76         mtv.full_clean()

    77         self.assertEqual(query_count + 1, len(connection.queries))

    78 

    79     def test_primary_key_unique_check_not_performed_when_not_adding(self):

    80         # Regression test for #12132

    81         query_count= len(connection.queries)

    82         mtv = ModelToValidate(number=10, name='Some Name')

    83         mtv.full_clean()

    84         self.assertEqual(query_count, len(connection.queries))

    85