Merge pull request #93 from Gigitsu/feature/ParametricRoute

Parametric route

Author: ream88

lib/bypass/instance.ex

@@ -2,6 +2,7 @@ defmodule Bypass.Instance do
   use GenServer, restart: :transient
 
   import Bypass.Utils
+  import Plug.Router.Utils, only: [build_path_match: 1]
 
   def start_link(opts \\ []) do
     GenServer.start_link(__MODULE__, [opts])
@@ -139,6 +140,7 @@ defmodule Bypass.Instance do
         route,
         new_route(
           fun,
+          path,
           case expect do
             :expect -> :once_or_more
             :expect_once -> :once
@@ -285,18 +287,47 @@ defmodule Bypass.Instance do
   end
 
   defp route_info(method, path, %{expectations: expectations} = _state) do
-    route =
-      case Map.get(expectations, {method, path}, :no_expectations) do
-        :no_expectations ->
-          {:any, :any}
+    segments = build_path_match(path) |> elem(1)
 
-        _ ->
-          {method, path}
-      end
+    route =
+      expectations
+      |> Enum.reduce_while(
+        {:any, :any, %{}},
+        fn
+          {{^method, path_pattern}, %{path_parts: path_parts}}, acc ->
+            case match_route(segments, path_parts) do
+              {true, params} -> {:halt, {method, path_pattern, params}}
+              {false, _} -> {:cont, acc}
+            end
+
+          _, acc ->
+            {:cont, acc}
+        end
+      )
 
     {route, Map.get(expectations, route)}
   end
 
+  defp match_route(path, route) when length(path) == length(route) do
+    path
+    |> Enum.zip(route)
+    |> Enum.reduce_while(
+      {true, %{}},
+      fn
+        {value, {param, _, _}}, {_, params} ->
+          {:cont, {true, Map.put(params, Atom.to_string(param), value)}}
+
+        {segment, segment}, acc ->
+          {:cont, acc}
+
+        _, _ ->
+          {:halt, {false, nil}}
+      end
+    )
+  end
+
+  defp match_route(_, _), do: {false, nil}
+
   defp do_up(port, ref) do
     plug_opts = [self()]
     {:ok, socket} = :ranch_tcp.listen(so_reuseport() ++ [ip: listen_ip(), port: port])
@@ -353,16 +384,23 @@ defmodule Bypass.Instance do
     |> length
   end
 
-  defp new_route(fun, expected) do
+  defp new_route(fun, path_parts, expected) when is_list(path_parts) do
     %{
       fun: fun,
       expected: expected,
+      path_parts: path_parts,
       retained_plugs: %{},
       results: [],
       request_count: 0
     }
   end
 
+  defp new_route(fun, :any, expected),
+    do: new_route(fun, [], expected)
+
+  defp new_route(fun, path, expected),
+    do: new_route(fun, build_path_match(path) |> elem(1), expected)
+
   defp cowboy_opts(port, ref, socket) do
     case Application.spec(:plug_cowboy, :vsn) do
       '1.' ++ _ -> [ref: ref, acceptors: 5, port: port, socket: socket]

lib/bypass/plug.ex

@@ -2,9 +2,12 @@ defmodule Bypass.Plug do
   def init([pid]), do: pid
 
   def call(%{method: method, request_path: request_path} = conn, pid) do
-    route = Bypass.Instance.call(pid, {:get_route, method, request_path})
+    {method, path, path_params} = Bypass.Instance.call(pid, {:get_route, method, request_path})
+    route = {method, path}
     ref = make_ref()
 
+    conn = Plug.Conn.fetch_query_params(%{conn | params: path_params})
+
     case Bypass.Instance.call(pid, {:get_expect_fun, route}) do
       fun when is_function(fun, 1) ->
         retain_current_plug(pid, route, ref)

test/bypass_test.exs

@@ -362,6 +362,49 @@ defmodule BypassTest do
     end)
   end
 
+  test "Bypass.stub/4 does not raise if request with parameters is made" do
+    :stub |> specific_route_with_params
+  end
+
+  test "Bypass.expect/4 can be used to define a specific route with parameters" do
+    :expect |> specific_route_with_params
+  end
+
+  test "Bypass.expect_once/4 can be used to define a specific route with parameters" do
+    :expect_once |> specific_route_with_params
+  end
+
+  defp specific_route_with_params(expect_fun) do
+    bypass = Bypass.open()
+    method = "POST"
+    pattern = "/this/:resource/get/:id"
+    path = "/this/my_resource/get/1234"
+
+    # one of Bypass.expect or Bypass.expect_once
+    apply(Bypass, expect_fun, [
+      bypass,
+      method,
+      pattern,
+      fn conn ->
+        assert conn.method == method
+        assert conn.request_path == path
+
+        assert conn.params == %{
+                 "resource" => "my_resource",
+                 "id" => "1234",
+                 "q_param_1" => "a",
+                 "q_param_2" => "b"
+               }
+
+        Plug.Conn.send_resp(conn, 200, "")
+      end
+    ])
+
+    capture_log(fn ->
+      assert {:ok, 200, ""} = request(bypass.port, path <> "?q_param_1=a&q_param_2=b")
+    end)
+  end
+
   test "All routes to a Bypass.expect/4 call must be called" do
     :expect |> all_routes_must_be_called
   end