Add a test model with renamed PK

Author: sterliakov

tests/testproject/testapp/admin.py

@@ -8,7 +8,7 @@
     DALFRelatedOnlyField,
 )
 
-from .models import Category, Post, Tag
+from .models import Category, CategoryRenamed, Post, Tag
 
 
 @admin.register(Post)
@@ -18,6 +18,7 @@ class PostAdmin(DALFModelAdmin):
         ('author', DALFRelatedField),
         ('audience', DALFChoicesField),
         ('category', DALFRelatedFieldAjax),
+        ('category_renamed', DALFRelatedFieldAjax),
         ('tags', DALFRelatedOnlyField),
     )
 
@@ -28,6 +29,12 @@ class CategoryAdmin(admin.ModelAdmin):
     ordering = ('name',)
 
 
+@admin.register(CategoryRenamed)
+class CategoryRenamedAdmin(admin.ModelAdmin):
+    search_fields = ('name',)
+    ordering = ('name',)
+
+
 @admin.register(Tag)
 class TagAdmin(admin.ModelAdmin):
     search_fields = ('name',)

tests/testproject/testapp/conftest.py

@@ -10,3 +10,7 @@
 @pytest.fixture
 def posts():
     return PostFactory.create_batch(10)
+
+@pytest.fixture
+def unused_tag():
+    return TagFactory(name='Unused')

tests/testproject/testapp/factories.py

@@ -2,7 +2,7 @@
 from django.contrib.auth import get_user_model
 from factory import fuzzy
 
-from .models import AudienceChoices, Category, Post, Tag
+from .models import AudienceChoices, Category, CategoryRenamed, Post, Tag
 
 FAKE_USERNAMES = [
     'vigo',
@@ -47,6 +47,14 @@ class Meta:
     name = factory.Iterator(FAKE_CATEGORIES)
 
 
+class CategoryRenamedFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = CategoryRenamed
+        django_get_or_create = ('name',)
+
+    name = factory.Iterator(FAKE_CATEGORIES)
+
+
 class TagFactory(factory.django.DjangoModelFactory):
     class Meta:
         model = Tag
@@ -62,6 +70,7 @@ class Meta:
 
     author = factory.SubFactory(UserFactory)
     category = factory.SubFactory(CategoryFactory)
+    category_renamed = factory.SubFactory(CategoryRenamedFactory)
     title = factory.Sequence(lambda n: f'Book about {FAKE_CATEGORIES[n % len(FAKE_CATEGORIES)]} - {n}')
     audience = fuzzy.FuzzyChoice(AudienceChoices.choices, getter=lambda c: c[0])
 

tests/testproject/testapp/models.py

@@ -1,3 +1,5 @@
+import uuid
+
 from django.conf import settings
 from django.db import models
 
@@ -9,6 +11,14 @@ def __str__(self):
         return self.name
 
 
+class CategoryRenamed(models.Model):
+    renamed_id = models.UUIDField(default=uuid.uuid4, primary_key=True)
+    name = models.CharField(max_length=255)
+
+    def __str__(self):
+        return self.name
+
+
 class Tag(models.Model):
     name = models.CharField(max_length=255)
 
@@ -33,6 +43,11 @@ class Post(models.Model):
         on_delete=models.CASCADE,
         related_name='posts',
     )
