diff --git a/lib/httpoison.ex b/lib/httpoison.ex
index 22a93ab..1f0d978 100644
--- a/lib/httpoison.ex
+++ b/lib/httpoison.ex
@@ -1,6 +1,67 @@
+defmodule HTTPoison.Request do
+  @moduledoc """
+  `Request` properties:
+    * `:method` - HTTP method as an atom (`:get`, `:head`, `:post`, `:put`,
+      `:delete`, etc.)
+    * `:url` - target url as a binary string or char list
+    * `:body` - request body. See more below
+    * `:headers` - HTTP headers as an orddict (e.g., `[{"Accept", "application/json"}]`)
+    * `:options` - Keyword list of options
+    * `:params` - Query parameters as a map, keyword, or orddict
+
+  `:body`:
+    * binary, char list or an iolist
+    * `{:form, [{K, V}, ...]}` - send a form url encoded
+    * `{:file, "/path/to/file"}` - send a file
+    * `{:stream, enumerable}` - lazily send a stream of binaries/charlists
+
+  `:options`:
+    * `:timeout` - timeout for establishing a TCP or SSL connection, in milliseconds. Default is 8000
+    * `:recv_timeout` - timeout for receiving an HTTP response from the socket. Default is 5000
+    * `:stream_to` - a PID to stream the response to
+    * `:async` - if given `:once`, will only stream one message at a time, requires call to `stream_next`
+    * `:proxy` - a proxy to be used for the request; it can be a regular url
+      or a `{Host, Port}` tuple, or a `{:socks5, ProxyHost, ProxyPort}` tuple
+    * `:proxy_auth` - proxy authentication `{User, Password}` tuple
+    * `:socks5_user`- socks5 username
+    * `:socks5_pass`- socks5 password
+    * `:ssl` - SSL options supported by the `ssl` erlang module
+    * `:follow_redirect` - a boolean that causes redirects to be followed
+    * `:max_redirect` - an integer denoting the maximum number of redirects to follow
+    * `:params` - an enumerable consisting of two-item tuples that will be appended to the url as query string parameters
+    * `:max_body_length` - a non-negative integer denoting the max response body length. See :hackney.body/2
+
+    Timeouts can be an integer or `:infinity`
+  """
+  @enforce_keys [:url]
+  defstruct method: :get, url: nil, headers: [], body: "", params: %{}, options: []
+  @type method :: :get | :post | :put | :patch | :delete | :options | :head
+  @type headers :: [{atom, binary}] | [{binary, binary}] | %{binary => binary}
+  @type url :: binary
+  @type body :: binary | {:form, [{atom, any}]} | {:file, binary}
+  @type params :: map | keyword | [{binary, binary}]
+  @type options :: keyword
+  @type t :: %__MODULE__{
+          method: method,
+          url: binary,
+          headers: headers,
+          body: body,
+          params: params,
+          options: options
+        }
+end
+
 defmodule HTTPoison.Response do
-  defstruct status_code: nil, body: nil, headers: [], request_url: nil
-  @type t :: %__MODULE__{status_code: integer, body: term, headers: list}
+  defstruct status_code: nil, body: nil, headers: [], request_url: nil, request: nil
+  alias HTTPoison.Request
+
+  @type t :: %__MODULE__{
+          status_code: integer,
+          body: term,
+          headers: list,
+          request: Request.t(),
+          request_url: Request.url()
+        }
 end
 
 defmodule HTTPoison.AsyncResponse do
diff --git a/lib/httpoison/base.ex b/lib/httpoison/base.ex
index a61faca..20ec6f9 100644
--- a/lib/httpoison/base.ex
+++ b/lib/httpoison/base.ex
@@ -67,11 +67,12 @@ defmodule HTTPoison.Base do
 
       # Used to arbitrarily process the status code of a response before
       # returning it to the caller.
