No OneTemporary
Actions

Size

29 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/config/config.exs b/config/config.exs
	index 6d90389..b1c965d 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,22 +1,22 @@
	# This file is responsible for configuring your application
	# and its dependencies with the aid of the Mix.Config module.
	use Mix.Config

	-config :tesla, adapter: :httpc
	+config :tesla, adapter: Tesla.Adapter.Httpc

	config :logger, :console,
	level: :debug,
	format: "$date $time [$level] $metadata$message\n"

	if Mix.env == :test do
	config :httparrot,
	http_port: 8888,
	ssl: false,
	unix_socket: false

	config :sasl,
	errlog_type: :error,
	sasl_error_logger: false

	- config :tesla, MockClient, adapter: :mock
	+ config :tesla, MockClient, adapter: Tesla.Mock
	end
	diff --git a/lib/tesla.ex b/lib/tesla.ex
	index 8a566c1..ab9aa37 100644
	--- a/lib/tesla.ex
	+++ b/lib/tesla.ex
	@@ -1,544 +1,515 @@
	defmodule Tesla.Error do
	defexception message: "", reason: nil
	end

	defmodule Tesla.Env do
	@type client :: Tesla.Client.t() \| (t, stack -> t)
	@type method :: :head \| :get \| :delete \| :trace \| :options \| :post \| :put \| :patch
	@type url :: binary
	@type param :: binary \| [{binary \| atom, param}]
	@type query :: [{binary \| atom, param}]
	@type headers :: %{binary => binary}
	#
	@type body :: any
	@type status :: integer
	@type opts :: [any]
	@type __module__ :: atom
	@type __client__ :: function

	@type stack :: [{atom, atom, any} \| {atom, atom} \| {:fn, (t -> t)} \| {:fn, (t, stack -> t)}]

	@type t :: %__MODULE__{
	method: method,
	query: query,
	url: url,
	headers: headers,
	body: body,
	status: status,
	opts: opts,
	__module__: __module__,
	__client__: __client__
	}

	defstruct method: nil,
	url: "",
	query: [],
	headers: %{},
	body: nil,
	status: nil,
	opts: [],
	__module__: nil,
	__client__: nil
	end

	defmodule Tesla.Client do
	@type t :: %__MODULE__{
	fun: (Tesla.Env.t(), Tesla.Env.stack() -> Tesla.Env.t()) \| nil,
	pre: Tesla.Env.stack(),
	post: Tesla.Env.stack()
	}
	defstruct fun: nil,
	pre: [],
	post: []
	end

	defmodule Tesla.Middleware do
	@callback call(env :: Tesla.Env.t(), next :: Tesla.Env.stack(), options :: any) :: Tesla.Env.t()
	end

	defmodule Tesla.Builder do
	@http_verbs ~w(head get delete trace options post put patch)a

	defmacro __using__(opts \\ []) do
	opts = Macro.prewalk(opts, &Macro.expand(&1, __CALLER__))
	docs = Keyword.get(opts, :docs, true)

	quote do
	Module.register_attribute(__MODULE__, :__middleware__, accumulate: true)
	Module.register_attribute(__MODULE__, :__adapter__, [])

	if unquote(docs) do
	@type option ::
	{:method, Tesla.Env.method()}
	\| {:url, Tesla.Env.url()}
	\| {:query, Tesla.Env.query()}
	\| {:headers, Tesla.Env.headers()}
	\| {:body, Tesla.Env.body()}
	\| {:opts, Tesla.Env.opts()}

	@doc """
	Perform a request using client function

	Options:
	- `:method` - the request method, one of [:head, :get, :delete, :trace, :options, :post, :put, :patch]
	- `:url` - either full url e.g. "http://example.com/some/path" or just "/some/path" if using `Tesla.Middleware.BaseUrl`
	- `:query` - a keyword list of query params, e.g. `[page: 1, per_page: 100]`
	- `:headers` - a keyworld list of headers, e.g. `[{"content-type", "text/plain"}]`
	- `:body` - depends on used middleware:
	- by default it can be a binary
	- if using e.g. JSON encoding middleware it can be a nested map
	- if adapter supports it it can be a Stream with any of the above
	- `:opts` - custom, per-request middleware or adapter options

	Examples:

	ExampleApi.request(method: :get, url: "/users/path")

	You can also use shortcut methods like:

	ExampleApi.get("/users/1")

	or

	myclient \|> ExampleApi.post("/users", %{name: "Jon"})
	"""
	@spec request(Tesla.Env.client(), [option]) :: Tesla.Env.t()
	else
	@doc false
	end

	def request(%Tesla.Client{} = client, options) do
	Tesla.perform_request(__MODULE__, client, options)
	end

	if unquote(docs) do
	@doc """
	Perform a request. See `request/2` for available options.
	"""
	@spec request([option]) :: Tesla.Env.t()
	else
	@doc false
	end

	def request(options) do
	Tesla.perform_request(__MODULE__, options)
	end

	unquote(generate_http_verbs(opts))

	import Tesla.Builder, only: [plug: 1, plug: 2, adapter: 1, adapter: 2]
	@before_compile Tesla.Builder
	end
	end

	@doc """
	Attach middleware to your API client

	```ex
	defmodule ExampleApi do
	use Tesla

	# plug middleware module with options
	plug Tesla.Middleware.BaseUrl, "http://api.example.com"
	plug Tesla.Middleware.JSON, engine: Poison

	# plug middleware function
	plug :handle_errors

	# middleware function gets two parameters: Tesla.Env and the rest of middleware call stack
	# and must return Tesla.Env
	def handle_errors(env, next) do
	env
	\|> modify_env_before_request
	\|> Tesla.run(next) # run the rest of stack
	\|> modify_env_after_request
	end
	end
	"""
	defmacro plug(middleware, opts \\ nil) do
	opts = Macro.escape(opts)
	- middleware = Tesla.alias(middleware)
	quote do: @__middleware__({unquote(middleware), unquote(opts)})
	end

	@doc """
	Choose adapter for your API client

	```ex
	defmodule ExampleApi do
	use Tesla

	# set adapter as module
	adapter Tesla.Adapter.Hackney

	# set adapter as function
	adapter :local_adapter

	# set adapter as anonymous function
	adapter fn env ->
	...
	env
	end


	# adapter function gets Tesla.Env as parameter and must return Tesla.Env
	def local_adapter(env) do
	...
	env
	end
	end
	"""
	defmacro adapter({:fn, _, _} = adapter) do
	adapter = Macro.escape(adapter)
	quote do: @__adapter__(unquote(adapter))
	end

	defmacro adapter(adapter, opts \\ nil) do
	- adapter = Tesla.alias(adapter)
	quote do: @__adapter__({unquote(adapter), unquote(opts)})
	end

	defp generate_http_verbs(opts) do
	only = Keyword.get(opts, :only, @http_verbs)
	except = Keyword.get(opts, :except, [])

	@http_verbs
	\|> Enum.filter(&(&1 in only && not &1 in except))
	\|> Enum.map(&generate_api(&1, Keyword.get(opts, :docs, true)))
	end

	defp generate_api(method, docs) when method in [:post, :put, :patch] do
	quote do
	if unquote(docs) do
	@doc """
	Perform a #{unquote(method \|> to_string \|> String.upcase())} request.
	See `request/1` or `request/2` for options definition.

	Example
	myclient \|> ExampleApi.#{unquote(method)}("/users", %{name: "Jon"}, query: [scope: "admin"])
	"""
	@spec unquote(method)(Tesla.Env.client(), Tesla.Env.url(), Tesla.Env.body(), [option]) ::
	Tesla.Env.t()
	else
	@doc false
	end

	def unquote(method)(%Tesla.Client{} = client, url, body, options) when is_list(options) do
	request(client, [method: unquote(method), url: url, body: body] ++ options)
	end

	# fallback to keep backward compatibility
	def unquote(method)(fun, url, body, options) when is_function(fun) and is_list(options) do
	unquote(method)(%Tesla.Client{fun: fun}, url, body, options)
	end

	if unquote(docs) do
	@doc """
	Perform a #{unquote(method \|> to_string \|> String.upcase())} request.
	See `request/1` or `request/2` for options definition.

	Example
	myclient \|> ExampleApi.#{unquote(method)}("/users", %{name: "Jon"})
	ExampleApi.#{unquote(method)}("/users", %{name: "Jon"}, query: [scope: "admin"])
	"""
	@spec unquote(method)(Tesla.Env.client(), Tesla.Env.url(), Tesla.Env.body()) ::
	Tesla.Env.t()
	else
	@doc false
	end

	def unquote(method)(%Tesla.Client{} = client, url, body) do
	request(client, method: unquote(method), url: url, body: body)
	end

	# fallback to keep backward compatibility
	def unquote(method)(fun, url, body) when is_function(fun) do
	unquote(method)(%Tesla.Client{fun: fun}, url, body)
	end

	if unquote(docs) do
	@spec unquote(method)(Tesla.Env.url(), Tesla.Env.body(), [option]) :: Tesla.Env.t()
	else
	@doc false
	end

	def unquote(method)(url, body, options) when is_list(options) do
	request([method: unquote(method), url: url, body: body] ++ options)
	end

	if unquote(docs) do
	@doc """
	Perform a #{unquote(method \|> to_string \|> String.upcase())} request.
	See `request/1` or `request/2` for options definition.

	Example
	ExampleApi.#{unquote(method)}("/users", %{name: "Jon"})
	"""
	@spec unquote(method)(Tesla.Env.url(), Tesla.Env.body()) :: Tesla.Env.t()
	else
	@doc false
	end

	def unquote(method)(url, body) do
	request(method: unquote(method), url: url, body: body)
	end
	end
	end

	defp generate_api(method, docs) when method in [:head, :get, :delete, :trace, :options] do
	quote do
	if unquote(docs) do
	@doc """
	Perform a #{unquote(method \|> to_string \|> String.upcase())} request.
	See `request/1` or `request/2` for options definition.

	Example
	myclient \|> ExampleApi.#{unquote(method)}("/users", query: [page: 1])
	"""
	@spec unquote(method)(Tesla.Env.client(), Tesla.Env.url(), [option]) :: Tesla.Env.t()
	else
	@doc false
	end

	def unquote(method)(%Tesla.Client{} = client, url, options) when is_list(options) do
	request(client, [method: unquote(method), url: url] ++ options)
	end

	# fallback to keep backward compatibility
	def unquote(method)(fun, url, options) when is_function(fun) and is_list(options) do
	unquote(method)(%Tesla.Client{fun: fun}, url, options)
	end

	if unquote(docs) do
	@doc """
	Perform a #{unquote(method \|> to_string \|> String.upcase())} request.
	See `request/1` or `request/2` for options definition.

	Example
	myclient \|> ExampleApi.#{unquote(method)}("/users")
	ExampleApi.#{unquote(method)}("/users", query: [page: 1])
	"""
	@spec unquote(method)(Tesla.Env.client(), Tesla.Env.url()) :: Tesla.Env.t()
	else
	@doc false
	end

	def unquote(method)(%Tesla.Client{} = client, url) do
	request(client, method: unquote(method), url: url)
	end

	# fallback to keep backward compatibility
	def unquote(method)(fun, url) when is_function(fun) do
	unquote(method)(%Tesla.Client{fun: fun}, url)
	end

	if unquote(docs) do
	@spec unquote(method)(Tesla.Env.url(), [option]) :: Tesla.Env.t()
	else
	@doc false
	end

	def unquote(method)(url, options) when is_list(options) do
	request([method: unquote(method), url: url] ++ options)
	end

	if unquote(docs) do
	@doc """
	Perform a #{unquote(method \|> to_string \|> String.upcase())} request.
	See `request/1` or `request/2` for options definition.

	Example
	ExampleApi.#{unquote(method)}("/users")
	"""
	@spec unquote(method)(Tesla.Env.url()) :: Tesla.Env.t()
	else
	@doc false
	end

	def unquote(method)(url) do
	request(method: unquote(method), url: url)
	end
	end
	end

	defmacro __before_compile__(env) do
	adapter = Module.get_attribute(env.module, :__adapter__)
	middleware = Module.get_attribute(env.module, :__middleware__) \|> Enum.reverse()

	quote do
	def __middleware__, do: unquote(middleware)
	def __adapter__, do: Tesla.adapter(__MODULE__, unquote(adapter))
	end
	end
	end

	defmodule Tesla do
	use Tesla.Builder

	@moduledoc """
	A HTTP toolkit for building API clients using middlewares

	Include Tesla module in your api client:

	```ex
	defmodule ExampleApi do
	use Tesla

	plug Tesla.Middleware.BaseUrl, "http://api.example.com"
	plug Tesla.Middleware.JSON
	end
	"""

	defmacro __using__(opts \\ []) do
	quote do
	use Tesla.Builder, unquote(opts)
	end
	end

	- @aliases [
	- httpc: Tesla.Adapter.Httpc,
	- hackney: Tesla.Adapter.Hackney,
	- ibrowse: Tesla.Adapter.Ibrowse,
	- mock: Tesla.Mock,
	- base_url: Tesla.Middleware.BaseUrl,
	- headers: Tesla.Middleware.Headers,
	- query: Tesla.Middleware.Query,
	- opts: Tesla.Middleware.Opts,
	- follow_redirects: Tesla.Middleware.FollowRedirects,
	- method_override: Tesla.Middleware.MethodOverride,
	- logger: Tesla.Middleware.Logger,
	- debug_logger: Tesla.Middleware.DebugLogger,
	- form_urlencoded: Tesla.Middleware.FormUrlencoded,
	- json: Tesla.Middleware.JSON,
	- compression: Tesla.Middleware.Compression,
	- decode_rels: Tesla.Middleware.DecodeRels,
	- basic_auth: Tesla.Middleware.BasicAuth,
	- digest_auth: Tesla.Middleware.DigestAuth,
	- timeout: Tesla.Middleware.Timeout,
	- retry: Tesla.Middleware.Retry,
	- fuse: Tesla.Middleware.Fuse,
	- tuples: Tesla.Middleware.Tuples
	- ]
	- def alias(key) when is_atom(key), do: Keyword.get(@aliases, key, key)
	- def alias(key), do: key
	-
	def perform_request(module, client \\ nil, options) do
	%{fun: fun, pre: pre, post: post} = client \|\| %Tesla.Client{}

	stack =
	pre ++
	prepare(module, List.wrap(fun) ++ module.__middleware__ ++ default_middleware()) ++
	post ++ prepare(module, [module.__adapter__])

	env = struct(Tesla.Env, options ++ [__module__: module, __client__: client])
	run(env, stack)
	end

	@spec prepare(atom, [any]) :: Tesla.Env.stack()
	def prepare(module, stack) do
	Enum.map(stack, fn
	{name, opts} -> prepare_module(module, name, opts)
	name when is_atom(name) -> prepare_module(module, name, nil)
	fun when is_function(fun) -> {:fn, fun}
	end)
	end

	defp prepare_module(module, name, opts) do
	case Atom.to_charlist(name) do
	~c"Elixir." ++ _ -> {name, :call, [opts]}
	_ -> {module, name}
	end
	end

	# empty stack case is useful for reusing/testing middlewares (just pass [] as next)
	def run(env, []), do: env

	# last item in stack is adapter - skip passing rest of stack
	def run(env, [{:fn, f}]), do: apply(f, [env])
	def run(env, [{m, f}]), do: apply(m, f, [env])
	def run(env, [{m, f, a}]), do: apply(m, f, [env \| a])

	# for all other elements pass (env, next, opts)
	def run(env, [{:fn, f} \| rest]), do: apply(f, [env, rest])
	def run(env, [{m, f} \| rest]), do: apply(m, f, [env, rest])
	def run(env, [{m, f, a} \| rest]), do: apply(m, f, [env, rest \| a])

	# useful helper fuctions
	def put_opt(env, key, value) do
	Map.update!(env, :opts, &Keyword.put(&1, key, value))
	end

	def adapter(module, custom) do
	module_adapter_from_config(module) \|\| custom \|\| default_adapter()
	end

	defp module_adapter_from_config(module) do
	- Application.get_env(:tesla, module, [])[:adapter] \|> Tesla.alias()
	+ Application.get_env(:tesla, module, [])[:adapter]
	end

	def default_adapter do
	- Application.get_env(:tesla, :adapter, :httpc) \|> Tesla.alias()
	+ Application.get_env(:tesla, :adapter, Tesla.Adapter.Httpc)
	end

	def run_default_adapter(env, opts \\ []) do
	apply(default_adapter(), :call, [env, opts])
	end

	def default_middleware do
	[{Tesla.Middleware.Normalize, nil}]
	end

	@doc """
	Dynamically build client from list of middlewares.

	```ex
	defmodule ExampleAPI do
	use Tesla

	def new(token) do
	Tesla.build_client([
	{Tesla.Middleware.Headers, %{"Authorization" => token}}
	])
	end
	end

	client = ExampleAPI.new(token: "abc")
	client \|> ExampleAPI.get("/me")
	```
	"""
	defmacro build_client(pre, post \\ []) do
	quote do
	%Tesla.Client{
	pre: Tesla.prepare(__MODULE__, unquote(pre)),
	post: Tesla.prepare(__MODULE__, unquote(post))
	}
	end
	end

	def build_adapter(fun) do
	%Tesla.Client{post: [{:fn, fn env, _next -> fun.(env) end}]}
	end

	def build_url(url, []), do: url

	def build_url(url, query) do
	join = if String.contains?(url, "?"), do: "&", else: "?"
	url <> join <> encode_query(query)
	end

	defp encode_query(query) do
	query
	\|> Enum.flat_map(&encode_pair/1)
	\|> URI.encode_query()
	end

	defp encode_pair({key, value}) when is_list(value) do
	if Keyword.keyword?(value) do
	Enum.flat_map(value, fn {k, v} -> encode_pair({"#{key}[#{k}]", v}) end)
	else
	Enum.map(value, fn e -> {"#{key}[]", e} end)
	end
	end

	defp encode_pair({key, value}), do: [{key, value}]
	end
	diff --git a/lib/tesla/mock.ex b/lib/tesla/mock.ex
	index e131a39..9d8c602 100644
	--- a/lib/tesla/mock.ex
	+++ b/lib/tesla/mock.ex
	@@ -1,174 +1,174 @@
	defmodule Tesla.Mock do
	@moduledoc """
	Mock adapter for better testing.

	### Setup

	```
	# config/test.exs
	- config :tesla, adapter: :mock
	+ config :tesla, adapter: Tesla.Mock

	# in case MyClient defines specific adapter with `adapter :specific`
	- config :tesla, MyClient, adapter: :mock
	+ config :tesla, MyClient, adapter: Tesla.Mock
	```

	### Example test
	```
	defmodule MyAppTest do
	use ExUnit.Case

	setup do
	Tesla.Mock.mock fn
	%{method: :get} ->
	%Tesla.Env{status: 200, body: "hello"}
	end

	:ok
	end

	test "list things" do
	assert %Tesla.Env{} = env = MyApp.get("...")
	assert env.status == 200
	assert env.body == "hello"
	end
	end
	```

	### Setting up mocks
	```
	# Match on method & url and return whole Tesla.Env
	Tesla.Mock.mock fn
	%{method: :get, url: "http://example.com/list"} ->
	%Tesla.Env{status: 200, body: "hello"}
	end

	# You can use any logic required
	Tesla.Mock.mock fn env ->
	case env.url do
	"http://example.com/list" ->
	%Tesla.Env{status: 200, body: "ok!"}
	_ ->
	%Tesla.Env{status: 404, body: "NotFound"}
	end

	# mock will also accept short version of response
	# in the form of {status, headers, body}
	Tesla.Mock.mock fn
	%{method: :post} -> {201, %{}, %{id: 42}}
	end
	```

	### Global mocks
	By default, mocks are bound to the current process,
	i.e. the process running a single test case.
	This design allows proper isolation between test cases
	and make testing in parallel (`async: true`) possible.

	While this style is recommended, there is one drawback:
	if Tesla client is called from different process
	it will not use the setup mock.

	To solve this issue it is possible to setup a global mock
	using `mock_global/1` function.

	```
	defmodule MyTest do
	use ExUnit.Case, async: false # must be false!

	setup_all do
	Tesla.Mock.mock_global fn
	env -> # ...
	end

	:ok
	end

	# ...
	end
	```

	WARNING: Using global mocks may affect tests with local mock
	(because of fallback to global mock in case local one is not found)
	"""

	defmodule Error do
	defexception env: nil, ex: nil, stacktrace: []

	def message(%__MODULE__{ex: nil}) do
	"""
	There is no mock set for process #{inspect(self())}.
	Use Tesla.Mock.mock/1 to mock HTTP requests.

	See https://github.com/teamon/tesla#testing
	"""
	end

	def message(%__MODULE__{env: env, ex: %FunctionClauseError{} = ex, stacktrace: stacktrace}) do
	"""
	Request not mocked

	The following request was not mocked:

	#{inspect(env, pretty: true)}

	#{Exception.format(:error, ex, stacktrace)}
	"""
	end
	end

	## PUBLIC API

	@doc """
	Setup mocks for current test.

	This mock will only be available to the current process.
	"""
	@spec mock((Tesla.Env.t() -> Tesla.Env.t() \| {integer, map, any})) :: no_return
	def mock(fun) when is_function(fun), do: pdict_set(fun)

	@doc """
	Setup global mocks.

	WARNING: This mock will be available to ALL processes.
	It might cause conflicts when running tests in parallel!
	"""
	@spec mock_global((Tesla.Env.t() -> Tesla.Env.t() \| {integer, map, any})) :: no_return
	def mock_global(fun) when is_function(fun), do: agent_set(fun)

	## ADAPTER IMPLEMENTATION

	def call(env, _opts) do
	case pdict_get() \|\| agent_get() do
	nil ->
	raise Tesla.Mock.Error, env: env

	fun ->
	case rescue_call(fun, env) do
	{status, headers, body} ->
	%{env \| status: status, headers: headers, body: body}

	%Tesla.Env{} = env ->
	env
	end
	end
	end

	defp pdict_set(fun), do: Process.put(__MODULE__, fun)
	defp pdict_get, do: Process.get(__MODULE__)

	defp agent_set(fun), do: {:ok, _pid} = Agent.start_link(fn -> fun end, name: __MODULE__)

	defp agent_get do
	case Process.whereis(__MODULE__) do
	nil -> nil
	pid -> Agent.get(pid, fn f -> f end)
	end
	end

	defp rescue_call(fun, env) do
	fun.(env)
	rescue
	ex in FunctionClauseError ->
	raise Tesla.Mock.Error, env: env, ex: ex, stacktrace: System.stacktrace()
	end
	end
	diff --git a/test/tesla_test.exs b/test/tesla_test.exs
	index fa5c73e..af91841 100644
	--- a/test/tesla_test.exs
	+++ b/test/tesla_test.exs
	@@ -1,284 +1,284 @@
	defmodule TeslaTest do
	use ExUnit.Case

	require Tesla

	@url "http://localhost:#{Application.get_env(:httparrot, :http_port)}"

	describe "use Tesla options" do
	defmodule OnlyGetClient do
	use Tesla, only: [:get]
	end

	defmodule ExceptDeleteClient do
	use Tesla.Builder, except: ~w(delete)a
	end

	@http_verbs ~w(head get delete trace options post put patch)a

	test "limit generated functions (only)" do
	functions = OnlyGetClient.__info__(:functions) \|> Keyword.keys() \|> Enum.uniq()
	assert :get in functions
	refute Enum.any?(@http_verbs -- [:get], &(&1 in functions))
	end

	test "limit generated functions (except)" do
	functions = ExceptDeleteClient.__info__(:functions) \|> Keyword.keys() \|> Enum.uniq()
	refute :delete in functions
	assert Enum.all?(@http_verbs -- [:delete], &(&1 in functions))
	end
	end

	describe "Docs" do
	# Code.get_docs/2 requires .beam file of given module to exist in file system
	# See test/support/docs.ex file for definitions of TeslaDocsTest.* modules

	test "generate docs by default" do
	docs = Code.get_docs(TeslaDocsTest.Default, :docs)
	assert {_, _, _, _, doc} = Enum.find(docs, &match?({{:get, 1}, _, :def, _, _}, &1))
	assert doc != false
	end

	test "do not generate docs for HTTP methods when docs: false" do
	docs = Code.get_docs(TeslaDocsTest.NoDocs, :docs)
	assert {_, _, _, _, false} = Enum.find(docs, &match?({{:get, 1}, _, :def, _, _}, &1))
	assert {_, _, _, _, doc} = Enum.find(docs, &match?({{:custom, 1}, _, :def, _, _}, &1))
	assert doc =~ ~r/something/
	end
	end

	describe "Adapters" do
	defmodule ModuleAdapter do
	def call(env, opts \\ []) do
	Map.put(env, :url, env.url <> "/module/" <> opts[:with])
	end
	end

	defmodule EmptyClient do
	use Tesla
	end

	defmodule ModuleAdapterClient do
	use Tesla

	adapter ModuleAdapter, with: "someopt"
	end

	defmodule LocalAdapterClient do
	use Tesla

	adapter :local_adapter

	def local_adapter(env) do
	Map.put(env, :url, env.url <> "/local")
	end
	end

	defmodule FunAdapterClient do
	use Tesla

	adapter fn env ->
	Map.put(env, :url, env.url <> "/anon")
	end
	end

	setup do
	# clean config
	Application.delete_env(:tesla, EmptyClient)
	Application.delete_env(:tesla, ModuleAdapterClient)
	:ok
	end

	test "defauilt adapter" do
	assert EmptyClient.__adapter__() == Tesla.default_adapter()
	end

	test "adapter as module" do
	assert ModuleAdapterClient.__adapter__() == {ModuleAdapter, [with: "someopt"]}
	end

	test "adapter as local function" do
	assert LocalAdapterClient.__adapter__() == {:local_adapter, nil}
	end

	test "adapter as anonymous function" do
	assert is_function(FunAdapterClient.__adapter__())
	end

	test "execute module adapter" do
	response = ModuleAdapterClient.request(url: "test")
	assert response.url == "test/module/someopt"
	end

	test "execute local function adapter" do
	response = LocalAdapterClient.request(url: "test")
	assert response.url == "test/local"
	end

	test "execute anonymous function adapter" do
	response = FunAdapterClient.request(url: "test")
	assert response.url == "test/anon"
	end

	test "use adapter override from config" do
	- Application.put_env(:tesla, EmptyClient, adapter: :mock)
	+ Application.put_env(:tesla, EmptyClient, adapter: Tesla.Mock)
	assert EmptyClient.__adapter__() == Tesla.Mock
	end

	test "prefer config over module setting" do
	- Application.put_env(:tesla, ModuleAdapterClient, adapter: :mock)
	+ Application.put_env(:tesla, ModuleAdapterClient, adapter: Tesla.Mock)
	assert ModuleAdapterClient.__adapter__() == Tesla.Mock
	end
	end

	describe "Middleware" do
	defmodule AppendOne do
	@behaviour Tesla.Middleware

	def call(env, next, _opts) do
	env
	\|> Map.put(:url, "#{env.url}/1")
	\|> Tesla.run(next)
	end
	end

	defmodule AppendWith do
	@behaviour Tesla.Middleware

	def call(env, next, opts) do
	env
	\|> Map.update!(:url, fn url -> url <> "/MB" <> opts[:with] end)
	\|> Tesla.run(next)
	\|> Map.update!(:url, fn url -> url <> "/MA" <> opts[:with] end)
	end
	end

	defmodule AppendClient do
	use Tesla

	plug AppendOne
	plug AppendWith, with: "1"
	plug AppendWith, with: "2"
	plug :local_middleware

	adapter fn env -> env end

	def local_middleware(env, next) do
	env
	\|> Map.update!(:url, fn url -> url <> "/LB" end)
	\|> Tesla.run(next)
	\|> Map.update!(:url, fn url -> url <> "/LA" end)
	end
	end

	test "middleware list" do
	assert AppendClient.__middleware__() == [
	{AppendOne, nil},
	{AppendWith, [with: "1"]},
	{AppendWith, [with: "2"]},
	{:local_middleware, nil}
	]
	end

	test "execute middleware top down" do
	response = AppendClient.get("one")
	assert response.url == "one/1/MB1/MB2/LB/LA/MA2/MA1"
	end
	end

	describe "Dynamic client" do
	defmodule DynamicClient do
	use Tesla

	adapter fn env ->
	if String.ends_with?(env.url, "/cached") do
	%{env \| body: "cached", status: 304}
	else
	Tesla.run_default_adapter(env)
	end
	end

	def help(client \\ %Tesla.Client{}) do
	get(client, "/help")
	end
	end

	test "override adapter - Tesla.build_client" do
	client =
	Tesla.build_client([], [
	fn env, _next ->
	%{env \| body: "new"}
	end
	])

	assert %{body: "new"} = DynamicClient.help(client)
	end

	test "override adapter - Tesla.build_adapter" do
	client =
	Tesla.build_adapter(fn env ->
	%{env \| body: "new"}
	end)

	assert %{body: "new"} = DynamicClient.help(client)
	end

	test "statically override adapter" do
	assert %{status: 200} = DynamicClient.get(@url <> "/ip")
	assert %{status: 304} = DynamicClient.get(@url <> "/cached")
	end
	end

	describe "request API" do
	defmodule SimpleClient do
	use Tesla

	adapter fn env ->
	env
	end
	end

	test "basic request" do
	response = SimpleClient.request(url: "/", method: :post, query: [page: 1], body: "data")
	assert response.method == :post
	assert response.url == "/"
	assert response.query == [page: 1]
	assert response.body == "data"
	end

	test "shortcut function" do
	response = SimpleClient.get("/get")
	assert response.method == :get
	assert response.url == "/get"
	end

	test "shortcut function with body" do
	response = SimpleClient.post("/post", "some-data")
	assert response.method == :post
	assert response.url == "/post"
	assert response.body == "some-data"
	end

	test "request with client" do
	client = fn env, next ->
	env
	\|> Map.put(:url, "/prefix" <> env.url)
	\|> Tesla.run(next)
	end

	response = SimpleClient.get("/")
	assert response.url == "/"
	refute response.__client__

	response = client \|> SimpleClient.get("/")
	assert response.url == "/prefix/"
	assert response.__client__ == %Tesla.Client{fun: client}
	end

	test "better errors when given nil opts" do
	assert_raise FunctionClauseError, fn ->
	Tesla.get("/", nil)
	end
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 24, 10:36 PM (1 d, 7 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 39496
Default Alt Text: (29 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions