f6cc9bc0ae05f24b374e6c1fa9b52e9d0967e032-PR-202

pending completion

Build # f6cc9bc0ae05f24b374e6c1fa9b52e9d0967e032-PR-202

Build Type

Pull #202

github

Committed by parroty

Commit Message

Pull Request Pull Request #202: Fix name conflict for finch test case

Run Details

577 of 642 relevant lines covered (89.88%)

95.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

75.86

/lib/exvcr/adapter/finch.ex

if Code.ensure_loaded?(Finch) do
  defmodule ExVCR.Adapter.Finch do
    @moduledoc """
    Provides adapter methods to mock Finch methods.
    """

    use ExVCR.Adapter

    alias ExVCR.Util

    defmacro __using__(_opts) do
      # do nothing
    end

    defdelegate convert_from_string(string), to: ExVCR.Adapter.Finch.Converter
    defdelegate convert_to_string(request, response), to: ExVCR.Adapter.Finch.Converter
    defdelegate parse_request_body(request_body), to: ExVCR.Adapter.Finch.Converter

    @doc """
    Returns the name of the mock target module.
    """
    def module_name do
      Finch
    end

    @doc """
    Returns list of the mock target methods with function name and callback.
    Implementation for global mock.
    """
    def target_methods() do
      [
        {:request, &ExVCR.Recorder.request([&1,&2])},
        {:request, &ExVCR.Recorder.request([&1,&2,&3])},
        {:request!, &(ExVCR.Recorder.request([&1,&2]) |> handle_response_for_request!())},
        {:request!, &(ExVCR.Recorder.request([&1,&2,&3]) |> handle_response_for_request!())}
      ]
    end

    @doc """
    Returns list of the mock target methods with function name and callback.
    """
    def target_methods(recorder) do
      [
        {:request, &ExVCR.Recorder.request(recorder, [&1,&2])},
        {:request, &ExVCR.Recorder.request(recorder, [&1,&2,&3])},
        {:request!, &(ExVCR.Recorder.request(recorder, [&1,&2]) |> handle_response_for_request!())},
        {:request!, &(ExVCR.Recorder.request(recorder, [&1,&2,&3]) |> handle_response_for_request!())}
      ]
    end

    @doc """
    Generate key for searching response.
    """
    def generate_keys_for_request(request) do
      req = Enum.fetch!(request, 0)
      url = Util.build_url(req.scheme, req.host, req.path, req.port, req.query)

      [url: url, method: String.downcase(req.method), request_body: req.body, headers: req.headers]
    end

    @doc """
    Callback from ExVCR.Handler when response is retrieved from the HTTP server.
    """
    def hook_response_from_server(response) do
      apply_filters(response)
    end

    @doc """
    Callback from ExVCR.Handler to get the response content tuple from the ExVCR.Reponse record.
    """
    def get_response_value_from_cache(response) do
      if response.type == "error" do
        {:error, response.body}
      else
        finch_response = %Finch.Response{
          status: response.status_code,
          headers: response.headers,
          body: response.body
        }

        {:ok, finch_response}
      end
    end

    defp apply_filters({:ok, %Finch.Response{} = response}) do
      filtered_response = apply_filters(response)
      {:ok, filtered_response}
    end

    defp apply_filters(%Finch.Response{} = response) do
      replaced_body = to_string(response.body) |> ExVCR.Filter.filter_sensitive_data
      filtered_headers = ExVCR.Filter.remove_blacklisted_headers(response.headers)
      response
      |> Map.put(:body, replaced_body)
      |> Map.put(:headers, filtered_headers)
    end

    defp apply_filters({:error, reason}), do: {:error, reason}

    defp handle_response_for_request!({:ok, resp}), do: resp
    defp handle_response_for_request!({:error, error}), do: raise error
    defp handle_response_for_request!(resp), do: resp

    @doc """
    Default definitions for stub.
    """
    def default_stub_params(:headers), do: %{"content-type" => "text/html"}
    def default_stub_params(:status_code), do: 200
  end

else
  defmodule ExVCR.Adapter.Finch do
    def module_name, do: raise "Missing dependency: Finch"
    def target_methods, do: raise "Missing dependency: Finch"
  end
end