-      @spec process_status_code(integer) :: term
-      def process_status_code(status_code)
+      @spec process_response_status_code(integer) :: term
+      def process_response_status_code(status_code)
 
   """
 
+  alias HTTPoison.Request
   alias HTTPoison.Response
   alias HTTPoison.AsyncResponse
   alias HTTPoison.Error
@@ -132,21 +133,24 @@ defmodule HTTPoison.Base do
   @callback post!(url, term, headers) :: Response.t() | AsyncResponse.t()
   @callback post!(url, term, headers, options) :: Response.t() | AsyncResponse.t()
 
-  @callback process_headers(headers) :: headers
+  @callback process_headers(response | headers) :: headers
+  @callback process_response_headers(response | headers) :: headers
 
-  @callback process_request_body(term) :: body
+  @callback process_request_body(request | term) :: body
 
-  @callback process_request_headers(headers) :: headers
+  @callback process_request_headers(request | headers) :: headers
 
-  @callback process_request_options(options) :: options
+  @callback process_request_options(request | options) :: options
 
-  @callback process_response_body(binary) :: term
+  @callback process_response_body(response | binary) :: term
 
   @callback process_response_chunk(binary) :: term
 
-  @callback process_status_code(integer) :: term
+  @callback process_status_code(response | integer) :: term
+  @callback process_response_status_code(response | integer) :: term
 
-  @callback process_url(binary) :: binary
+  @callback process_url(request | term) :: url
+  @callback process_request_url(request | term) :: url
 
   @callback put(binary) :: {:ok, Response.t() | AsyncResponse.t()} | {:error, Error.t()}
   @callback put(binary, term) :: {:ok, Response.t() | AsyncResponse.t()} | {:error, Error.t()}
@@ -175,59 +179,154 @@ defmodule HTTPoison.Base do
 
   @callback stream_next(AsyncResponse.t()) :: {:ok, AsyncResponse.t()} | {:error, Error.t()}
 
-  @type url :: binary
-  @type headers :: [{atom, binary}] | [{binary, binary}] | %{binary => binary}
-  @type body :: binary | {:form, [{atom, any}]} | {:file, binary}
-  @type options :: Keyword.t()
+  @type response :: Response.t()
+  @type request :: Request.t()
+  @type url :: Request.url()
+  @type headers :: Request.headers()
+  @type body :: Request.body()
+  @type options :: Request.options()
+  @type params :: Request.params()
 
   defmacro __using__(_) do
     quote do
       @behaviour HTTPoison.Base
+
+      @type response :: HTTPoison.Base.response()
+      @type request :: HTTPoison.Base.request()
+      @type url :: HTTPoison.Base.url()
       @type headers :: HTTPoison.Base.headers()
       @type body :: HTTPoison.Base.body()
+      @type options :: HTTPoison.Base.options()
+      @type params :: HTTPoison.Base.params()
 
       @doc """
       Starts HTTPoison and its dependencies.
       """
       def start, do: :application.ensure_all_started(:httpoison)
 
+      @deprecated "Use process_request_url/1 instead"
+      @spec process_url(request | url) :: url
       def process_url(url) do
-        HTTPoison.Base.default_process_url(url)
+        HTTPoison.Base.default_process_request_url(url)
       end
 
-      @spec process_request_body(any) :: body
+      @spec process_request_url(request | url) :: url
+      def process_request_url(%Request{url: url}), do: process_request_url(url)
+
+      def process_request_url(url), do: process_url(url)
+
+      @spec process_request_body(request | any) :: body
+      def process_request_body(%Request{body: body}), do: process_request_body(body)
+
       def process_request_body(body), do: body
 
-      @spec process_response_body(binary) :: any
-      def process_response_body(body), do: body
+      @spec process_request_headers(request | headers) :: headers
+      def process_request_headers(%Request{headers: headers}) do
+        process_request_headers(headers)
+      end
 
-      @spec process_request_headers(headers) :: headers
       def process_request_headers(headers) when is_map(headers) do
         Enum.into(headers, [])
       end
 
       def process_request_headers(headers), do: headers
 
+      @spec process_request_options(request | options) :: options
+      def process_request_options(%Request{options: options}) do
+        process_request_options(options)
+      end
+
       def process_request_options(options), do: options
 
-      def process_response_chunk(chunk), do: chunk
+      @spec process_request_params(request | any) :: params
+      def process_request_params(%Request{params: params}), do: process_request_params(params)
+
+      def process_request_params(params), do: params
+
+      @spec process_response(response) :: any
+      def process_response(%Response{} = response), do: response
 
+      @deprecated "Use process_response_headers/1 instead"
+      @spec process_headers(list) :: headers
       def process_headers(headers), do: headers
 
+      @spec process_response_headers(list) :: headers
+      def process_response_headers(headers), do: process_headers(headers)
+
+      @deprecated "Use process_response_status_code/1 instead"
+      @spec process_status_code(integer) :: any
       def process_status_code(status_code), do: status_code
 
+      @spec process_response_status_code(integer) :: any
+      def process_response_status_code(status_code), do: process_status_code(status_code)
+
+      @spec process_response_body(binary) :: any
+      def process_response_body(body), do: body
+
+      @spec process_response_chunk(binary) :: any
+      def process_response_chunk(chunk), do: chunk
+
       @doc false
       @spec transformer(pid) :: :ok
       def transformer(target) do
         HTTPoison.Base.transformer(
           __MODULE__,
           target,
-          &process_status_code/1,
-          &process_headers/1,
+          &process_response_status_code/1,
+          &process_response_headers/1,
           &process_response_chunk/1
         )
       end
 
+      @doc ~S"""
+      Issues an HTTP request using a `Request` struct.
+
+      This function returns `{:ok, response}` or `{:ok, async_response}` if the
+      request is successful, `{:error, reason}` otherwise.
+
+      ## Examples
+
+          request = %Request{
+            method: :post,
+            url: "https://my.website.com",
+            body: "{\"foo\": 3}",
+            headers: [{"Accept", "application/json"}]
+          }
+
+          request(request)
+
+      """
+      @spec request(Request.t()) :: {:ok, Response.t() | AsyncResponse.t()} | {:error, Error.t()}
+      def request(%Request{} = request) do
+        params =
+          request.params
+          |> HTTPoison.Base.merge_params(request.options[:params])
+          |> process_request_params()
+
+        url =
+          request
+          |> process_request_url()
+          |> HTTPoison.Base.build_request_url(params)
+
+        request = %Request{
+          method: request.method,
+          url: url,
+          headers: process_request_headers(request),
+          body: process_request_body(request),
+          params: params,
+          options: process_request_options(request)
+        }
+
+        HTTPoison.Base.request(
+          __MODULE__,
+          request,
+          &process_response_status_code/1,
+          &process_response_headers/1,
+          &process_response_body/1,
+          &process_response/1
+        )
+      end
+
       @doc ~S"""
       Issues an HTTP request with the given method to the given url.
 
@@ -241,29 +340,9 @@ defmodule HTTPoison.Base do
         * `headers` - HTTP headers as an orddict (e.g., `[{"Accept", "application/json"}]`)
         * `options` - Keyword list of options
 
-      Body:
-        * binary, char list or an iolist
-        * `{:form, [{K, V}, ...]}` - send a form url encoded
-        * `{:file, "/path/to/file"}` - send a file
-        * `{:stream, enumerable}` - lazily send a stream of binaries/charlists
-
-      Options:
-        * `:timeout` - timeout for establishing a TCP or SSL connection, in milliseconds. Default is 8000
-        * `:recv_timeout` - timeout for receiving an HTTP response from the socket. Default is 5000
-        * `:stream_to` - a PID to stream the response to
-        * `:async` - if given `:once`, will only stream one message at a time, requires call to `stream_next`
-        * `:proxy` - a proxy to be used for the request; it can be a regular url
-          or a `{Host, Port}` tuple, or a `{:socks5, ProxyHost, ProxyPort}` tuple
-        * `:proxy_auth` - proxy authentication `{User, Password}` tuple
-        * `:socks5_user`- socks5 username
-        * `:socks5_pass`- socks5 password
-        * `:ssl` - SSL options supported by the `ssl` erlang module
-        * `:follow_redirect` - a boolean that causes redirects to be followed
-        * `:max_redirect` - an integer denoting the maximum number of redirects to follow
-        * `:params` - an enumerable consisting of two-item tuples that will be appended to the url as query string parameters
-        * `:max_body_length` - a non-negative integer denoting the max response body length. See :hackney.body/2
-
-      Timeouts can be an integer or `:infinity`
+      Body: see type `HTTPoison.Request`
+
+      Options: see type `HTTPoison.Request`
 
       This function returns `{:ok, response}` or `{:ok, async_response}` if the
       request is successful, `{:error, reason}` otherwise.
