No OneTemporary
Actions

Size

23 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/tesla.ex b/lib/tesla.ex
	index 017dc3c..cc76382 100644
	--- a/lib/tesla.ex
	+++ b/lib/tesla.ex
	@@ -1,226 +1,232 @@
	defmodule Tesla.Error do
	defexception message: "", reason: nil
	end

	defmodule Tesla.Env do
	@type client :: Tesla.Client.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 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__: atom,
	__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__{
	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) ::
	{:ok, Tesla.Env.t()} \| {:error, any}
	end

	defmodule Tesla.Adapter do
	@callback call(env :: Tesla.Env.t(), options :: any) :: {:ok, Tesla.Env.t()} \| {:error, any}
	+
	+ def opts(defaults \\ [], env, opts) do
	+ defaults
	+ \|> Keyword.merge(opts \|\| [])
	+ \|> Keyword.merge(env.opts[:adapter] \|\| [])
	+ end
	end

	defmodule Tesla do
	use Tesla.Builder

	alias Tesla.Env

	require Tesla.Adapter.Httpc
	@default_adapter Tesla.Adapter.Httpc

	@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

	@doc false
	def execute(module, %{pre: pre, post: post} = client, options) do
	env = struct(Env, options ++ [__module__: module, __client__: client])
	stack = pre ++ module.__middleware__ ++ post ++ [effective_adapter(module)]
	run(env, stack)
	end

	@doc false
	def effective_adapter(module) do
	with nil <- adapter_per_module_from_config(module),
	nil <- adapter_per_module(module),
	nil <- adapter_from_config() do
	adapter_default()
	end
	end

	defp adapter_per_module_from_config(module) do
	case Application.get_env(:tesla, module, [])[:adapter] do
	nil -> nil
	{adapter, opts} -> {adapter, :call, [opts]}
	adapter -> {adapter, :call, [[]]}
	end
	end

	defp adapter_per_module(module) do
	module.__adapter__
	end

	defp adapter_from_config do
	case Application.get_env(:tesla, :adapter) do
	nil -> nil
	{adapter, opts} -> {adapter, :call, [opts]}
	adapter -> {adapter, :call, [[]]}
	end
	end

	defp adapter_default do
	{@default_adapter, :call, [[]]}
	end

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

	# empty stack case is useful for reusing/testing middlewares (just pass [] as next)
	def run(env, []), do: {:ok, 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, 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, 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

	@spec get_header(Env.t(), binary) :: binary \| nil
	def get_header(%Env{headers: headers}, key) do
	case List.keyfind(headers, key, 0) do
	{_, value} -> value
	_ -> nil
	end
	end

	@spec get_headers(Env.t(), binary) :: [binary]
	def get_headers(%Env{headers: headers}, key) do
	for {k, v} <- headers, k == key, do: v
	end

	@spec put_header(Env.t(), binary, binary) :: Env.t()
	def put_header(%Env{} = env, key, value) do
	headers = List.keystore(env.headers, key, 0, {key, value})
	%{env \| headers: headers}
	end

	@spec put_headers(Env.t(), [{binary, binary}]) :: Env.t()
	def put_headers(%Env{} = env, list) when is_list(list) do
	%{env \| headers: env.headers ++ list}
	end

	@spec delete_header(Env.t(), binary) :: Env.t()
	def delete_header(%Env{} = env, key) do
	headers = for {k, v} <- env.headers, k != key, do: {k, v}
	%{env \| headers: headers}
	end

	@spec put_body(Env.t(), Env.body()) :: Env.t()
	def put_body(%Env{} = env, body), do: %{env \| body: body}

	@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")
	```
	"""
	def build_client(pre, post \\ []), do: Tesla.Builder.client(pre, post)

	def build_adapter(fun), do: Tesla.Builder.client([], [fn env, _next -> fun.(env) 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/adapter/hackney.ex b/lib/tesla/adapter/hackney.ex
	index d4addc8..de1e117 100644
	--- a/lib/tesla/adapter/hackney.ex
	+++ b/lib/tesla/adapter/hackney.ex
	@@ -1,92 +1,92 @@
	if Code.ensure_loaded?(:hackney) do
	defmodule Tesla.Adapter.Hackney do
	@moduledoc """
	Adapter for [hackney](https://github.com/benoitc/hackney)

	Remember to add `{:hackney, "~> 1.6"}` to dependencies (and `:hackney` to applications in `mix.exs`)
	Also, you need to recompile tesla after adding `:hackney` dependency:

	```
	mix deps.clean tesla
	mix deps.compile tesla
	```

	### Example usage
	```
	# set globally in config/config.exs
	config :tesla, :adapter, :hackney

	# set per module
	defmodule MyClient do
	use Tesla

	adapter :hackney
	end
	```
	"""
	@behaviour Tesla.Adapter
	alias Tesla.Multipart

	def call(env, opts) do
	- with {:ok, status, headers, body} <- request(env, opts \|\| []) do
	+ with {:ok, status, headers, body} <- request(env, opts) do
	{:ok, %{env \| status: status, headers: format_headers(headers), body: format_body(body)}}
	end
	end

	defp format_headers(headers) do
	for {key, value} <- headers do
	{String.downcase(to_string(key)), to_string(value)}
	end
	end

	defp format_body(data) when is_list(data), do: IO.iodata_to_binary(data)
	defp format_body(data) when is_binary(data), do: data

	defp request(env, opts) do
	request(
	env.method,
	Tesla.build_url(env.url, env.query),
	env.headers,
	env.body,
	- opts ++ env.opts
	+ Tesla.Adapter.opts(env, opts)
	)
	end

	defp request(method, url, headers, %Stream{} = body, opts),
	do: request_stream(method, url, headers, body, opts)

	defp request(method, url, headers, body, opts) when is_function(body),
	do: request_stream(method, url, headers, body, opts)

	defp request(method, url, headers, %Multipart{} = mp, opts) do
	headers = headers ++ Multipart.headers(mp)
	body = Multipart.body(mp)

	request(method, url, headers, body, opts)
	end

	defp request(method, url, headers, body, opts) do
	handle(:hackney.request(method, url, headers, body \|\| '', opts))
	end

	defp request_stream(method, url, headers, body, opts) do
	with {:ok, ref} <- :hackney.request(method, url, headers, :stream, opts) do
	for data <- body, do: :ok = :hackney.send_body(ref, data)
	handle(:hackney.start_response(ref))
	else
	e -> handle(e)
	end
	end

	defp handle({:error, _} = error), do: error
	defp handle({:ok, status, headers}), do: {:ok, status, headers, []}

	defp handle({:ok, status, headers, ref}) when is_reference(ref) do
	with {:ok, body} <- :hackney.body(ref) do
	{:ok, status, headers, body}
	end
	end

	defp handle({:ok, status, headers, body}), do: {:ok, status, headers, body}
	end
	end
	diff --git a/lib/tesla/adapter/httpc.ex b/lib/tesla/adapter/httpc.ex
	index 8fa9f2f..d910af0 100644
	--- a/lib/tesla/adapter/httpc.ex
	+++ b/lib/tesla/adapter/httpc.ex
	@@ -1,94 +1,94 @@
	defmodule Tesla.Adapter.Httpc do
	@moduledoc """
	Adapter for [httpc](http://erlang.org/doc/man/httpc.html)

	This is the default adapter.

	NOTE Tesla overrides default autoredirect value with false to ensure
	consistency between adapters
	"""

	@behaviour Tesla.Adapter
	import Tesla.Adapter.Shared, only: [stream_to_fun: 1, next_chunk: 1]
	alias Tesla.Multipart

	@override_defaults autoredirect: false
	@http_opts ~w(timeout connect_timeout ssl essl autoredirect proxy_auth version relaxed url_encode)a

	def call(env, opts) do
	- opts = Keyword.merge(@override_defaults, opts \|\| [])
	+ opts = Tesla.Adapter.opts(@override_defaults, env, opts)

	with {:ok, {status, headers, body}} <- request(env, opts) do
	{:ok, format_response(env, status, headers, body)}
	end
	end

	defp format_response(env, {_, status, _}, headers, body) do
	%{env \| status: status, headers: format_headers(headers), body: format_body(body)}
	end

	# from http://erlang.org/doc/man/httpc.html
	# headers() = [header()]
	# header() = {field(), value()}
	# field() = string()
	# value() = string()
	defp format_headers(headers) do
	for {key, value} <- headers do
	{String.downcase(to_string(key)), to_string(value)}
	end
	end

	# from http://erlang.org/doc/man/httpc.html
	# string() = list of ASCII characters
	# Body = string() \| binary()
	defp format_body(data) when is_list(data), do: IO.iodata_to_binary(data)
	defp format_body(data) when is_binary(data), do: data

	defp request(env, opts) do
	content_type = to_charlist(Tesla.get_header(env, "content-type") \|\| "")

	handle(
	request(
	env.method,
	Tesla.build_url(env.url, env.query) \|> to_charlist,
	Enum.map(env.headers, fn {k, v} -> {to_charlist(k), to_charlist(v)} end),
	content_type,
	env.body,
	- Keyword.split(opts ++ env.opts, @http_opts)
	+ Keyword.split(opts, @http_opts)
	)
	)
	end

	defp request(method, url, headers, _content_type, nil, {http_opts, opts}) do
	:httpc.request(method, {url, headers}, http_opts, opts)
	end

	defp request(method, url, headers, _content_type, %Multipart{} = mp, opts) do
	headers = headers ++ Multipart.headers(mp)
	headers = for {key, value} <- headers, do: {to_charlist(key), to_charlist(value)}
	{content_type, headers} = case List.keytake(headers, 'content-type', 0) do
	nil -> {'text/plain', headers}
	{{_, ct}, headers} -> {ct, headers}
	end
	body = stream_to_fun(Multipart.body(mp))

	request(method, url, headers, to_charlist(content_type), body, opts)
	end

	defp request(method, url, headers, content_type, %Stream{} = body, opts) do
	fun = stream_to_fun(body)
	request(method, url, headers, content_type, fun, opts)
	end

	defp request(method, url, headers, content_type, body, opts) when is_function(body) do
	body = {:chunkify, &next_chunk/1, body}
	request(method, url, headers, content_type, body, opts)
	end

	defp request(method, url, headers, content_type, body, {http_opts, opts}) do
	:httpc.request(method, {url, headers, content_type, body}, http_opts, opts)
	end

	defp handle({:error, {:failed_connect, _}}), do: {:error, :econnrefused}
	defp handle(response), do: response
	end
	diff --git a/lib/tesla/adapter/ibrowse.ex b/lib/tesla/adapter/ibrowse.ex
	index 4166831..761da89 100644
	--- a/lib/tesla/adapter/ibrowse.ex
	+++ b/lib/tesla/adapter/ibrowse.ex
	@@ -1,96 +1,96 @@
	if Code.ensure_loaded?(:ibrowse) do
	defmodule Tesla.Adapter.Ibrowse do
	@moduledoc """
	Adapter for [ibrowse](https://github.com/cmullaparthi/ibrowse)

	Remember to add `{:ibrowse, "~> 4.2"}` to dependencies (and `:ibrowse` to applications in `mix.exs`)
	Also, you need to recompile tesla after adding `:ibrowse` dependency:

	```
	mix deps.clean tesla
	mix deps.compile tesla
	```

	### Example usage
	```
	# set globally in config/config.exs
	config :tesla, :adapter, :ibrowse

	# set per module
	defmodule MyClient do
	use Tesla

	adapter :ibrowse
	end
	```
	"""

	@behaviour Tesla.Adapter
	import Tesla.Adapter.Shared, only: [stream_to_fun: 1, next_chunk: 1]
	alias Tesla.Multipart

	def call(env, opts) do
	- with {:ok, status, headers, body} <- request(env, opts \|\| []) do
	+ with {:ok, status, headers, body} <- request(env, opts) do
	{:ok,
	%{
	env
	\| status: format_status(status),
	headers: format_headers(headers),
	body: format_body(body)
	}}
	end
	end

	defp format_status(status) when is_list(status) do
	status \|> to_string() \|> String.to_integer()
	end

	defp format_headers(headers) do
	for {key, value} <- headers do
	{String.downcase(to_string(key)), to_string(value)}
	end
	end

	defp format_body(data) when is_list(data), do: IO.iodata_to_binary(data)
	defp format_body(data) when is_binary(data), do: data

	defp request(env, opts) do
	body = env.body \|\| []

	handle(
	request(
	Tesla.build_url(env.url, env.query) \|> to_charlist,
	env.headers,
	env.method,
	body,
	- opts ++ env.opts
	+ Tesla.Adapter.opts(env, opts)
	)
	)
	end

	defp request(url, headers, method, %Multipart{} = mp, opts) do
	headers = headers ++ Multipart.headers(mp)
	body = stream_to_fun(Multipart.body(mp))

	request(url, headers, method, body, opts)
	end

	defp request(url, headers, method, %Stream{} = body, opts) do
	fun = stream_to_fun(body)
	request(url, headers, method, fun, opts)
	end

	defp request(url, headers, method, body, opts) when is_function(body) do
	body = {&next_chunk/1, body}
	opts = Keyword.put(opts, :transfer_encoding, :chunked)
	request(url, headers, method, body, opts)
	end

	defp request(url, headers, method, body, opts) do
	:ibrowse.send_req(url, headers, method, body, opts)
	end

	defp handle({:error, {:conn_failed, error}}), do: error
	defp handle(response), do: response
	end
	end
	diff --git a/test/tesla_test.exs b/test/tesla_test.exs
	index 3f1285a..862c9ad 100644
	--- a/test/tesla_test.exs
	+++ b/test/tesla_test.exs
	@@ -1,267 +1,292 @@
	defmodule TeslaTest do
	use ExUnit.Case

	require Tesla

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

	describe "Adapters" do
	defmodule ModuleAdapter do
	- def call(env, opts \\ []) do
	+ def call(env, opts) do
	{:ok, 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 FunAdapterClient do
	use Tesla

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

	+ defmodule OptsAdapter do
	+ def call(env, opts) do
	+ {:ok, %{env \| body: Tesla.Adapter.opts(env, opts)}}
	+ end
	+ end
	+
	+ defmodule OptsClient do
	+ use Tesla
	+ adapter OptsAdapter, static: :always
	+ end
	+
	setup do
	# clean config
	Application.delete_env(:tesla, EmptyClient)
	Application.delete_env(:tesla, ModuleAdapterClient)
	:ok
	end

	test "defauilt adapter" do
	assert Tesla.effective_adapter(EmptyClient) == {Tesla.Adapter.Httpc, :call, [[]]}
	end

	test "use adapter override from config" do
	Application.put_env(:tesla, EmptyClient, adapter: Tesla.Mock)
	assert Tesla.effective_adapter(EmptyClient) == {Tesla.Mock, :call, [[]]}
	end

	test "prefer config over module setting" do
	Application.put_env(:tesla, ModuleAdapterClient, adapter: Tesla.Mock)
	assert Tesla.effective_adapter(ModuleAdapterClient) == {Tesla.Mock, :call, [[]]}
	end

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

	test "execute anonymous function adapter" do
	assert {:ok, response} = FunAdapterClient.request(url: "test")
	assert response.url == "test/anon"
	end
	+
	+ test "pass only :adapter opts to adapter" do
	+ assert {:ok, env} = OptsClient.get("/")
	+ assert env.body == [static: :always]
	+
	+ assert {:ok, env} = OptsClient.get("/", opts: [ignore: :me])
	+ assert env.body == [static: :always]
	+
	+ assert {:ok, env} = OptsClient.get("/", opts: [adapter: [include: :me]])
	+ assert env.body == [static: :always, include: :me]
	+
	+ assert {:ok, env} = OptsClient.get("/", opts: [adapter: [static: :override]])
	+ assert env.body == [static: :override]
	+ 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)
	\|> case do
	{:ok, env} ->
	{:ok, Map.update!(env, :url, fn url -> url <> "/MA" <> opts[:with] end)}

	error ->
	error
	end
	end
	end

	defmodule AppendClient do
	use Tesla

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

	adapter fn env -> {:ok, env} end
	end

	test "execute middleware top down" do
	assert {:ok, response} = AppendClient.get("one")
	assert response.url == "one/1/MB1/MB2/MA2/MA1"
	end
	end

	describe "Dynamic client" do
	defmodule DynamicClient do
	use Tesla

	adapter fn env ->
	if String.ends_with?(env.url, "/cached") do
	{:ok, %{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 ->
	{:ok, %{env \| body: "new"}}
	end
	])

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

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

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

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

	describe "request API" do
	defmodule SimpleClient do
	use Tesla

	adapter fn env ->
	{:ok, env}
	end
	end

	test "basic request" do
	assert {:ok, 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
	assert {:ok, response} = SimpleClient.get("/get")
	assert response.method == :get
	assert response.url == "/get"
	end

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

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

	alias Tesla.Env
	import Tesla

	describe "get_header/2" do
	test "non existing header" do
	env = %Env{headers: [{"server", "Cowboy"}]}
	assert get_header(env, "some-key") == nil
	end

	test "existing header" do
	env = %Env{headers: [{"server", "Cowboy"}]}
	assert get_header(env, "server") == "Cowboy"
	end

	test "first of multiple headers with the same name" do
	env = %Env{headers: [{"cookie", "chocolate"}, {"cookie", "biscuits"}]}
	assert get_header(env, "cookie") == "chocolate"
	end
	end

	describe "get_headers/2" do
	test "none matching" do
	env = %Env{headers: [{"server", "Cowboy"}]}
	assert get_headers(env, "cookie") == []
	end

	test "multiple matches matching" do
	env = %Env{headers: [{"cookie", "chocolate"}, {"cookie", "biscuits"}]}
	assert get_headers(env, "cookie") == ["chocolate", "biscuits"]
	end
	end

	describe "put_header/3" do
	test "add new header" do
	env = %Env{}
	env = put_header(env, "server", "Cowboy")
	assert get_header(env, "server") == "Cowboy"
	end

	test "override existing header" do
	env = %Env{headers: [{"server", "Cowboy"}]}
	env = put_header(env, "server", "nginx")
	assert get_header(env, "server") == "nginx"
	end
	end

	describe "put_headers/2" do
	test "add headers to env existing header" do
	env = %Env{}
	assert get_header(env, "server") == nil

	env = Tesla.put_headers(env, [{"server", "Cowboy"}, {"content-length", "100"}])
	assert get_header(env, "server") == "Cowboy"
	assert get_header(env, "content-length") == "100"

	env = Tesla.put_headers(env, [{"server", "nginx"}, {"content-type", "text/plain"}])
	assert get_header(env, "server") == "Cowboy"
	assert get_header(env, "content-length") == "100"
	assert get_header(env, "content-type") == "text/plain"
	end

	test "add multiple headers with the same name" do
	env = %Env{}
	env = Tesla.put_headers(env, [{"cookie", "chocolate"}, {"cookie", "biscuits"}])
	assert get_headers(env, "cookie") == ["chocolate", "biscuits"]
	end
	end

	describe "delete_header/2" do
	test "delete all headers with given name" do
	env = %Env{headers: [{"cookie", "chocolate"}, {"server", "Cowboy"}, {"cookie", "biscuits"}]}
	env = delete_header(env, "cookie")
	assert get_header(env, "cookie") == nil
	assert get_header(env, "server") == "Cowboy"
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Mon, Nov 25, 6:31 AM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 39687
Default Alt Text: (23 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions