[#33] basic_logger using pretty inspect, printing exception message. …

…basic_logger unit tests. fixing credo warnings.

lib/dayron/adapters/httpoison_adapter.ex

@@ -56,31 +56,31 @@ defmodule Dayron.HTTPoisonAdapter do
   """
   def get(url, headers \\ [], opts \\ []) do
     Client.start
-    Client.get(url, headers, opts) |> translate_response
+    url |> Client.get(headers, opts) |> translate_response
   end
 
   @doc """
   Implementation for `Dayron.Adapter.post/4`.
   """
   def post(url, body, headers \\ [], opts \\ []) do
     Client.start
-    Client.post(url, body, headers, opts) |> translate_response
+    url |> Client.post(body, headers, opts) |> translate_response
   end
 
   @doc """
   Implementation for `Dayron.Adapter.patch/4`.
   """
   def patch(url, body, headers \\ [], opts \\ []) do
     Client.start
-    Client.patch(url, body, headers, opts) |> translate_response
+    url |> Client.patch(body, headers, opts) |> translate_response
   end
 
   @doc """
   Implementation for `Dayron.Adapter.delete/3`.
   """
   def delete(url, headers \\ [], opts \\ []) do
     Client.start
-    Client.delete(url, headers, opts) |> translate_response
+    url |> Client.delete(headers, opts) |> translate_response
   end
 
   defp translate_response({:ok, response}) do

lib/dayron/logger.ex

@@ -8,7 +8,7 @@ defmodule Dayron.Logger do
 
       defmodule Dayron.CustomLogger do
         @behaviour Dayron.Logger
-        
+
         require Logger
 
         def log(request, response) do

lib/dayron/loggers/basic_logger.ex

@@ -9,44 +9,26 @@ defmodule Dayron.BasicLogger do
   @doc """
   Logs a debug message for response codes between 200-399.
   """
-  def log(request, %Response{status_code: code}) when code < 400 do
-    Logger.debug fn ->
-      [inspect_method(request.method), ?\s, request.url, ?\s, "-> #{code}"]
-    end
-    log_request_body(:debug, request.body)
+  def log(request, %Response{status_code: code} = response) when code < 400 do
+    do_log(:debug, request, response)
   end
 
   @doc """
   Logs an error message for error response codes, or greater than 400.
   """
-  def log(request, %Response{status_code: code}) do
-    Logger.error fn ->
-      [inspect_method(request.method), ?\s, request.url, ?\s, "-> #{code}"]
-    end
-    log_request_body(:error, request.body)
-  end
+  def log(request, %Response{} = response), do:
+    do_log(:error, request, response)
 
   @doc """
   Logs an error message for response error/exception.
   """
-  def log(request, %ClientError{reason: reason}) do
-    Logger.error fn ->
-      [inspect_method(request.method), ?\s, request.url, ?\s, "-> #{reason}"]
-    end
-    log_request_body(:error, request.body)
-  end
-
-  defp inspect_method(method) do
-    method |> Atom.to_string |> String.upcase
+  def log(request, %ClientError{} = response) do
+    response = %{response | request: request}
+    Logger.error ClientError.message(response)
   end
 
-  defp log_request_body(_level, nil), do: :ok
-  defp log_request_body(level, body) do
-    if Enum.any?(body) do
-      Logger.log level, fn ->
-        ["Request body:", ?\s, inspect(body, pretty: true)]
-      end
-    end
+  defp do_log(level, request, response) do
+    Logger.log level, inspect(request, pretty: true)
+    Logger.log level, inspect(response, pretty: true)
   end
-
 end

lib/dayron/repo.ex

@@ -42,7 +42,7 @@ defmodule Dayron.Repo do
   alias Dayron.Config
   alias Dayron.Request
   alias Dayron.Response
-  
+
   defmacro __using__(opts) do
     quote bind_quoted: [opts: opts] do
       alias Dayron.Repo
@@ -368,15 +368,15 @@ defmodule Dayron.Repo do
     case response do
       %Response{status_code: 500} ->
         raise Dayron.ServerError, request: request, response: response
-      %Dayron.ClientError{reason: reason} -> :ok
+      %Dayron.ClientError{reason: reason} ->
         raise Dayron.ClientError, request: request, reason: reason
       _ -> {request, response}
     end
   end
 
   defp log_request(data, nil), do: data
   defp log_request({request, response}, logger) do
-    :ok = logger.log(request, response)    
+    :ok = logger.log(request, response)
     {request, response}
   end
 end

lib/dayron/request.ex

@@ -93,17 +93,19 @@ defimpl Inspect, for: Dayron.Request do
   defp list_to_doc([], _level), do: "-"
   defp list_to_doc(%{}, _level), do: "-"
   defp list_to_doc(list, level) do
-    Enum.map(list, fn
+    list
+    |> Enum.map(fn
       {key, value} when is_list(value) ->
         nest(
           glue(
-            concat(Atom.to_string(key) |> String.capitalize, ":"),
+            concat(key |> Atom.to_string |> String.capitalize, ":"),
             list_to_doc(value, level + 1)
           ), @tab_width * level
         )
       {key, value} ->
         concat(Atom.to_string(key) <> "=", inspect(value))
       value -> inspect(value)
-    end) |> fold_doc(&glue(&1,&2))
+    end)
+    |> fold_doc(&glue(&1,&2))
   end
 end

lib/dayron/response.ex

@@ -18,7 +18,7 @@ defimpl Inspect, for: Dayron.Response do
       Response: 200 in 200ms
   """
   import Inspect.Algebra
-  
+
   def inspect(response, %Inspect.Opts{pretty: true}) do
     concat([
       "Response: ",

test/lib/dayron/loggers/basic_logger_test.exs

@@ -0,0 +1,51 @@
+defmodule Dayron.BasicLoggerTest do
+  use ExUnit.Case, async: true
+  alias Dayron.BasicLogger
+  alias Dayron.Request
+  alias Dayron.Response
+  alias Dayron.ClientError
+  import ExUnit.CaptureIO
+
+  defp capture_log(fun) do
+    data = capture_io(:user, fn ->
+      Process.put(:capture_log, fun.())
+      Logger.flush()
+    end)
+    {Process.get(:capture_log), data}
+  end
+
+  setup do
+    body = %{name: "Full Name", age: 30}
+    options = [params: [{:q, "qu ery"}, {:page, 2}]]
+    request = %Request{method: :get, url: "http://localhost/resources", body: body, headers: [access_token: "token"], options: options}
+    {:ok, request: request}
+  end
+
+  test "logs a Response with success", %{request: request} do
+    response = %Response{status_code: 200, elapsed_time: 28000}
+    {:ok, output} = capture_log fn ->
+      :ok = BasicLogger.log(request, response)
+    end
+    assert output =~ ~r/\[debug\] GET http\:\/\/localhost\/resources/ 
+    assert output =~ ~r/\[debug\] Response: 200 in 28ms/
+  end
+
+  test "logs Response with error", %{request: request} do
+    response = %Response{status_code: 500, elapsed_time: 5, body: "Internal Server Error"}
+    {:ok, output} = capture_log fn ->
+      :ok = BasicLogger.log(request, response)
+    end
+    assert output =~ ~r/\[error\] GET http\:\/\/localhost\/resources/ 
+    assert output =~ ~r/\[error\] Response: 500 in 5µs/
+  end
+
+  test "logs ClientError exceptions", %{request: request} do
+    response = %ClientError{reason: :timeout}
+    {:ok, output} = capture_log fn ->
+      :ok = BasicLogger.log(request, response)
+    end
+
+    assert output =~ ~r/\[error\] unexpected client error in request\:\n\nGET/ 
+    assert output =~ ~r/Reason\: \:timeout/
+  end
+end