+    category_renamed = models.ForeignKey(
+        to='CategoryRenamed',
+        on_delete=models.CASCADE,
+        related_name='posts',
+    )
     tags = models.ManyToManyField(to='Tag', blank=True)
     audience = models.CharField(
         max_length=100,

tests/testproject/testapp/tests.py

@@ -8,7 +8,7 @@
 
 from dalf.admin import DALFChoicesField, DALFRelatedField, DALFRelatedFieldAjax, DALFRelatedOnlyField
 
-from .models import Post
+from .models import Post, Tag
 
 csrf_token_pattern = re.compile(r'name="csrfmiddlewaretoken" value="([^"]+)"')
 
@@ -19,12 +19,14 @@ class MatchingTagValidator(HTMLParser):
     Instances of this class are not reusable. Create a new one for every ``check`` call.
     """
 
-    def __init__(self, expected_attrs, matcher_attrs, tag):
+    def __init__(self, tag, matcher_attrs, expected_attrs, expected_content=None):
         super().__init__()
-        self.expected_attrs = expected_attrs
         self.matcher_attrs = matcher_attrs
         self.target_tag = tag
+        self.expected_attrs = expected_attrs
+        self.expected_content = expected_content
         self.seen_target_tag = False
+        self.inside_target_tag = False
 
     def check(self, content):
         self.feed(content)
@@ -35,19 +37,35 @@ def handle_starttag(self, tag, attrs):
             return
         attrs = dict(attrs)
         if self.matcher_attrs.items() <= attrs.items():
+            self.inside_target_tag = True
             assert not self.seen_target_tag, 'Multiple matching tags found'
             self.seen_target_tag = True
             assert self.expected_attrs.items() <= attrs.items()
 
+    def handle_endtag(self, tag):
+        if tag == self.target_tag:
+            # Yes, this will be incorrect with nested tags of same kind. We don't need
+            # nested tags at all.
+            self.inside_target_tag = False
+
+    def handle_data(self, data):
+        if self.inside_target_tag and self.expected_content is not None:
+            assert data.strip() == self.expected_content
+
+
 
 @pytest.mark.django_db
-def test_post_admin_filters_basics(admin_client, posts):  # noqa: ARG001
+@pytest.mark.usefixtures('posts')
+def test_post_admin_filters_basics(admin_client, unused_tag):
     posts_count = 10
-    post_authors = set(Post.objects.values_list('author__username', flat=True))
-    post_audiences = set(Post.objects.values_list('audience', flat=True))
+    post_authors = dict(Post.objects.values_list('author__id', 'author__username'))
+    post_audiences = {p.audience: p.get_audience_display() for p in Post.objects.all()}
+    post_tags = dict(Tag.objects.filter(post__isnull=False).distinct().values_list('id', 'name'))
 
     assert post_authors
     assert post_audiences
+    assert post_tags
+    target_options = {'author': post_authors, 'audience': post_audiences, 'tags': post_tags}
 
     response = admin_client.get(reverse('admin:testapp_post_changelist'))
     assert response.status_code == HTTPStatus.OK
@@ -60,36 +78,60 @@ def test_post_admin_filters_basics(admin_client, posts):  # noqa: ARG001
 
     assert len(filter_specs) > 0
 
+    expected_lookup_kwargs = {
+        'author': 'author__id__exact',
+        'audience': 'audience__exact',
+        'category': 'category__id__exact',
+        'category_renamed': 'category_renamed__renamed_id__exact',
+        'tags': 'tags__id__exact',
+    }
+
     for spec in filter_specs:
         if isinstance(spec, (DALFRelatedField, DALFChoicesField, DALFRelatedFieldAjax, DALFRelatedOnlyField)):
             filter_choices = list(spec.choices(response.context['cl']))
             filter_custom_options = filter_choices.pop()
-            option_field_name = filter_custom_options.get('field_name', None)
+            option_field_name = filter_custom_options['field_name']
+
+            lookup_kwarg = filter_custom_options['lookup_kwarg']
+            assert lookup_kwarg == expected_lookup_kwargs[option_field_name]
 
-            if option_field_name in ['author', 'audience']:
-                maybe_id_suffix = '__id' if option_field_name == 'author' else ''
+            if option_field_name in ['author', 'audience', 'tags']:
                 validator = MatchingTagValidator(
+                    'select',
+                    {'name': option_field_name},
                     {
                         'class': 'django-admin-list-filter admin-autocomplete',
-                        'name': option_field_name,
-                        'data-lookup-kwarg': f'{option_field_name}{maybe_id_suffix}__exact',
                         'data-theme': 'admin-autocomplete',
+                        'name': option_field_name,
+                        'data-lookup-kwarg': lookup_kwarg,
                     },
-                    {'name': option_field_name},
-                    'select',
                 )
                 validator.check(content)
 
-            if option_field_name == 'author':
-                for author in post_authors:
-                    assert f'{author}</option>' in content
+                for internal, human in target_options[option_field_name].items():
+                    validator = MatchingTagValidator(
+                        'option',
+                        {'value': f'?{lookup_kwarg}={internal}'},
+                        {},
+                        human
+                    )
+                    validator.check(content)
 
-            if option_field_name == 'audience':
-                for audience in post_audiences:
-                    assert f'<option value="?audience__exact={audience}">' in content
-
-            if option_field_name == 'category':
-                assert 'data-field-name="category"></select>' in content
+            elif option_field_name in ['category', 'category_renamed']:
+                validator = MatchingTagValidator(
+                    'select',
+                    {'data-field-name': option_field_name},
+                    {
+                        'class': 'django-admin-list-filter-ajax',
+                        'data-theme': 'admin-autocomplete',
+                        'data-allow-clear': 'true',
+                        'data-lookup-kwarg': lookup_kwarg,
+                        'data-app-label': 'testapp',
+                        'data-model-name': 'post',
+                        'data-field-name': option_field_name,
+                    },
+                )
+                validator.check(content)
 
                 url_params = '&'.join(
                     [f'{key}={value}' for key, value in filter_custom_options.items() if key != 'selected_value']
@@ -98,13 +140,24 @@ def test_post_admin_filters_basics(admin_client, posts):  # noqa: ARG001
                 ajax_resonse = admin_client.get(f'/admin/autocomplete/?{url_params}')
 
                 assert ajax_resonse['Content-Type'] == 'application/json'
-
                 json_response = ajax_resonse.json()
                 assert json_response
 
                 results = json_response.get('results')
-                pagination = json_response.get('pagination', {}).get('more', None)
-
                 assert len(results) == 1
-                assert pagination is not None
+                # Even when not named `id`, autocomplete AJAX will helpfully call it so:
+                assert 'id' in results[0]
+
+                pagination = json_response.get('pagination', {}).get('more', None)
                 assert pagination is False
+            else:
+                pytest.fail(f'Unexpected field: {option_field_name}')
+
+    # Must not include tags that have no associated Posts.
+    validator = MatchingTagValidator(
+        'option',
+        {'value': f'?tags__id__exact={unused_tag.pk}'},
+        {}
+    )
+    validator.feed(content)
+    assert not validator.seen_target_tag