Convert ex_unit context to a map

Author: José Valim

lib/ex_unit/lib/ex_unit/callbacks.ex

@@ -5,15 +5,15 @@ defmodule ExUnit.Callbacks do
   This module defines four callbacks: `setup_all`, `teardown_all`,
   `setup` and `teardown`.
 
-  These callbacks are defined via macros and each one can optionally receive a
-  keyword list with metadata, usually referred to as `context`. The callback
+  These callbacks are defined via macros and each one can optionally receive
+  a map with metadata, usually referred to as `context`. The callback
   may optionally put extra data into `context` to be used in the tests.
 
-  If you return `{:ok, <keyword list>}` from `setup` or `teardown`, the keyword
+  If you return `{:ok, <dict>}` from `setup` or `teardown`, the keyword
   list will be merged into the context that will be available in all
   subsequent `setup`, `test` or `teardown` calls.
 
-  Similarly, returning `{:ok, <keyword list>}` from `setup_all` or
+  Similarly, returning `{:ok, <dict>}` from `setup_all` or
   `teardown_all` will merge the keyword list into the context that will be
   available in all subsequent `setup_all` or `teardown_all` calls.
 
@@ -41,8 +41,8 @@ defmodule ExUnit.Callbacks do
         setup do
           IO.puts "This is a setup callback"
 
-          # Return extra metadata, it must be a keyword list
-          {:ok, [hello: "world"]}
+          # Return extra metadata, it must be a keyword list / map
+          {:ok, hello: "world"}
         end
 
         # Same as `setup`, but receives the context for the current test
@@ -89,10 +89,10 @@ defmodule ExUnit.Callbacks do
 
   @doc false
   defmacro __before_compile__(env) do
-    [ compile_callbacks(env, :setup),
-      compile_callbacks(env, :teardown),
-      compile_callbacks(env, :setup_all),
-      compile_callbacks(env, :teardown_all) ]
+    [compile_callbacks(env, :setup),
+     compile_callbacks(env, :teardown),
+     compile_callbacks(env, :setup_all),
+     compile_callbacks(env, :teardown_all)]
   end
 
   @doc """
@@ -150,13 +150,13 @@ defmodule ExUnit.Callbacks do
     {:ok, other}
   end
 
-  def __merge__(_mod, other, {:ok, data}) when is_list(data) do
-    {:ok, Keyword.merge(other, data)}
+  def __merge__(_mod, other, {:ok, data}) do
+    {:ok, Dict.merge(other, data)}
   end
 
   def __merge__(mod, _, failure) do
     raise "expected ExUnit callback in #{inspect mod} to return :ok " <>
-          " or {:ok, keywords}, got #{inspect failure} instead"
+          " or {:ok, dict}, got #{inspect failure} instead"
   end
 
   defp escape(contents) do

lib/ex_unit/lib/ex_unit/case.ex

@@ -46,6 +46,14 @@ defmodule ExUnit.Case do
         end
       end
 
+  As the context is a map, it can be pattern matched on to extract
+  information:
+
+      test "stores key-values", %{pid: pid} do
+        assert KV.put(pid, :hello, :world) == :ok
+        assert KV.get(pid, :hello) == :world
+      end
+
   ## Tags
 
   The context is used to pass information from the callbacks to
@@ -234,7 +242,7 @@ defmodule ExUnit.Case do
   def __on_definition__(env, name) do
     mod  = env.module
     tags = Module.get_attribute(mod, :tag) ++ Module.get_attribute(mod, :moduletag)
-    tags = [line: env.line, file: env.file] ++ normalize_tags(tags)
+    tags = tags |> normalize_tags |> Map.merge(%{line: env.line, file: env.file})
 
     Module.put_attribute(mod, :ex_unit_tests,
       %ExUnit.Test{name: name, case: mod, tags: tags})
@@ -243,9 +251,9 @@ defmodule ExUnit.Case do
   end
 
   defp normalize_tags(tags) do
-    Enum.reduce tags, [], fn
-      tag, acc when is_atom(tag) -> Keyword.put_new(acc, tag, true)
-      tag, acc when is_list(tag) -> Keyword.merge(tag, acc)
+    Enum.reduce Enum.reverse(tags), %{}, fn
+      tag, acc when is_atom(tag) -> Map.put(acc, tag, true)
+      tag, acc when is_list(tag) -> Dict.merge(acc, tag)
     end
   end
 end

lib/ex_unit/lib/ex_unit/filters.ex

@@ -69,15 +69,15 @@ defmodule ExUnit.Filters do
 
   ## Examples
 
-      iex> ExUnit.Filters.eval([foo: "bar"], [:foo], [foo: "bar"])
+      iex> ExUnit.Filters.eval([foo: "bar"], [:foo], %{foo: "bar"})
       :ok
 
-      iex> ExUnit.Filters.eval([foo: "bar"], [:foo], [foo: "baz"])
+      iex> ExUnit.Filters.eval([foo: "bar"], [:foo], %{foo: "baz"})
       {:error, :foo}
 
   """
-  @spec eval(t, t, Keyword.t) :: :ok | {:error, atom}
-  def eval(include, exclude, tags) do
+  @spec eval(t, t, map) :: :ok | {:error, atom}
+  def eval(include, exclude, tags) when is_map(tags) do
     excluded = Enum.find_value exclude, &has_tag(&1, tags)
     if !excluded or Enum.any?(include, &has_tag(&1, tags)) do
       :ok
@@ -87,22 +87,22 @@ defmodule ExUnit.Filters do
   end
 
   defp has_tag({key, %Regex{} = value}, tags) when is_atom(key) do
-    case Keyword.fetch(tags, key) do
+    case Map.fetch(tags, key) do
       {:ok, tag} -> to_string(tag) =~ value and key
       _ -> false
     end
   end
 
   defp has_tag({key, value}, tags) when is_atom(key) do
-    case Keyword.fetch(tags, key) do
+    case Map.fetch(tags, key) do
       {:ok, ^value} -> key
       {:ok, tag} -> compare(to_string(tag), to_string(value)) and key
       _ -> false
     end
   end
 
   defp has_tag(key, tags) when is_atom(key),
-    do: Keyword.has_key?(tags, key) and key
+    do: Map.has_key?(tags, key) and key
 
   defp compare("Elixir." <> tag, tag), do: true
   defp compare(tag, tag), do: true

lib/ex_unit/lib/ex_unit/runner.ex

@@ -129,7 +129,7 @@ defmodule ExUnit.Runner do
     exclude = config.exclude
 
     for test <- tests do
-      tags = Keyword.put(test.tags, :test, test.name)
+      tags = Map.put(test.tags, :test, test.name)
       case ExUnit.Filters.eval(include, exclude, tags) do
         :ok           -> %{test | tags: tags}
         {:error, tag} -> %{test | state: {:skip, "due to #{tag} filter"}}
@@ -163,7 +163,7 @@ defmodule ExUnit.Runner do
   end
 
   defp exec_case_setup(%ExUnit.TestCase{name: case_name} = test_case) do
-    {:ok, context} = case_name.__ex_unit__(:setup_all, [case: case_name])
+    {:ok, context} = case_name.__ex_unit__(:setup_all, %{case: case_name})
     {:ok, {test_case, context}}
   catch
     kind, error ->
@@ -184,7 +184,7 @@ defmodule ExUnit.Runner do
     EM.test_started(config.manager, test)
 
     if nil?(test.state) do
-      test = spawn_test(config, test, Keyword.merge(test.tags, context))
+      test = spawn_test(config, test, Map.merge(test.tags, context))
     end
 
     EM.test_finished(config.manager, test)

lib/ex_unit/test/ex_unit/case_template_test.exs

@@ -55,8 +55,8 @@ defmodule ExUnit.CaseTemplateTest do
     assert 2 == unquote(two)
   end
 
-  test "receives context from parent case", context do
-    assert context[:context] == :setup
+  test "receives context from parent case", %{context: context} do
+    assert context == :setup
   end
 
   test "runs both templates setup", context do

