1. import copy

  2. import datetime

  3. from operator import attrgetter

  4. 

  5. from django.core.exceptions import ValidationError

  6. from django.db import models, router

  7. from django.db.models.sql import InsertQuery

  8. from django.test import TestCase, skipUnlessDBFeature

  9. from django.test.utils import isolate_apps

  10. from django.utils.timezone import get_fixed_timezone

  11. 

  12. from .models import (

  13.     Article,

  14.     Department,

  15.     Event,

  16.     Model1,

  17.     Model2,

  18.     Model3,

  19.     NonAutoPK,

  20.     Party,

  21.     Worker,

  22. )

  23. 

  24. 

  25. class ModelTests(TestCase):

  26.     def test_model_init_too_many_args(self):

  27.         msg = "Number of args exceeds number of fields"

  28.         with self.assertRaisesMessage(IndexError, msg):

  29.             Worker(1, 2, 3, 4)

  30. 

  31.     # The bug is that the following queries would raise:

  32.     # "TypeError: Related Field has invalid lookup: gte"

  33.     def test_related_gte_lookup(self):

  34.         """

  35.         Regression test for #10153: foreign key __gte lookups.

  36.         """

  37.         Worker.objects.filter(department__gte=0)

  38. 

  39.     def test_related_lte_lookup(self):

  40.         """

  41.         Regression test for #10153: foreign key __lte lookups.

  42.         """

  43.         Worker.objects.filter(department__lte=0)

  44. 

  45.     def test_sql_insert_compiler_return_id_attribute(self):

  46.         """

  47.         Regression test for #14019: SQLInsertCompiler.as_sql() failure

  48.         """

  49.         db = router.db_for_write(Party)

  50.         query = InsertQuery(Party)

  51.         query.insert_values([Party._meta.fields[0]], [], raw=False)

  52.         # this line will raise an AttributeError without the accompanying fix

  53.         query.get_compiler(using=db).as_sql()

  54. 

  55.     def test_empty_choice(self):

  56.         # NOTE: Part of the regression test here is merely parsing the model

  57.         # declaration. The verbose_name, in particular, did not always work.

  58.         a = Article.objects.create(

  59.             headline="Look at me!", pub_date=datetime.datetime.now()

  60.         )

  61.         # An empty choice field should return None for the display name.

  62.         self.assertIs(a.get_status_display(), None)

  63. 

  64.         # Empty strings should be returned as string

  65.         a = Article.objects.get(pk=a.pk)

  66.         self.assertEqual(a.misc_data, "")

  67. 

  68.     def test_long_textfield(self):

  69.         # TextFields can hold more than 4000 characters (this was broken in

  70.         # Oracle).

  71.         a = Article.objects.create(

  72.             headline="Really, really big",

  73.             pub_date=datetime.datetime.now(),

  74.             article_text="ABCDE" * 1000,

  75.         )

  76.         a = Article.objects.get(pk=a.pk)

  77.         self.assertEqual(len(a.article_text), 5000)

  78. 

  79.     def test_long_unicode_textfield(self):

  80.         # TextFields can hold more than 4000 bytes also when they are

  81.         # less than 4000 characters

  82.         a = Article.objects.create(

  83.             headline="Really, really big",

  84.             pub_date=datetime.datetime.now(),

  85.             article_text="\u05d0\u05d1\u05d2" * 1000,

  86.         )

  87.         a = Article.objects.get(pk=a.pk)

  88.         self.assertEqual(len(a.article_text), 3000)

  89. 

  90.     def test_date_lookup(self):

  91.         # Regression test for #659

  92.         Party.objects.create(when=datetime.datetime(1999, 12, 31))

  93.         Party.objects.create(when=datetime.datetime(1998, 12, 31))

  94.         Party.objects.create(when=datetime.datetime(1999, 1, 1))

  95.         Party.objects.create(when=datetime.datetime(1, 3, 3))

  96.         self.assertQuerysetEqual(Party.objects.filter(when__month=2), [])

  97.         self.assertQuerysetEqual(

  98.             Party.objects.filter(when__month=1),

  99.             [datetime.date(1999, 1, 1)],

  100.             attrgetter("when"),

  101.         )

  102.         self.assertQuerysetEqual(

  103.             Party.objects.filter(when__month=12),

  104.             [

  105.                 datetime.date(1999, 12, 31),

  106.                 datetime.date(1998, 12, 31),

  107.             ],

  108.             attrgetter("when"),

  109.             ordered=False,

  110.         )

  111.         self.assertQuerysetEqual(

  112.             Party.objects.filter(when__year=1998),

  113.             [

  114.                 datetime.date(1998, 12, 31),

  115.             ],

  116.             attrgetter("when"),

  117.         )

  118.         # Regression test for #8510

  119.         self.assertQuerysetEqual(

  120.             Party.objects.filter(when__day="31"),

  121.             [

  122.                 datetime.date(1999, 12, 31),

  123.                 datetime.date(1998, 12, 31),

  124.             ],

  125.             attrgetter("when"),

  126.             ordered=False,

  127.         )

  128.         self.assertQuerysetEqual(

  129.             Party.objects.filter(when__month="12"),

  130.             [

  131.                 datetime.date(1999, 12, 31),

  132.                 datetime.date(1998, 12, 31),

  133.             ],

  134.             attrgetter("when"),

  135.             ordered=False,

  136.         )

  137.         self.assertQuerysetEqual(

  138.             Party.objects.filter(when__year="1998"),

  139.             [

  140.                 datetime.date(1998, 12, 31),

  141.             ],

  142.             attrgetter("when"),

  143.         )

  144. 

  145.         # Regression test for #18969

  146.         self.assertQuerysetEqual(

  147.             Party.objects.filter(when__year=1),

  148.             [

  149.                 datetime.date(1, 3, 3),

  150.             ],

  151.             attrgetter("when"),

  152.         )

  153.         self.assertQuerysetEqual(

  154.             Party.objects.filter(when__year="1"),

  155.             [

  156.                 datetime.date(1, 3, 3),

  157.             ],

  158.             attrgetter("when"),

  159.         )

  160. 

  161.     def test_date_filter_null(self):

  162.         # Date filtering was failing with NULL date values in SQLite

  163.         # (regression test for #3501, among other things).

  164.         Party.objects.create(when=datetime.datetime(1999, 1, 1))

  165.         Party.objects.create()

  166.         p = Party.objects.filter(when__month=1)[0]

  167.         self.assertEqual(p.when, datetime.date(1999, 1, 1))

  168.         self.assertQuerysetEqual(

  169.             Party.objects.filter(pk=p.pk).dates("when", "month"),

  170.             [1],

  171.             attrgetter("month"),

  172.         )

  173. 

  174.     def test_get_next_prev_by_field(self):

  175.         # get_next_by_FIELD() and get_previous_by_FIELD() don't crash when

  176.         # microseconds values are stored in the database.

  177.         Event.objects.create(when=datetime.datetime(2000, 1, 1, 16, 0, 0))

  178.         Event.objects.create(when=datetime.datetime(2000, 1, 1, 6, 1, 1))

  179.         Event.objects.create(when=datetime.datetime(2000, 1, 1, 13, 1, 1))

  180.         e = Event.objects.create(when=datetime.datetime(2000, 1, 1, 12, 0, 20, 24))

  181.         self.assertEqual(

  182.             e.get_next_by_when().when, datetime.datetime(2000, 1, 1, 13, 1, 1)

  183.         )

  184.         self.assertEqual(

  185.             e.get_previous_by_when().when, datetime.datetime(2000, 1, 1, 6, 1, 1)

  186.         )

  187. 

  188.     def test_get_next_prev_by_field_unsaved(self):

  189.         msg = "get_next/get_previous cannot be used on unsaved objects."

  190.         with self.assertRaisesMessage(ValueError, msg):

  191.             Event().get_next_by_when()

  192.         with self.assertRaisesMessage(ValueError, msg):

  193.             Event().get_previous_by_when()

  194. 

  195.     def test_primary_key_foreign_key_types(self):

  196.         # Check Department and Worker (non-default PK type)

  197.         d = Department.objects.create(id=10, name="IT")

  198.         w = Worker.objects.create(department=d, name="Full-time")

  199.         self.assertEqual(str(w), "Full-time")

  200. 

  201.     @skipUnlessDBFeature("supports_timezones")

  202.     def test_timezones(self):

  203.         # Saving and updating with timezone-aware datetime Python objects.

  204.         # Regression test for #10443.

  205.         # The idea is that all these creations and saving should work without

  206.         # crashing. It's not rocket science.

  207.         dt1 = datetime.datetime(2008, 8, 31, 16, 20, tzinfo=get_fixed_timezone(600))

  208.         dt2 = datetime.datetime(2008, 8, 31, 17, 20, tzinfo=get_fixed_timezone(600))

  209.         obj = Article.objects.create(

  210.             headline="A headline", pub_date=dt1, article_text="foo"

  211.         )

  212.         obj.pub_date = dt2

  213.         obj.save()

  214.         self.assertEqual(

  215.             Article.objects.filter(headline="A headline").update(pub_date=dt1), 1

  216.         )

  217. 

  218.     def test_chained_fks(self):

  219.         """

  220.         Chained foreign keys with to_field produce incorrect query.

  221.         """

  222. 

  223.         m1 = Model1.objects.create(pkey=1000)

  224.         m2 = Model2.objects.create(model1=m1)

  225.         m3 = Model3.objects.create(model2=m2)

  226. 

  227.         # this is the actual test for #18432

  228.         m3 = Model3.objects.get(model2=1000)

  229.         m3.model2

  230. 

  231.     @isolate_apps("model_regress")

  232.     def test_metaclass_can_access_attribute_dict(self):

  233.         """

  234.         Model metaclasses have access to the class attribute dict in

  235.         __init__() (#30254).

  236.         """

  237. 

  238.         class HorseBase(models.base.ModelBase):

  239.             def __init__(cls, name, bases, attrs):

  240.                 super().__init__(name, bases, attrs)

  241.                 cls.horns = 1 if "magic" in attrs else 0

  242. 

  243.         class Horse(models.Model, metaclass=HorseBase):

  244.             name = models.CharField(max_length=255)

  245.             magic = True

  246. 

  247.         self.assertEqual(Horse.horns, 1)

  248. 

  249. 

  250. class ModelValidationTest(TestCase):

  251.     def test_pk_validation(self):

  252.         NonAutoPK.objects.create(name="one")

  253.         again = NonAutoPK(name="one")

  254.         with self.assertRaises(ValidationError):

  255.             again.validate_unique()

  256. 

  257. 

  258. class EvaluateMethodTest(TestCase):

  259.     """

  260.     Regression test for #13640: cannot filter by objects with 'evaluate' attr

  261.     """

  262. 

  263.     def test_model_with_evaluate_method(self):

  264.         """

  265.         You can filter by objects that have an 'evaluate' attr

  266.         """

  267.         dept = Department.objects.create(pk=1, name="abc")

  268.         dept.evaluate = "abc"

  269.         Worker.objects.filter(department=dept)

  270. 

  271. 

  272. class ModelFieldsCacheTest(TestCase):

  273.     def test_fields_cache_reset_on_copy(self):

  274.         department1 = Department.objects.create(id=1, name="department1")

  275.         department2 = Department.objects.create(id=2, name="department2")

  276.         worker1 = Worker.objects.create(name="worker", department=department1)

  277.         worker2 = copy.copy(worker1)

  278. 

  279.         self.assertEqual(worker2.department, department1)

  280.         # Changing related fields doesn't mutate the base object.

  281.         worker2.department = department2

  282.         self.assertEqual(worker2.department, department2)

  283.         self.assertEqual(worker1.department, department1)
About Sign Up Leave Feedback Contact