defmodule Chaperon.Action.HTTP do
@moduledoc """
HTTP based actions to be run in a `Chaperon.Scenario` module for a given
`Chaperon.Session`.
This supports `GET`, `POST`, `PUT`, `PATCH`, `DELETE` & `HEAD` requests with
support for optional headers & query params.
"""
defstruct method: :get,
path: nil,
headers: %{},
params: %{},
body: nil,
decode: nil,
callback: nil,
metrics_url: nil
@type method :: :get | :post | :put | :patch | :delete | :head
@type options :: [
form: map | Keyword.t(),
json: map | Keyword.t(),
headers: map | Keyword.t(),
params: map | Keyword.t(),
decode: :json | (HTTPoison.Response.t() -> any),
with_result: Chaperon.Session.result_callback(),
metrics_url: String.t()
]
@type t :: %Chaperon.Action.HTTP{
method: method,
path: String.t(),
headers: map,
params: map,
body: binary,
decode: :json | (HTTPoison.Response.t() -> any),
callback: Chaperon.Session.result_callback(),
metrics_url: String.t()
}
@spec get(String.t(), options) :: t
def get(path, opts) do
%Chaperon.Action.HTTP{
method: :get,
path: path
}
|> add_options(opts)
end
@spec post(String.t(), options) :: t
def post(path, opts) do
%Chaperon.Action.HTTP{
method: :post,
path: path
}
|> add_options(opts)
end
@spec put(String.t(), options) :: t
def put(path, opts) do
%Chaperon.Action.HTTP{
method: :put,
path: path
}
|> add_options(opts)
end
@spec patch(String.t(), options) :: t
def patch(path, opts) do
%Chaperon.Action.HTTP{
method: :patch,
path: path
}
|> add_options(opts)
end
@spec delete(String.t(), options) :: t
def delete(path, opts \\ []) do
%Chaperon.Action.HTTP{
method: :delete,
path: path
}
|> add_options(opts)
end
alias __MODULE__
alias Chaperon.Session
def url(%{path: ""}, %Session{config: %{base_url: base_url}}) do
base_url <> "/"
end
def url(%{path: path}, %Session{config: %{base_url: base_url}}) do
if is_full_url?(path) do
path
else
base_url <> path
end
end
def url(%{path: path}, _) do
path
end
def is_full_url?("http://" <> _), do: true
def is_full_url?("https://" <> _), do: true
def is_full_url?("ws://" <> _), do: true
def is_full_url?("wss://" <> _), do: true
def is_full_url?(_), do: false
def full_url(action = %HTTP{method: method, params: params}, session) do
url = url(action, session)
case method do
:get -> url <> query_params_string(params)
_ -> url
end
end
def metrics_url(%{metrics_url: metrics_url}, %Session{config: %{base_url: base_url}})
when not is_nil(metrics_url) do
base_url <> metrics_url
end
def metrics_url(action, session) do
if session.config[:skip_query_params_in_metrics] do
action
|> url(session)
else
action
|> full_url(session)
end
end
def full_path(%{path: path, params: params}), do: path <> query_params_string(params)
def query_params_string([]), do: ""
def query_params_string(params) do
case URI.encode_query(params) do
"" -> ""
q -> "?" <> q
end
end
def options(action, session) do
opts =
session.config
|> Map.get(:http, %{})
|> Enum.into([])
|> Keyword.merge(params: action.params)
case hackney_opts(action, session) do
[] ->
opts
hackney_opts ->
opts
|> Keyword.merge(hackney: hackney_opts)
end
end
@default_headers %{
"User-Agent" => "chaperon",
"Accept" => "*/*"
}
@spec add_options(any, Chaperon.Action.HTTP.options()) :: t
def add_options(action, opts) do
alias Keyword, as: KW
import Map, only: [merge: 2]
headers = opts[:headers] || %{}
params = opts[:params] || %{}
decode = opts[:decode]
callback = opts[:with_result]
metrics_url = opts[:metrics_url]
{new_headers, body} =
opts
|> KW.delete(:headers)
|> KW.delete(:params)
|> KW.delete(:decode)
|> KW.delete(:with_result)
|> KW.delete(:metrics_url)
|> parse_body
headers =
action.headers
|> merge(@default_headers)
|> merge(headers)
|> merge(new_headers)
%{
action
| headers: headers,
params: params,
body: body,
decode: decode,
callback: callback,
metrics_url: metrics_url
}
end
defp hackney_opts(_action, session) do
opts = [
cookie: session.cookies,
basic_auth: session.config[:basic_auth],
pool: :chaperon,
insecure: session.config[:insecure]
]
opts
|> Enum.map(&hackney_opt/1)
|> Enum.reject(&is_nil/1)
end
# don't pass if no value set
defp hackney_opt({_key, nil}), do: nil
# don't pass empty list of cookies
defp hackney_opt({:cookie, []}), do: nil
# pass everything else as hackney option
defp hackney_opt(opt), do: opt
defp parse_body([]), do: {%{}, ""}
defp parse_body(json: data) when is_list(data) do
data =
if Keyword.keyword?(data) do
data |> Enum.into(%{})
else
data
end
data
|> json_body
end
defp parse_body(json: data), do: data |> json_body
defp parse_body(form: data), do: data |> form_body
defp json_body(data) do
{
%{"Content-Type" => "application/json", "Accept" => "application/json"},
data |> Poison.encode!()
}
end
defp form_body(data) do
{
%{"Content-Type" => "application/x-www-form-urlencoded"},
data |> URI.encode_query()
}
end
end
defimpl Chaperon.Actionable, for: Chaperon.Action.HTTP do
alias Chaperon.Action.Error
alias Chaperon.Action.HTTP
import Chaperon.Timing
import Chaperon.Session
use Chaperon.Session.Logging
def run(action, session) do
full_url = HTTP.full_url(action, session)
session
|> log_info("#{action.method |> to_string |> String.upcase()} #{full_url}")
start = timestamp()
case HTTPoison.request(
action.method,
HTTP.url(action, session),
action.body || "",
action.headers,
HTTP.options(action, session)
) do
{:ok, response} ->
session
|> add_result(action, response)
|> add_request_metrics(action, response, timestamp() - start)
|> store_response_cookies(response)
|> run_callback_if_defined(action, response)
|> ok
{:error, reason} ->
session
|> log_error("HTTP action #{action} failed")
session =
session
|> run_error_callback(action, reason)
{:error, %Error{reason: reason, action: action, session: session}}
end
end
defp add_request_metrics(
session,
action,
_response = %HTTPoison.Response{status_code: status_code},
duration
) do
metrics_url = HTTP.metrics_url(action, session)
session =
session
|> add_metric({action.method, metrics_url}, duration)
case status_code do
c when c < 400 ->
session
c when c in 400..599 ->
session
|> add_metric({{:error, {:http, c}}, {action.method, metrics_url}}, duration)
end
end
def run_callback_if_defined(session, action, response) do
case response.status_code do
code when code in 200..399 ->
session
|> log_debug("HTTP Response #{action} : #{code}")
|> run_callback(action, response)
code ->
session
|> log_warn("HTTP Response #{action} failed with status code: #{code}")
|> log_warn(response.body)
|> run_error_callback(action, response)
end
end
def abort(action, session) do
# TODO
{:ok, action, session}
end
end
defimpl String.Chars, for: Chaperon.Action.HTTP do
alias Chaperon.Action.HTTP
@methods [:get, :post, :put, :patch, :delete, :head]
@method_strings @methods
|> Enum.map(&{&1, &1 |> Kernel.to_string() |> String.upcase()})
|> Enum.into(%{})
def to_string(http) do
"#{@method_strings[http.method]} #{HTTP.full_url(http, %{})}"
end
end
