1. from django.contrib import admin

  2. from django.contrib.admin.options import ModelAdmin

  3. from django.contrib.auth.models import User

  4. from django.db.models import F

  5. from django.test import RequestFactory, TestCase

  6. 

  7. from .models import (

  8.     Band,

  9.     DynOrderingBandAdmin,

  10.     Song,

  11.     SongInlineDefaultOrdering,

  12.     SongInlineNewOrdering,

  13. )

  14. 

  15. 

  16. class MockRequest:

  17.     pass

  18. 

  19. 

  20. class MockSuperUser:

  21.     def has_perm(self, perm, obj=None):

  22.         return True

  23. 

  24.     def has_module_perms(self, module):

  25.         return True

  26. 

  27. 

  28. request = MockRequest()

  29. request.user = MockSuperUser()

  30. 

  31. site = admin.AdminSite()

  32. 

  33. 

  34. class TestAdminOrdering(TestCase):

  35.     """

  36.     Let's make sure that ModelAdmin.get_queryset uses the ordering we define

  37.     in ModelAdmin rather that ordering defined in the model's inner Meta

  38.     class.

  39.     """

  40. 

  41.     request_factory = RequestFactory()

  42. 

  43.     @classmethod

  44.     def setUpTestData(cls):

  45.         Band.objects.bulk_create(

  46.             [

  47.                 Band(name="Aerosmith", bio="", rank=3),

  48.                 Band(name="Radiohead", bio="", rank=1),

  49.                 Band(name="Van Halen", bio="", rank=2),

  50.             ]

  51.         )

  52. 

  53.     def test_default_ordering(self):

  54.         """

  55.         The default ordering should be by name, as specified in the inner Meta

  56.         class.

  57.         """

  58.         ma = ModelAdmin(Band, site)

  59.         names = [b.name for b in ma.get_queryset(request)]

  60.         self.assertEqual(["Aerosmith", "Radiohead", "Van Halen"], names)

  61. 

  62.     def test_specified_ordering(self):

  63.         """

  64.         Let's use a custom ModelAdmin that changes the ordering, and make sure

  65.         it actually changes.

  66.         """

  67. 

  68.         class BandAdmin(ModelAdmin):

  69.             ordering = ("rank",)  # default ordering is ('name',)

  70. 

  71.         ma = BandAdmin(Band, site)

  72.         names = [b.name for b in ma.get_queryset(request)]

  73.         self.assertEqual(["Radiohead", "Van Halen", "Aerosmith"], names)

  74. 

  75.     def test_specified_ordering_by_f_expression(self):

  76.         class BandAdmin(ModelAdmin):

  77.             ordering = (F("rank").desc(nulls_last=True),)

  78. 

  79.         band_admin = BandAdmin(Band, site)

  80.         names = [b.name for b in band_admin.get_queryset(request)]

  81.         self.assertEqual(["Aerosmith", "Van Halen", "Radiohead"], names)

  82. 

  83.     def test_dynamic_ordering(self):

  84.         """

  85.         Let's use a custom ModelAdmin that changes the ordering dynamically.

  86.         """

  87.         super_user = User.objects.create(username="admin", is_superuser=True)

  88.         other_user = User.objects.create(username="other")

  89.         request = self.request_factory.get("/")

  90.         request.user = super_user

  91.         ma = DynOrderingBandAdmin(Band, site)

  92.         names = [b.name for b in ma.get_queryset(request)]

  93.         self.assertEqual(["Radiohead", "Van Halen", "Aerosmith"], names)

  94.         request.user = other_user

  95.         names = [b.name for b in ma.get_queryset(request)]

  96.         self.assertEqual(["Aerosmith", "Radiohead", "Van Halen"], names)

  97. 

  98. 

  99. class TestInlineModelAdminOrdering(TestCase):

  100.     """

  101.     Let's make sure that InlineModelAdmin.get_queryset uses the ordering we

  102.     define in InlineModelAdmin.

  103.     """

  104. 

  105.     @classmethod

  106.     def setUpTestData(cls):

  107.         cls.band = Band.objects.create(name="Aerosmith", bio="", rank=3)

  108.         Song.objects.bulk_create(

  109.             [

  110.                 Song(band=cls.band, name="Pink", duration=235),

  111.                 Song(band=cls.band, name="Dude (Looks Like a Lady)", duration=264),

  112.                 Song(band=cls.band, name="Jaded", duration=214),

  113.             ]

  114.         )

  115. 

  116.     def test_default_ordering(self):

  117.         """

  118.         The default ordering should be by name, as specified in the inner Meta

  119.         class.

  120.         """

  121.         inline = SongInlineDefaultOrdering(self.band, site)

  122.         names = [s.name for s in inline.get_queryset(request)]

  123.         self.assertEqual(["Dude (Looks Like a Lady)", "Jaded", "Pink"], names)

  124. 

  125.     def test_specified_ordering(self):

  126.         """

  127.         Let's check with ordering set to something different than the default.

  128.         """

  129.         inline = SongInlineNewOrdering(self.band, site)

  130.         names = [s.name for s in inline.get_queryset(request)]

  131.         self.assertEqual(["Jaded", "Pink", "Dude (Looks Like a Lady)"], names)

  132. 

  133. 

  134. class TestRelatedFieldsAdminOrdering(TestCase):

  135.     @classmethod

  136.     def setUpTestData(cls):

  137.         cls.b1 = Band.objects.create(name="Pink Floyd", bio="", rank=1)

  138.         cls.b2 = Band.objects.create(name="Foo Fighters", bio="", rank=5)

  139. 

  140.     def setUp(self):

  141.         # we need to register a custom ModelAdmin (instead of just using

  142.         # ModelAdmin) because the field creator tries to find the ModelAdmin

  143.         # for the related model

  144.         class SongAdmin(admin.ModelAdmin):

  145.             pass

  146. 

  147.         site.register(Song, SongAdmin)

  148. 

  149.     def tearDown(self):

  150.         site.unregister(Song)

  151.         if Band in site._registry:

  152.             site.unregister(Band)

  153. 

  154.     def check_ordering_of_field_choices(self, correct_ordering):

  155.         fk_field = site._registry[Song].formfield_for_foreignkey(

  156.             Song.band.field, request=None

  157.         )

  158.         m2m_field = site._registry[Song].formfield_for_manytomany(

  159.             Song.other_interpreters.field, request=None

  160.         )

  161.         self.assertEqual(list(fk_field.queryset), correct_ordering)

  162.         self.assertEqual(list(m2m_field.queryset), correct_ordering)

  163. 

  164.     def test_no_admin_fallback_to_model_ordering(self):

  165.         # should be ordered by name (as defined by the model)

  166.         self.check_ordering_of_field_choices([self.b2, self.b1])

  167. 

  168.     def test_admin_with_no_ordering_fallback_to_model_ordering(self):

  169.         class NoOrderingBandAdmin(admin.ModelAdmin):

  170.             pass

  171. 

  172.         site.register(Band, NoOrderingBandAdmin)

  173. 

  174.         # should be ordered by name (as defined by the model)

  175.         self.check_ordering_of_field_choices([self.b2, self.b1])

  176. 

  177.     def test_admin_ordering_beats_model_ordering(self):

  178.         class StaticOrderingBandAdmin(admin.ModelAdmin):

  179.             ordering = ("rank",)

  180. 

  181.         site.register(Band, StaticOrderingBandAdmin)

  182. 

  183.         # should be ordered by rank (defined by the ModelAdmin)

  184.         self.check_ordering_of_field_choices([self.b1, self.b2])

  185. 

  186.     def test_custom_queryset_still_wins(self):

  187.         """Custom queryset has still precedence (#21405)"""

  188. 

  189.         class SongAdmin(admin.ModelAdmin):

  190.             # Exclude one of the two Bands from the querysets

  191.             def formfield_for_foreignkey(self, db_field, request, **kwargs):

  192.                 if db_field.name == "band":

  193.                     kwargs["queryset"] = Band.objects.filter(rank__gt=2)

  194.                 return super().formfield_for_foreignkey(db_field, request, **kwargs)

  195. 

  196.             def formfield_for_manytomany(self, db_field, request, **kwargs):

  197.                 if db_field.name == "other_interpreters":

  198.                     kwargs["queryset"] = Band.objects.filter(rank__gt=2)

  199.                 return super().formfield_for_foreignkey(db_field, request, **kwargs)

  200. 

  201.         class StaticOrderingBandAdmin(admin.ModelAdmin):

  202.             ordering = ("rank",)

  203. 

  204.         site.unregister(Song)

  205.         site.register(Song, SongAdmin)

  206.         site.register(Band, StaticOrderingBandAdmin)

  207. 

  208.         self.check_ordering_of_field_choices([self.b2])
About Sign Up Leave Feedback Contact