lib/ex_unit/test/ex_unit/filters_test.exs

@@ -6,35 +6,35 @@ defmodule ExUnit.FiltersTest do
   doctest ExUnit.Filters
 
   test "evaluating filters" do
-    assert ExUnit.Filters.eval([], [:os], [])                == :ok
-    assert ExUnit.Filters.eval([], [os: :win], [os: :unix])  == :ok
-    assert ExUnit.Filters.eval([], [:os], [os: :unix])       == {:error, :os}
-    assert ExUnit.Filters.eval([], [os: :unix], [os: :unix]) == {:error, :os}
+    assert ExUnit.Filters.eval([], [:os], %{})                == :ok
+    assert ExUnit.Filters.eval([], [os: :win], %{os: :unix})  == :ok
+    assert ExUnit.Filters.eval([], [:os], %{os: :unix})       == {:error, :os}
+    assert ExUnit.Filters.eval([], [os: :unix], %{os: :unix}) == {:error, :os}
 
-    assert ExUnit.Filters.eval([os: :win], [], [])            == :ok
-    assert ExUnit.Filters.eval([os: :win], [], [os: :unix])   == :ok
-    assert ExUnit.Filters.eval([os: :win], [:os], [])         == :ok
-    assert ExUnit.Filters.eval([os: :win], [:os], [os: :win]) == :ok
+    assert ExUnit.Filters.eval([os: :win], [], %{})            == :ok
+    assert ExUnit.Filters.eval([os: :win], [], %{os: :unix})   == :ok
+    assert ExUnit.Filters.eval([os: :win], [:os], %{})         == :ok
+    assert ExUnit.Filters.eval([os: :win], [:os], %{os: :win}) == :ok
 
-    assert ExUnit.Filters.eval([os: :win, os: :unix], [:os], [os: :win]) == :ok
+    assert ExUnit.Filters.eval([os: :win, os: :unix], [:os], %{os: :win}) == :ok
   end
 
   test "evaluating filters matches integers" do
-    assert ExUnit.Filters.eval([line: "1"], [], [line: 1])        == :ok
-    assert ExUnit.Filters.eval([line: "1"], [line: 5], [line: 1]) == :ok
-    assert ExUnit.Filters.eval([line: "1"], [:line], [line: 1])   == :ok
+    assert ExUnit.Filters.eval([line: "1"], [], %{line: 1})        == :ok
+    assert ExUnit.Filters.eval([line: "1"], [line: 5], %{line: 1}) == :ok
+    assert ExUnit.Filters.eval([line: "1"], [:line], %{line: 1})   == :ok
   end
 
   test "evaluating filter matches atoms" do
-    assert ExUnit.Filters.eval([os: "win"], [], [os: :win])          == :ok
-    assert ExUnit.Filters.eval([os: "win"], [os: :unix], [os: :win]) == :ok
-    assert ExUnit.Filters.eval([os: "win"], [:os], [os: :win])       == :ok
-    assert ExUnit.Filters.eval([case: "Foo"], [:os], [case: Foo])    == :ok
+    assert ExUnit.Filters.eval([os: "win"], [], %{os: :win})          == :ok
+    assert ExUnit.Filters.eval([os: "win"], [os: :unix], %{os: :win}) == :ok
+    assert ExUnit.Filters.eval([os: "win"], [:os], %{os: :win})       == :ok
+    assert ExUnit.Filters.eval([case: "Foo"], [:os], %{case: Foo})    == :ok
   end
 
   test "evaluating filter matches regexes" do
-    assert ExUnit.Filters.eval([os: ~r"win"], [], [os: :win])           == :ok
-    assert ExUnit.Filters.eval([os: ~r"mac"], [os: :unix], [os: :unix]) == {:error, :os}
+    assert ExUnit.Filters.eval([os: ~r"win"], [], %{os: :win})           == :ok
+    assert ExUnit.Filters.eval([os: ~r"mac"], [os: :unix], %{os: :unix}) == {:error, :os}
   end
 
   test "parsing filters" do