zest

if Code.ensure_loaded?(Phoenix.ConnTest) do
  defmodule Zest.Phoenix do
    require Phoenix.ConnTest
    alias Phoenix.ConnTest
    alias Plug.Conn
  
    @type filter :: {atom, term}
    @type filters :: [filters] | filter
  
    @spec new() :: Conn.t
    def new(), do: ConnTest.build_conn()
  
    @spec new(filters) :: Conn.t
    def new(filters), do: filter(new(), filters)
  
    @html_mime "text/html"
    @json_mime "application/json"
  
    @spec filter(Conn.t, filters) :: Conn.t
    def filter(conn, [filter | filters]), do: filter(filter(conn, filter), filters)
    def filter(conn, []), do: conn
    def filter(conn, {:method, :get}), do: %{ conn | method: "GET" }
    def filter(conn, {:method, :post}), do: %{ conn | method: "POST" }
    def filter(conn, {:headers, headers}), do: headers
    def filter(conn, {:params, params}), do: %{ conn | params: params }
    def filter(conn, {:accept, :json}), do: header(:accept, @json_mime)
    def filter(conn, {:accept, :html}), do: header(:accept, @html_mime)
    def filter(conn, {:response_type, :json}), do: Conn.put_resp_content_type(conn, @json_mime)
    def filter(conn, {:type, :json}), do: filter(conn, accept: :json, response_type: :json)
  
    def filter(conn, {:auth, value}), do: header(conn, :authorization, value)
  
    def filter(conn, {:bearer_auth, token})
    when is_binary(token), do: filter(conn, auth: "Bearer " <> token)
  
  
    def headers(conn, headers) when is_list(headers) do
      Enum.reduce(headers, conn, &headers(&2, &1))
    end
  
    def headers(conn, {name, value})
    when is_atom(name) and is_binary(value) do
      header(conn, Atom.to_string(name), value)
    end
  
    def headers(conn, {name, value})
    when is_binary(name) and is_binary(value) do
      Conn.put_req_header(conn, name, value)
    end
  
  end
end