Fixed #35529 -- Added support for positional arguments in querystring template tag.

Co-authored-by: Natalia <124304+nessita@users.noreply.github.com>

tests/template_tests/syntax_tests/test_querystring.py

@@ -1,5 +1,6 @@
 from django.http import QueryDict
 from django.template import RequestContext
+from django.template.base import TemplateSyntaxError
 from django.test import RequestFactory, SimpleTestCase
 
 from ..utils import setup
@@ -13,6 +14,10 @@ class QueryStringTagTests(SimpleTestCase):
         output = self.engine.render_to_string(template_name, context)
         self.assertEqual(output, expected)
 
+    def assertTemplateSyntaxError(self, template_name, context, expected):
+        with self.assertRaisesMessage(TemplateSyntaxError, expected):
+            self.engine.render_to_string(template_name, context)
+
     @setup({"querystring_empty_get_params": "{% querystring %}"})
     def test_querystring_empty_get_params(self):
         context = RequestContext(self.request_factory.get("/"))
@@ -26,6 +31,19 @@ class QueryStringTagTests(SimpleTestCase):
             with self.subTest(context=context):
                 self.assertRenderEqual("querystring_remove_all_params", context, "?")
 
+    @setup(
+        {
+            "querystring_remove_all_params_custom_querydict": (
+                "{% querystring my_query_dict my_dict a=None %}"
+            )
+        }
+    )
+    def test_querystring_remove_all_params_custom_querydict(self):
+        context = {"my_query_dict": QueryDict("a=1&b=2"), "my_dict": {"b": None}}
+        self.assertRenderEqual(
+            "querystring_remove_all_params_custom_querydict", context, "?"
+        )
+
     @setup({"querystring_non_empty_get_params": "{% querystring %}"})
     def test_querystring_non_empty_get_params(self):
         request = self.request_factory.get("/", {"a": "b"})
@@ -42,7 +60,7 @@ class QueryStringTagTests(SimpleTestCase):
 
     @setup({"querystring_empty_params": "{% querystring qd %}"})
     def test_querystring_empty_params(self):
-        cases = [None, {}, QueryDict()]
+        cases = [{}, QueryDict()]
         request = self.request_factory.get("/")
         qs = "?a=b"
         request_with_qs = self.request_factory.get(f"/{qs}")
@@ -87,6 +105,82 @@ class QueryStringTagTests(SimpleTestCase):
             "querystring_remove_nonexistent", context, expected="?x=y&a=1"
         )
 
+    @setup({"querystring_remove_dict": "{% querystring my_dict a=1 %}"})
+    def test_querystring_remove_from_dict(self):
+        request = self.request_factory.get("/", {"test": "value"})
+        context = RequestContext(request, {"my_dict": {"test": None}})
+        self.assertRenderEqual("querystring_remove_dict", context, expected="?a=1")
+
+    @setup({"querystring_variable": "{% querystring a=a %}"})
+    def test_querystring_variable(self):
+        request = self.request_factory.get("/")
+        context = RequestContext(request, {"a": 1})
+        self.assertRenderEqual("querystring_variable", context, expected="?a=1")
+
+    @setup({"querystring_dict": "{% querystring my_dict %}"})
+    def test_querystring_dict(self):
+        context = {"my_dict": {"a": 1}}
+        self.assertRenderEqual("querystring_dict", context, expected="?a=1")
+
+    @setup({"querystring_dict_list": "{% querystring my_dict %}"})
+    def test_querystring_dict_list_values(self):
+        context = {"my_dict": {"a": [1, 2]}}
+        self.assertRenderEqual(
+            "querystring_dict_list", context, expected="?a=1&a=2"
+        )
+
+    @setup(
+        {
+            "querystring_multiple_args_override": (
+                "{% querystring my_dict my_query_dict x=3 y=None %}"
+            )
+        }
+    )
+    def test_querystring_multiple_args_override(self):
+        context = {"my_dict": {"x": 0, "y": 42}, "my_query_dict": QueryDict("a=1&b=2")}
+        self.assertRenderEqual(
+            "querystring_multiple_args_override",
+            context,
+            expected="?x=3&a=1&b=2",
+        )
+
+    @setup({"querystring_request_get_ignored": "{% querystring my_mapping %}"})
+    def test_querystring_request_get_ignored(self):
+        cases = [({"y": "x"}, "?y=x"), ({}, "?")]
+        request = self.request_factory.get("/", {"x": "y", "a": "b"})
+        for param, expected in cases:
+            with self.subTest(param=param):
+                context = RequestContext(request, {"my_mapping": param})
+                self.assertRenderEqual(
+                    "querystring_request_get_ignored", context, expected=expected
+                )
+
+    @setup({"querystring_same_arg": "{% querystring a=1 a=2 %}"})
+    def test_querystring_same_arg(self):
+        msg = "'querystring' received multiple values for keyword argument 'a'"
+        self.assertTemplateSyntaxError("querystring_same_arg", {}, msg)
+
+    @setup({"querystring_non_mapping_args": "{% querystring somevar %}"})
+    def test_querystring_non_mapping_args(self):
+        cases = [None, 0, "", []]
+        request = self.request_factory.get("/")
+        msg = (
+            "querystring requires mappings for positional arguments (got %r "
+            "instead)."
+        )
+        for param in cases:
+            with self.subTest(param=param):
+                context = RequestContext(request, {"somevar": param})
+                self.assertTemplateSyntaxError(
+                    "querystring_non_mapping_args", context, msg % param
+                )
+
+    @setup({"querystring_non_string_dict_keys": "{% querystring my_dict %}"})
+    def test_querystring_non_string_dict_keys(self):
+        context = {"my_dict": {0: 1}}
+        msg = "querystring requires strings for mapping keys (got 0 instead)."
+        self.assertTemplateSyntaxError("querystring_non_string_dict_keys", context, msg)
+
     @setup({"querystring_list": "{% querystring a=my_list %}"})
     def test_querystring_add_list(self):
         request = self.request_factory.get("/")