@@ -274,32 +353,33 @@ defmodule HTTPoison.Base do
 
       """
       @spec request(atom, binary, any, headers, Keyword.t()) ::
-              {:ok, Response.t() | AsyncResponse.t()}
-              | {:error, Error.t()}
+              {:ok, Response.t() | AsyncResponse.t()} | {:error, Error.t()}
       def request(method, url, body \\ "", headers \\ [], options \\ []) do
         options = process_request_options(options)
+        params = process_request_params(options[:params] || %{})
 
         url =
-          cond do
-            not Keyword.has_key?(options, :params) -> url
-            URI.parse(url).query -> url <> "&" <> URI.encode_query(options[:params])
-            true -> url <> "?" <> URI.encode_query(options[:params])
-          end
-
-        url = process_url(to_string(url))
-        body = process_request_body(body)
-        headers = process_request_headers(headers)
+          url
+          |> to_string()
+          |> process_request_url()
+          |> HTTPoison.Base.build_request_url(params)
+
+        request = %Request{
+          method: method,
+          url: url,
+          headers: process_request_headers(headers),
+          body: process_request_body(body),
+          params: params,
+          options: options
+        }
 
         HTTPoison.Base.request(
           __MODULE__,
-          method,
-          url,
-          body,
-          headers,
-          options,
-          &process_status_code/1,
-          &process_headers/1,
-          &process_response_body/1
+          request,
+          &process_response_status_code/1,
+          &process_response_headers/1,
+          &process_response_body/1,
+          &process_response/1
         )
       end
 
@@ -508,15 +588,35 @@ defmodule HTTPoison.Base do
   end
 
   @doc false
-  def transformer(module, target, process_status_code, process_headers, process_response_chunk) do
+  def transformer(
+        module,
+        target,
+        process_response_status_code,
+        process_response_headers,
+        process_response_chunk
+      ) do
     receive do
       {:hackney_response, id, {:status, code, _reason}} ->
-        send(target, %HTTPoison.AsyncStatus{id: id, code: process_status_code.(code)})
-        transformer(module, target, process_status_code, process_headers, process_response_chunk)
+        send(target, %HTTPoison.AsyncStatus{id: id, code: process_response_status_code.(code)})
+
+        transformer(
+          module,
+          target,
+          process_response_status_code,
+          process_response_headers,
+          process_response_chunk
+        )
 
       {:hackney_response, id, {:headers, headers}} ->
-        send(target, %HTTPoison.AsyncHeaders{id: id, headers: process_headers.(headers)})
-        transformer(module, target, process_status_code, process_headers, process_response_chunk)
+        send(target, %HTTPoison.AsyncHeaders{id: id, headers: process_response_headers.(headers)})
+
+        transformer(
+          module,
+          target,
+          process_response_status_code,
+          process_response_headers,
+          process_response_chunk
+        )
 
       {:hackney_response, id, :done} ->
         send(target, %HTTPoison.AsyncEnd{id: id})
@@ -525,16 +625,27 @@ defmodule HTTPoison.Base do
         send(target, %Error{id: id, reason: reason})
 
       {:hackney_response, id, {redirect, to, headers}} when redirect in [:redirect, :see_other] ->
-        send(target, %HTTPoison.AsyncRedirect{id: id, to: to, headers: process_headers.(headers)})
+        send(target, %HTTPoison.AsyncRedirect{
+          id: id,
+          to: to,
+          headers: process_response_headers.(headers)
+        })
 
       {:hackney_response, id, chunk} ->
         send(target, %HTTPoison.AsyncChunk{id: id, chunk: process_response_chunk.(chunk)})
-        transformer(module, target, process_status_code, process_headers, process_response_chunk)
+
+        transformer(
+          module,
+          target,
+          process_response_status_code,
+          process_response_headers,
+          process_response_chunk
+        )
     end
   end
 
   @doc false
-  def default_process_url(url) do
+  def default_process_request_url(url) do
     case url |> String.slice(0, 12) |> String.downcase() do
       "http://" <> _ -> url
       "https://" <> _ -> url
@@ -543,7 +654,28 @@ defmodule HTTPoison.Base do
     end
   end
 
-  defp build_hackney_options(module, options) do
+  @doc false
+  def merge_params(params, nil), do: params
+
+  def merge_params(request_params, options_params) do
+    Map.merge(
+      URI.encode_query(request_params) |> URI.decode_query(),
+      URI.encode_query(options_params) |> URI.decode_query()
+    )
+  end
+
+  @doc false
+  def build_request_url(url, nil), do: url
+
+  def build_request_url(url, params) do
+    cond do
+      Enum.count(params) === 0 -> url
+      URI.parse(url).query -> url <> "&" <> URI.encode_query(params)
+      true -> url <> "?" <> URI.encode_query(params)
+    end
+  end
+
+  defp build_hackney_options(module, %Request{options: options}) do
     timeout = Keyword.get(options, :timeout)
     recv_timeout = Keyword.get(options, :recv_timeout)
     stream_to = Keyword.get(options, :stream_to)
@@ -583,7 +715,7 @@ defmodule HTTPoison.Base do
     hn_options
   end
 
-  defp build_hackney_proxy_options(options, request_url) do
+  defp build_hackney_proxy_options(%Request{options: options, url: request_url}) do
     proxy =
       if Keyword.has_key?(options, :proxy) do
         Keyword.get(options, :proxy)
@@ -614,47 +746,46 @@ defmodule HTTPoison.Base do
   end
 
   @doc false
-  @spec request(atom, atom, binary, body, headers, any, fun, fun, fun) ::
+  @spec request(atom, request, fun, fun, fun, fun) ::
           {:ok, Response.t() | AsyncResponse.t()} | {:error, Error.t()}
   def request(
         module,
-        method,
-        request_url,
-        request_body,
-        request_headers,
-        options,
-        process_status_code,
-        process_headers,
-        process_response_body
+        request,
+        process_response_status_code,
+        process_response_headers,
+        process_response_body,
+        process_response
       ) do
-    hn_proxy_options = build_hackney_proxy_options(options, request_url)
-    hn_options = hn_proxy_options ++ build_hackney_options(module, options)
+    hn_proxy_options = build_hackney_proxy_options(request)
+    hn_options = hn_proxy_options ++ build_hackney_options(module, request)
 
-    case do_request(method, request_url, request_headers, request_body, hn_options) do
+    case do_request(request, hn_options) do
       {:ok, status_code, headers} ->
         response(
-          process_status_code,
-          process_headers,
+          process_response_status_code,
+          process_response_headers,
           process_response_body,
+          process_response,
           status_code,
           headers,
           "",
-          request_url
+          request
         )
 
       {:ok, status_code, headers, client} ->
-        max_length = Keyword.get(options, :max_body_length, :infinity)
+        max_length = Keyword.get(request.options, :max_body_length, :infinity)
 
         case :hackney.body(client, max_length) do
           {:ok, body} ->
             response(
-              process_status_code,
-              process_headers,
+              process_response_status_code,
+              process_response_headers,
               process_response_body,
+              process_response,
               status_code,
               headers,
               body,
-              request_url
+              request
             )
 
           {:error, reason} ->
@@ -669,8 +800,9 @@ defmodule HTTPoison.Base do
     end
   end
 
-  defp do_request(method, request_url, request_headers, {:stream, enumerable}, hn_options) do
-    with {:ok, ref} <- :hackney.request(method, request_url, request_headers, :stream, hn_options) do
+  defp do_request(%Request{body: {:stream, enumerable}} = request, hn_options) do
+    with {:ok, ref} <-
+           :hackney.request(request.method, request.url, request.headers, :stream, hn_options) do
       failures =
         Stream.transform(enumerable, :ok, fn
           _, :error -> {:halt, :error}
@@ -689,25 +821,28 @@ defmodule HTTPoison.Base do
     end
   end
 
-  defp do_request(method, request_url, request_headers, request_body, hn_options) do
-    :hackney.request(method, request_url, request_headers, request_body, hn_options)
+  defp do_request(request, hn_options) do
+    :hackney.request(request.method, request.url, request.headers, request.body, hn_options)
   end
 
   defp response(
-         process_status_code,
-         process_headers,
+         process_response_status_code,
+         process_response_headers,
          process_response_body,
+         process_response,
          status_code,
          headers,
          body,
-         request_url
+         request
        ) do
     {:ok,
      %Response{
-       status_code: process_status_code.(status_code),
-       headers: process_headers.(headers),
+       status_code: process_response_status_code.(status_code),
+       headers: process_response_headers.(headers),
        body: process_response_body.(body),
-       request_url: request_url
-     }}
+       request: request,
+       request_url: request.url
+     }
+     |> process_response.()}
   end
 end
diff --git a/test/httpoison_base_test.exs b/test/httpoison_base_test.exs
index d791ea3..d237968 100644
--- a/test/httpoison_base_test.exs
+++ b/test/httpoison_base_test.exs
@@ -4,7 +4,7 @@ defmodule HTTPoisonBaseTest do
 
   setup :verify_on_exit!
 
-  defmodule Example do
+  defmodule DeprecatedExample do
     use HTTPoison.Base
     def process_url(url), do: "http://" <> url
     def process_request_body(body), do: {:req_body, body}
@@ -15,6 +15,18 @@ defmodule HTTPoisonBaseTest do
     def process_status_code(code), do: {:code, code}
   end
 
+  defmodule Example do
+    use HTTPoison.Base
+    def process_request_url(url), do: "http://" <> url
+    def process_request_body(body), do: {:req_body, body}
+    def process_request_headers(headers), do: {:req_headers, headers}
+    def process_request_options(options), do: Keyword.put(options, :timeout, 10)
+    def process_response_body(body), do: {:resp_body, body}
+    def process_response_headers(headers), do: {:headers, headers}
+    def process_response_status_code(code), do: {:code, code}
+    def process_response(response), do: {:resp, response}
+  end
+
   defmodule ExampleParamsOptions do
     use HTTPoison.Base
     def process_url(url), do: "http://" <> url
@@ -44,11 +56,45 @@ defmodule HTTPoisonBaseTest do
     expect(:hackney, :body, fn _, _ -> {:ok, "response"} end)
 
     assert Example.post!("localhost", "body") ==
+             {:resp,
+              %HTTPoison.Response{
+                status_code: {:code, 200},
+                headers: {:headers, "headers"},
+                body: {:resp_body, "response"},
+                request_url: "http://localhost",
+                request: %HTTPoison.Request{
+                  body: {:req_body, "body"},
+                  headers: {:req_headers, []},
+                  method: :post,
+                  options: [timeout: 10],
+                  params: %{},
+                  url: "http://localhost"
+                }
+              }}
+  end
+
+  test "request body using DeprecatedExample" do
+    expect(:hackney, :request, fn
+      :post, "http://localhost", {:req_headers, []}, {:req_body, "body"}, [connect_timeout: 10] ->
+        {:ok, 200, "headers", :client}
+    end)
+
+    expect(:hackney, :body, fn _, _ -> {:ok, "response"} end)
+
+    assert DeprecatedExample.post!("localhost", "body") ==
              %HTTPoison.Response{
                status_code: {:code, 200},
                headers: {:headers, "headers"},
                body: {:resp_body, "response"},
-               request_url: "http://localhost"
+               request_url: "http://localhost",
+               request: %HTTPoison.Request{
+                 body: {:req_body, "body"},
+                 headers: {:req_headers, []},
+                 method: :post,
+                 options: [timeout: 10],
+                 params: %{},
+                 url: "http://localhost"
+               }
              }
   end
 
@@ -64,7 +110,15 @@ defmodule HTTPoisonBaseTest do
                status_code: 200,
                headers: "headers",
                body: "response",
-               request_url: "http://localhost?foo=bar&key=fizz"
+               request_url: "http://localhost?foo=bar&key=fizz",
+               request: %HTTPoison.Request{
+                 body: "",
+                 headers: [],
+                 method: :get,
+                 options: [params: %{foo: "bar", key: "fizz"}],
+                 params: %{foo: "bar", key: "fizz"},
+                 url: "http://localhost?foo=bar&key=fizz"
+               }
              }
   end
 
@@ -94,7 +148,15 @@ defmodule HTTPoisonBaseTest do
                status_code: 200,
                headers: "headers",
                body: "response",
-               request_url: "http://localhost"
+               request_url: "http://localhost",
+               request: %HTTPoison.Request{
+                 body: "body",
+                 headers: [],
+                 method: :post,
+                 options: [timeout: 12345],
+                 params: %{},
+                 url: "http://localhost"
+               }
              }
   end
 
@@ -111,7 +173,15 @@ defmodule HTTPoisonBaseTest do
                status_code: 200,
                headers: "headers",
                body: "response",
-               request_url: "http://localhost"
+               request_url: "http://localhost",
+               request: %HTTPoison.Request{
+                 body: "body",
+                 headers: [],
+                 method: :post,
+                 options: [recv_timeout: 12345],
+                 params: %{},
+                 url: "http://localhost"
+               }
              }
   end
 
@@ -127,7 +197,15 @@ defmodule HTTPoisonBaseTest do
                status_code: 200,
                headers: "headers",
                body: "response",
-               request_url: "http://localhost"
+               request_url: "http://localhost",
+               request: %HTTPoison.Request{
+                 body: "body",
+                 headers: [],
+                 method: :post,
+                 options: [proxy: "proxy"],
+                 params: %{},
+                 url: "http://localhost"
+               }
              }
   end
 
@@ -159,7 +237,19 @@ defmodule HTTPoisonBaseTest do
                status_code: 200,
                headers: "headers",
                body: "response",
-               request_url: "http://localhost"
+               request_url: "http://localhost",
+               request: %HTTPoison.Request{
+                 body: "body",
+                 headers: [],
+                 method: :post,
+                 options: [
+                   proxy: {:socks5, 'localhost', 1080},
+                   socks5_user: "user",
+                   socks5_pass: "secret"
+                 ],
+                 params: %{},
+                 url: "http://localhost"
+               }
              }
   end
 
@@ -186,7 +276,15 @@ defmodule HTTPoisonBaseTest do
                status_code: 200,
                headers: "headers",
                body: "response",
-               request_url: "http://localhost"
+               request_url: "http://localhost",
+               request: %HTTPoison.Request{
+                 body: "body",
+                 headers: [],
+                 method: :post,
+                 options: [proxy: "proxy", proxy_auth: {"username", "password"}],
+                 params: %{},
+                 url: "http://localhost"
+               }
              }
   end
 
@@ -204,7 +302,15 @@ defmodule HTTPoisonBaseTest do
                status_code: 200,
                headers: "headers",
                body: "response",
-               request_url: "http://localhost"
+               request_url: "http://localhost",
+               request: %HTTPoison.Request{
+                 body: "body",
+                 headers: [],
+                 method: :post,
+                 options: [],
+                 params: %{},
+                 url: "http://localhost"
+               }
              }
   end
 
@@ -222,7 +328,15 @@ defmodule HTTPoisonBaseTest do
                status_code: 200,
                headers: "headers",
                body: "response",
-               request_url: "http://localhost"
+               request_url: "http://localhost",
+               request: %HTTPoison.Request{
+                 body: "body",
+                 headers: [],
+                 method: :post,
+                 options: [],
+                 params: %{},
+                 url: "http://localhost"
+               }
              }
   end
 
@@ -240,7 +354,15 @@ defmodule HTTPoisonBaseTest do
                status_code: 200,
                headers: "headers",
                body: "response",
-               request_url: "https://localhost"
+               request_url: "https://localhost",
+               request: %HTTPoison.Request{
+                 body: "body",
+                 headers: [],
+                 method: :post,
+                 options: [],
+                 params: %{},
+                 url: "https://localhost"
+               }
              }
   end
 
@@ -258,7 +380,15 @@ defmodule HTTPoisonBaseTest do
                status_code: 200,
                headers: "headers",
                body: "response",
-               request_url: "http://localhost"
+               request_url: "http://localhost",
+               request: %HTTPoison.Request{
+                 body: "body",
+                 headers: [],
+                 method: :post,
+                 options: [],
+                 params: %{},
+                 url: "http://localhost"
+               }
              }
   end
 
@@ -278,7 +408,15 @@ defmodule HTTPoisonBaseTest do
                status_code: 200,
                headers: "headers",
                body: "response",
-               request_url: "http://localhost"
+               request_url: "http://localhost",
+               request: %HTTPoison.Request{
+                 body: "body",
+                 headers: [],
+                 method: :post,
+                 options: [ssl: [certfile: "certs/client.crt"]],
+                 params: %{},
+                 url: "http://localhost"
+               }
              }
   end
 
@@ -298,7 +436,15 @@ defmodule HTTPoisonBaseTest do
                status_code: 200,
                headers: "headers",
                body: "response",
-               request_url: "http://localhost"
+               request_url: "http://localhost",
+               request: %HTTPoison.Request{
+                 body: "body",
+                 headers: [],
+                 method: :post,
+                 options: [follow_redirect: true],
+                 params: %{},
+                 url: "http://localhost"
+               }
              }
   end
 
@@ -314,7 +460,15 @@ defmodule HTTPoisonBaseTest do
                status_code: 200,
                headers: "headers",
                body: "response",
-               request_url: "http://localhost"
+               request_url: "http://localhost",
+               request: %HTTPoison.Request{
+                 body: "body",
+                 headers: [],
+                 method: :post,
+                 options: [max_redirect: 2],
+                 params: %{},
+                 url: "http://localhost"
+               }
              }
   end
 
@@ -331,7 +485,15 @@ defmodule HTTPoisonBaseTest do
                 status_code: 200,
                 headers: "headers",
                 body: "response",
-                request_url: "http://localhost"
+                request_url: "http://localhost",
+                request: %HTTPoison.Request{
+                  body: "",
+                  headers: [],
+                  method: :get,
+                  options: [],
+                  params: %{},
+                  url: "http://localhost"
+                }
               }}
 
     expect(:hackney, :request, fn :get, "http://localhost", [], "", [] ->
@@ -346,7 +508,15 @@ defmodule HTTPoisonBaseTest do
                 status_code: 200,
                 headers: "headers",
                 body: "res",
-                request_url: "http://localhost"
+                request_url: "http://localhost",
+                request: %HTTPoison.Request{
+                  body: "",
+                  headers: [],
+                  method: :get,
+                  options: [max_body_length: 3],
+                  params: %{},
+                  url: "http://localhost"
+                }
               }}
   end
 end