1	if Code.ensure_loaded?(Finch) do
2	defmodule ExVCR.Adapter.Finch do
3	@moduledoc """
4	Provides adapter methods to mock Finch methods.
5	"""
6
7	use ExVCR.Adapter
8
9	alias ExVCR.Util
10
11	defmacro __using__(_opts) do
12	# do nothing
13	end
14
15	defdelegate convert_from_string(string), to: ExVCR.Adapter.Finch.Converter	22✔
16	defdelegate convert_to_string(request, response), to: ExVCR.Adapter.Finch.Converter	10✔
17	defdelegate parse_request_body(request_body), to: ExVCR.Adapter.Finch.Converter	×
18
19	@doc """
20	Returns the name of the mock target module.
21	"""
22	def module_name do
23	Finch
24	end
25
26	@doc """
27	Returns list of the mock target methods with function name and callback.
28	Implementation for global mock.
29	"""
30	def target_methods() do
31	[
32	{:request, &ExVCR.Recorder.request([&1,&2])},	27✔
33	{:request, &ExVCR.Recorder.request([&1,&2,&3])},	4✔
34	{:request!, &(ExVCR.Recorder.request([&1,&2]) \|> handle_response_for_request!())},	4✔
35	{:request!, &(ExVCR.Recorder.request([&1,&2,&3]) \|> handle_response_for_request!())}	×
36	]
37	end
38
39	@doc """
40	Returns list of the mock target methods with function name and callback.
41	"""
42	def target_methods(recorder) do
43	[
44	{:request, &ExVCR.Recorder.request(recorder, [&1,&2])},	×
45	{:request, &ExVCR.Recorder.request(recorder, [&1,&2,&3])},	×
46	{:request!, &(ExVCR.Recorder.request(recorder, [&1,&2]) \|> handle_response_for_request!())},	×
47	{:request!, &(ExVCR.Recorder.request(recorder, [&1,&2,&3]) \|> handle_response_for_request!())}	×
48	]
49	end
50
51	@doc """
52	Generate key for searching response.
53	"""
54	def generate_keys_for_request(request) do
55	req = Enum.fetch!(request, 0)	33✔
56	url = Util.build_url(req.scheme, req.host, req.path, req.port, req.query)	33✔
57
58	[url: url, method: String.downcase(req.method), request_body: req.body, headers: req.headers]	33✔
59	end
60
61	@doc """
62	Callback from ExVCR.Handler when response is retrieved from the HTTP server.
63	"""
64	def hook_response_from_server(response) do
65	apply_filters(response)	11✔
66	end
67
68	@doc """
69	Callback from ExVCR.Handler to get the response content tuple from the ExVCR.Reponse record.
70	"""
71	def get_response_value_from_cache(response) do
72	if response.type == "error" do	21✔
73	{:error, response.body}	7✔
74	else
75	finch_response = %Finch.Response{	14✔
76	status: response.status_code,	14✔
77	headers: response.headers,	14✔
78	body: response.body	14✔
79	}
80
81	{:ok, finch_response}
82	end
83	end
84
85	defp apply_filters({:ok, %Finch.Response{} = response}) do
86	filtered_response = apply_filters(response)	10✔
87	{:ok, filtered_response}
88	end
89
90	defp apply_filters(%Finch.Response{} = response) do
91	replaced_body = to_string(response.body) \|> ExVCR.Filter.filter_sensitive_data	10✔
92	filtered_headers = ExVCR.Filter.remove_blacklisted_headers(response.headers)	10✔
93	response
94	\|> Map.put(:body, replaced_body)
95	\|> Map.put(:headers, filtered_headers)	10✔
96	end
97
98	defp apply_filters({:error, reason}), do: {:error, reason}
99
100	defp handle_response_for_request!({:ok, resp}), do: resp	2✔
101	defp handle_response_for_request!({:error, error}), do: raise error	1✔
102	defp handle_response_for_request!(resp), do: resp	×
103
104	@doc """
105	Default definitions for stub.
106	"""
107	def default_stub_params(:headers), do: %{"content-type" => "text/html"}	1✔
108	def default_stub_params(:status_code), do: 200
109	end
110
111	else
112	defmodule ExVCR.Adapter.Finch do
113	def module_name, do: raise "Missing dependency: Finch"
114	def target_methods, do: raise "Missing dependency: Finch"
115	end
116	end

parroty / exvcr / f6cc9bc0ae05f24b374e6c1fa9b52e9d0967e032-PR-202

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous