sort query params in verified routes during tests (#6536)

By having the query parameters being serialized in order (during tests only)
when using VerifiedRoutes, we can make some test assertions, like e.g.
`assert_redirect/3` from Phoenix.Liveview, less brittle when the query params
are constructed dynamically in the backend and it's not easy to predict /
maintain exact query param order in tested urls.

This behaviour will be enabled in newly generated apps by default. For existing
apps, add the following to `confing/test.exs`

```elixir
config :phoenix,
  sort_verified_routes_query_params: true
```

Author: bottlenecked

config/config.exs

@@ -7,7 +7,8 @@ config :logger, :console,
 config :phoenix,
   json_library: Jason,
   stacktrace_depth: 20,
-  trim_on_html_eex_engine: false
+  trim_on_html_eex_engine: false,
+  sort_verified_routes_query_params: true
 
 if Mix.env() == :dev do
   esbuild = fn args ->

installer/templates/phx_single/config/test.exs

@@ -23,3 +23,7 @@ config :phoenix, :plug_init_mode, :runtime<%= if @html do %>
 # Enable helpful, but potentially expensive runtime checks
 config :phoenix_live_view,
   enable_expensive_runtime_checks: true<% end %>
+
+# Sort query params output of verified routes for robust url comparisons
+config :phoenix,
+  sort_verified_routes_query_params: true

installer/templates/phx_umbrella/config/test.exs

@@ -16,3 +16,7 @@ config :phoenix, :plug_init_mode, :runtime<%= if @html do %>
 # Enable helpful, but potentially expensive runtime checks
 config :phoenix_live_view,
   enable_expensive_runtime_checks: true<% end %>
+  
+# Sort query params output of verified routes for robust url comparisons
+config :phoenix,
+  sort_verified_routes_query_params: true

lib/phoenix/verified_routes.ex

@@ -42,6 +42,10 @@ defmodule Phoenix.VerifiedRoutes do
   Like path segments, query strings params are proper URL encoded and may be interpolated
   directly into the ~p string.
 
+  To ease url comparisons during tests (e.g. when using `assert_redirect/3`) query params
+  will be sorted. This is controlled by the `phoenix: [sort_verified_routes_query_params: true]`
+  configuration option.
+
   ## What about named routes?
 
   Many web frameworks, and early versions of Phoenix, provided a feature called "named routes".
@@ -821,7 +825,11 @@ defmodule Phoenix.VerifiedRoutes do
             "interpolated query string params must be separated by &, got: #{Macro.to_string(route)}"
     end
 
-    rewrite = {:"::", m1, [{{:., m2, [__MODULE__, :__encode_query__]}, m3, [arg]}, bin]}
+    sort_params? = Application.get_env(:phoenix, :sort_verified_routes_query_params, false)
+
+    rewrite =
+      {:"::", m1, [{{:., m2, [__MODULE__, :__encode_query__]}, m3, [arg, sort_params?]}, bin]}
+
     verify_query(rest, route, [rewrite | acc])
   end
 
@@ -880,14 +888,22 @@ defmodule Phoenix.VerifiedRoutes do
   end
 
   @doc false
-  def __encode_query__(dict) when is_list(dict) or (is_map(dict) and not is_struct(dict)) do
+  def __encode_query__(dict, sort? \\ false)
+
+  def __encode_query__(dict, sort?)
+      when is_list(dict) or (is_map(dict) and not is_struct(dict)) do
     case Plug.Conn.Query.encode(dict, &to_param/1) do
       "" -> ""
-      query_str -> query_str
+      query_str -> maybe_sort_query(query_str, sort?)
     end
   end
 
-  def __encode_query__(val), do: val |> to_param() |> URI.encode_www_form()
+  def __encode_query__(val, _sort?), do: val |> to_param() |> URI.encode_www_form()
+
+  defp maybe_sort_query(query_str, false), do: query_str
+
+  defp maybe_sort_query(query, true),
+    do: query |> String.split("&") |> Enum.sort() |> Enum.join("&")
 
   defp to_param(int) when is_integer(int), do: Integer.to_string(int)
   defp to_param(bin) when is_binary(bin), do: bin

test/phoenix/verified_routes_test.exs

@@ -371,6 +371,14 @@ defmodule Phoenix.VerifiedRoutesTest do
 
     assert ~p"/posts/5?#{[foo: %{__struct__: Foo, id: 5}]}" ==
              "/posts/5?foo=5"
+
+    # {key, value} params pairs are sorted
+    assert ~p"/posts/5?#{[b: 2, a: 1, c: 3]}" == "/posts/5?a=1&b=2&c=3"
+    assert ~p"/posts/5?#{%{b: 2, a: 1, c: 3}}" == "/posts/5?a=1&b=2&c=3"
+    # array values are sorted
+    assert ~p"/posts/5?#{[foo: ~w(b a)]}" == "/posts/5?foo[]=a&foo[]=b"
+    # ampersands are escaped and won't mess with splitting query at '&'
+    assert ~p"/posts/5?#{[foo: "bar", "a&b": "e&f"]}" == "/posts/5?a%26b=e%26f&foo=bar"
   end
 
   test "~p mixed query string interpolation" do