From 7a55fabc5850678965e38e0ba4b6395ba61f24e9 Mon Sep 17 00:00:00 2001 From: Christophe De Troyer Date: Fri, 13 Dec 2024 16:42:58 +0100 Subject: [PATCH] behavior --- .credo.exs | 2 +- README.md | 6 +- lib/ex_example.ex | 179 ++++++++++------- lib/ex_example/analyzer/analyze.ex | 19 +- lib/ex_example/behaviour.ex | 12 ++ lib/ex_example/cache.ex | 0 lib/ex_example/cache/cache.ex | 11 +- lib/ex_example/cache/result.ex | 1 + lib/ex_example/executor.ex | 305 ++++++++++++++++++++++------- lib/ex_example/run.ex | 23 +++ lib/ex_example/tests.ex | 25 +++ lib/examples/stack.ex | 6 +- lib/examples/stack_examples.ex | 14 +- test/stack_test.exs | 5 +- 14 files changed, 437 insertions(+), 171 deletions(-) create mode 100644 lib/ex_example/behaviour.ex delete mode 100644 lib/ex_example/cache.ex create mode 100644 lib/ex_example/run.ex create mode 100644 lib/ex_example/tests.ex diff --git a/.credo.exs b/.credo.exs index ce2973c..dbdab20 100644 --- a/.credo.exs +++ b/.credo.exs @@ -109,7 +109,7 @@ {Credo.Check.Readability.RedundantBlankLines, []}, {Credo.Check.Readability.Semicolons, []}, {Credo.Check.Readability.SpaceAfterCommas, []}, - # {Credo.Check.Readability.Specs, []}, + {Credo.Check.Readability.Specs, []}, {Credo.Check.Readability.StringSigils, []}, {Credo.Check.Readability.TrailingBlankLine, []}, {Credo.Check.Readability.TrailingWhiteSpace, []}, diff --git a/README.md b/README.md index aa6cacb..4724abc 100644 --- a/README.md +++ b/README.md @@ -46,12 +46,12 @@ if the code it depends on, or the example itself, have not been changed. When the code changes, the example is executed again. -## Tests +## Tests -The examples are created to work with the code base, but they can also serve as a unit test. +The examples are created to work with the code base, but they can also serve as a unit test. To let ExUnit use the examples in your codebase as tests, add a test file in the `test/` folder, and -import the `ExExample.Test` module. +import the `ExExample.Test` module. To run the examples from above, add a file `ny_examples_test.exs` to your `test/` folder and include the following. diff --git a/lib/ex_example.ex b/lib/ex_example.ex index 295606e..8caa4c6 100644 --- a/lib/ex_example.ex +++ b/lib/ex_example.ex @@ -3,17 +3,111 @@ defmodule ExExample do Documentation for `ExExample`. """ alias ExExample.Analyze + alias ExExample.Cache alias ExExample.Executor + ############################################################ + # Types # + ############################################################ + + @typedoc """ + A dependency is a function that will be called by an example. + The format of a dependency is `{{module, function}, arity}` + """ + @type dependency :: {{atom(), atom()}, non_neg_integer()} + + @typedoc """ + """ + @type example :: {atom(), list(dependency)} + + ############################################################ + # Helpers # + ############################################################ + + @doc """ + I return the hidden name of an example. + The hidden name is the example body without modification. + """ + @spec hidden_name({atom(), atom()}) :: {atom(), atom()} + def hidden_name({module, func}) do + {module, String.to_atom("__#{func}__")} + end + + @doc """ + I determine if a module/function pair is an example or not. + + A function is an example if it is defined in a module that has the `__examples__/0` function + implemented, and when the `__examples__()` output lists that function name as being an example. + """ + @spec example?(dependency()) :: boolean() + def example?({{module, func}, _arity}) do + example_module?(module) and Keyword.has_key?(module.__examples__(), func) + end + + @doc """ + I return true if the given module contains examples. + """ + @spec example_module?(atom()) :: boolean + def example_module?(module) do + {:__examples__, 0} in module.__info__(:functions) + end + + @doc """ + I return a list of all dependencies for this example. + Note: this does includes other called modules too (e.g., Enum). + """ + @spec all_dependencies({atom(), atom()}) :: [dependency()] + def all_dependencies({module, func}) do + module.__examples__() + |> Keyword.get(func, []) + end + + @doc """ + I return a list of example dependencies for this example. + Note: this does not include other called modules. + """ + @spec example_dependencies({atom(), atom()}) :: [dependency()] + def example_dependencies({module, func}) do + all_dependencies({module, func}) + |> Enum.filter(&example?/1) + end + + @doc """ + I return a list of examples in the order they should be + executed in. + + I do this by topologically sorting their execution order. + """ + @spec execution_order(atom()) :: [{atom(), atom()}] + def execution_order(module) do + module.__examples__() + |> Enum.reduce(Graph.new(), fn + {function, []}, g -> + Graph.add_vertex(g, {__MODULE__, function}) + + {function, dependencies}, g -> + dependencies + # filter out all non-example dependencies + |> Enum.filter(&example?/1) + |> Enum.reduce(g, fn {{module, func}, _arity}, g -> + Graph.add_edge(g, {module, func}, {module, function}) + end) + end) + |> Graph.topsort() + end + + ############################################################ + # Macros # + ############################################################ + defmacro __using__(_options) do quote do import unquote(__MODULE__) + @behaviour ExExample.Behaviour + # module attribute that holds all the examples - Module.register_attribute(__MODULE__, :example_dependencies, accumulate: true) Module.register_attribute(__MODULE__, :examples, accumulate: true) - Module.register_attribute(__MODULE__, :copies, accumulate: true) - Module.register_attribute(__MODULE__, :copy, accumulate: false) @before_compile unquote(__MODULE__) end @@ -21,61 +115,8 @@ defmodule ExExample do defmacro __before_compile__(_env) do quote do - @doc """ - I return a list of all the dependencies for a given example, - or the list of all dependencies if no argument is given. - """ - def __example_dependencies__, do: @example_dependencies - - def __example_dependencies__(dependee) do - @example_dependencies - |> Enum.find({nil, []}, fn {name, _} -> name == dependee end) - |> elem(1) - end - - @doc """ - I reutrn all the examples in this module. - """ - def __examples__ do - @examples - end - - @doc """ - I run all the examples in this module. - """ - def __run_examples__ do - __sorted__() - |> Enum.each(fn {module, name} -> - apply(module, name, []) - end) - end - - @doc """ - I return a topologically sorted list of examples. - This list is the order in which the examples should be run. - """ - @spec __sorted__() :: list({atom(), atom()}) - def __sorted__ do - __example_dependencies__() - |> Enum.reduce(Graph.new(), fn - {example, []}, g -> - Graph.add_vertex(g, {__MODULE__, example}) - - {example, dependencies}, g -> - dependencies - # filter out all non-example dependencies - |> Enum.filter(&Executor.example?/1) - |> Enum.reduce(g, fn {{module, func}, _arity}, g -> - Graph.add_edge(g, {module, func}, {__MODULE__, example}) - end) - end) - |> Graph.topsort() - end - - def __example_copy__(example_name) do - @copies - |> Keyword.get(example_name, nil) - end + @spec __examples__ :: [ExExample.example()] + def __examples__, do: @examples end end @@ -91,24 +132,22 @@ defmodule ExExample do hidden_example_name = String.to_atom("__#{example_name}__") quote do - # fetch the attribute value, and then clear it for the next examples. - example_copy_tag = Module.get_attribute(unquote(__CALLER__.module), :copy) - Module.delete_attribute(unquote(__CALLER__.module), :copy) - def unquote({hidden_example_name, context, args}) do unquote(body) end - @copies {unquote(example_name), {unquote(__CALLER__.module), example_copy_tag}} - @example_dependencies {unquote(example_name), unquote(called_functions)} - @examples unquote(example_name) + @examples {unquote(example_name), unquote(called_functions)} def unquote(name) do - example_dependencies = __example_dependencies__(unquote(example_name)) - example_copy = __example_copy__(unquote(example_name)) + case Executor.attempt_example({__MODULE__, unquote(example_name)}, []) do + %{result: %Cache.Result{success: :success} = result} -> + result.result + + %{result: %Cache.Result{success: :failed} = result} -> + raise result.result - Executor.maybe_run_example(__MODULE__, unquote(example_name), example_dependencies, - copy: example_copy - ) + %{result: %Cache.Result{success: :skipped} = result} -> + :skipped + end end end end diff --git a/lib/ex_example/analyzer/analyze.ex b/lib/ex_example/analyzer/analyze.ex index ce8f391..85380fb 100644 --- a/lib/ex_example/analyzer/analyze.ex +++ b/lib/ex_example/analyzer/analyze.ex @@ -13,29 +13,21 @@ defmodule ExExample.Analyze do """ defstruct called_functions: [], env: nil, functions: [] + @spec put_call(map(), {atom(), atom()}, non_neg_integer()) :: map() def put_call(state, mod, arg) do %{state | called_functions: [{mod, arg} | state.called_functions]} end + @spec put_def(map(), atom(), non_neg_integer()) :: map() def put_def(state, func, arity) do %{state | functions: [{func, arity} | state.functions]} end end - # ---------------------------------------------------------------------------- - # Compute hash of all modules that the example depends on - - def compile_dependency_hash(dependencies) do - dependencies - |> Enum.map(fn {{module, _func}, _arity} -> - module.__info__(:attributes)[:vsn] - end) - |> :erlang.phash2() - end - # ---------------------------------------------------------------------------- # Exctract function calls from ast + @spec extract_function_calls(tuple(), Macro.Env.t()) :: [{{atom(), atom()}, non_neg_integer()}] def extract_function_calls(ast, env) do state = %State{env: env} # IO.inspect(env) @@ -52,6 +44,7 @@ defmodule ExExample.Analyze do # qualified function call # e.g., Foo.bar() + defp extract_function_call( {{:., _, [{:__aliases__, _, aliases}, func_name]}, _, args} = ast, state @@ -70,6 +63,10 @@ defmodule ExExample.Analyze do end end + defp extract_function_call({{:., _, _args}, _, _} = ast, state) do + {ast, state} + end + # variable in binding # e.g. `x` in `x = 1` defp extract_function_call({_func, _, nil} = ast, state) do diff --git a/lib/ex_example/behaviour.ex b/lib/ex_example/behaviour.ex new file mode 100644 index 0000000..28ca9b1 --- /dev/null +++ b/lib/ex_example/behaviour.ex @@ -0,0 +1,12 @@ +defmodule ExExample.Behaviour do + @moduledoc """ + I help determine when Examples ought to be run again or be copied + + + I do this by defining out a behaviour that is to be used with the + use macro for ExExample + """ + + @callback rerun?(any()) :: boolean() + @callback copy(any()) :: any() +end diff --git a/lib/ex_example/cache.ex b/lib/ex_example/cache.ex deleted file mode 100644 index e69de29..0000000 diff --git a/lib/ex_example/cache/cache.ex b/lib/ex_example/cache/cache.ex index 7c4a3e5..849aeb6 100644 --- a/lib/ex_example/cache/cache.ex +++ b/lib/ex_example/cache/cache.ex @@ -10,6 +10,15 @@ defmodule ExExample.Cache do @cache_name __MODULE__ + @doc """ + I clear the entire cache. + """ + @spec clear() :: :ok + def clear do + Cachex.clear!(@cache_name) + :ok + end + @doc """ I store a result in cache for a given key. """ @@ -22,7 +31,7 @@ defmodule ExExample.Cache do I fetch a previous Result from the cache if it exists. If it does not exist, I return `{:error, :not_found}`. """ - @spec get_result(Key.t()) :: {:ok, any()} | {:error, :no_result} + @spec get_result(Key.t()) :: {:ok, Result.t()} | {:error, :no_result} def get_result(%Key{} = key) do case Cachex.get(@cache_name, key) do {:ok, nil} -> diff --git a/lib/ex_example/cache/result.ex b/lib/ex_example/cache/result.ex index 558b085..4d71b60 100644 --- a/lib/ex_example/cache/result.ex +++ b/lib/ex_example/cache/result.ex @@ -15,5 +15,6 @@ defmodule ExExample.Cache.Result do field(:key, Key.t()) field(:success, :failed | :success | :skipped) field(:result, term()) + field(:cached, boolean(), default: true) end end diff --git a/lib/ex_example/executor.ex b/lib/ex_example/executor.ex index 38dadc6..b2ed6cd 100644 --- a/lib/ex_example/executor.ex +++ b/lib/ex_example/executor.ex @@ -5,20 +5,154 @@ defmodule ExExample.Executor do I contain logic to determine if a cachd result should be used, computation should be done again, or if an example should be skipped. """ - alias ExExample.Cache require Logger - @type dependency :: {{atom(), atom()}, non_neg_integer()} + + alias ExExample.Cache + alias ExExample.Run + + ############################################################ + # API # + ############################################################ + + @spec print_dependencies(ExExample.Run.t()) :: binary() + def print_dependencies(run) do + output = + if run.success != [] do + run.success + |> Enum.map_join( + ", ", + fn {{mod, func}, _arity} -> " 🟢 #{inspect(mod)}.#{Atom.to_string(func)}" end + ) + else + "" + end + + output = + if run.failed != [] do + run.success + |> Enum.map_join( + ", ", + fn {{mod, func}, _arity} -> + " 🔴 #{inspect(mod)}.#{Atom.to_string(func)}" + end + ) + |> Kernel.<>(output) + else + output + end + + output = + if run.no_cache != [] do + run.success + |> Enum.map_join( + ", ", + fn {{mod, func}, _arity} -> + " ⚪️ #{inspect(mod)}.#{Atom.to_string(func)}" + end + ) + |> Kernel.<>(output) + else + output + end + + output = + if run.skipped != [] do + run.success + |> Enum.map_join( + ", ", + fn {{mod, func}, _arity} -> + " ⚪️ #{inspect(mod)}.#{Atom.to_string(func)}" + end + ) + |> Kernel.<>(output) + else + output + end + + if output == "", do: "", else: "\n" <> output + end + + @spec print_run(ExExample.Run.t()) :: :ok + def print_run(%Run{result: %Cache.Result{success: :success} = result} = run) do + cached = if result.cached, do: "(cached) ", else: "" + + IO.puts(""" + 🟢 #{cached}#{inspect(run.key.module)}.#{Atom.to_string(run.key.function)}\ + #{print_dependencies(run)}\ + """) + + :ok + end + + def print_run(%Run{result: %Cache.Result{success: :skipped} = result} = run) do + cached = if result.cached, do: "(cached) ", else: "" + + IO.puts(""" + ⚪️ #{cached}#{inspect(run.key.module)}.#{Atom.to_string(run.key.function)}\ + #{print_dependencies(run)}\ + """) + + :ok + end + + def print_run(%Run{result: %Cache.Result{success: :failed} = result} = run) do + cached = if result.cached, do: "(cached) ", else: "" + + IO.puts(""" + 🔴 #{cached}#{inspect(run.key.module)}.#{Atom.to_string(run.key.function)}\ + #{print_dependencies(run)}\ + """) + + :ok + end + + @spec pretty_run(atom()) :: :ok + def pretty_run(module) do + module + |> ExExample.execution_order() + |> Enum.map(&attempt_example(&1, [])) + |> Enum.each(&print_run/1) + + :ok + end @doc """ - I determine if a module/function pair is an example or not. + I return the last known result of an example invocation. + If the example has not been run yet I return an error. + """ + @spec last_result(ExExample.dependency()) :: :success | :skipped | :failed | :no_cache + def last_result({{module, func}, _arity}) do + deps_hash = dependency_hash({module, func}) + + key = %Cache.Key{module: module, function: func, arguments: [], deps_hash: deps_hash} + + case Cache.get_result(key) do + {:ok, result} -> + result.success - A function is an example if it is defined in a module that has the `__examples__/0` function - implemented, and when the `__examples__()` output lists that function name as being an example. + {:error, :no_result} -> + :no_cache + end + end + + @doc """ + Given an example, I return a map of all its dependencies + that failed, succeeded, were skipped, or have not run yet. """ - @spec example?(dependency) :: boolean() - def example?({{module, func}, _arity}) do - {:__examples__, 0} in module.__info__(:functions) and func in module.__examples__() + @spec dependency_results({atom(), atom()}) :: %{ + success: [ExExample.dependency()], + skipped: [ExExample.dependency()], + failed: [ExExample.dependency()], + no_cache: [ExExample.dependency()] + } + def dependency_results({module, func}) do + results = + {module, func} + |> ExExample.example_dependencies() + |> Enum.group_by(&last_result/1) + + Map.merge(%{success: [], skipped: [], failed: [], no_cache: []}, results) end @doc """ @@ -26,97 +160,120 @@ defmodule ExExample.Executor do This hash can be used to determine of an example was run with an older version of a dependency. """ - def deps_hash(dependencies) do - dependencies + @spec dependency_hash({atom(), atom()}) :: non_neg_integer() + def dependency_hash({module, func}) do + {module, func} + |> ExExample.all_dependencies() |> Enum.map(fn {{module, _func}, _arity} -> - module.__info__(:attributes)[:vsn] + {module, module.__info__(:attributes)[:vsn]} end) + |> Enum.uniq() |> :erlang.phash2() end @doc """ - I run an example, iff all its dependencies have succeeded. + I run all the examples in the given module. + I use the cache for each invocation. + """ + @spec run_all_examples(atom()) :: [Run.t()] + def run_all_examples(module) do + module + |> ExExample.execution_order() + |> Enum.map(&attempt_example(&1, [])) + end - If all the dependencies of this example executed succesfully, - I will execute the example. + @doc """ + I attempt to run an example. - If any of the example its dependencies either failed or were skipped, - I will skip the example. + I return a struct that holds the result, the key, and a list of all + the dependencies and their previous result. """ - @spec maybe_run_example(atom(), atom(), list(dependency), Keyword.t()) :: any() - def maybe_run_example(module, func, dependencies, copy: copy) do - dependency_results = - dependencies - |> Enum.map(fn {{module, func}, _arity} -> - Cache.state({module, func}) - end) - |> Enum.group_by(& &1) - |> Map.put_new(:success, []) - |> Map.put_new(:skipped, []) - |> Map.put_new(:failed, []) - - deps_hash = deps_hash(dependencies) - - case dependency_results do - %{success: _, failed: [], skipped: []} -> - # check for a cached result - case Cache.get_result(%Cache.Key{module: module, function: func, deps_hash: deps_hash}) do - # cached result, no recompile - {:ok, result} -> - Logger.debug("found cached result for #{inspect(module)}.#{func}") - copy_result(result, copy).result - - {:error, :no_result} -> - Logger.debug("running #{inspect(module)}.#{func} for the first time") - hidden_example_name = String.to_atom("__#{func}__") - - run_example(module, hidden_example_name, [], func, deps_hash) - |> Map.get(:result) - end + @spec attempt_example({atom(), atom()}, [any()]) :: Run.t() + def attempt_example({module, func}, arguments) do + deps_hash = dependency_hash({module, func}) + key = %Cache.Key{module: module, function: func, arguments: arguments, deps_hash: deps_hash} - map -> - Logger.warning( - "skipping #{inspect(module)}.#{func} due to failed or skipped dependencies" - ) + case dependency_results({module, func}) do + # no failures, only no cache or success + %{failed: [], skipped: [], no_cache: no_cache, success: success} -> + result = run_example_with_cache({module, func}, arguments) + %Run{key: key, result: result, no_cache: no_cache, success: success} + + # failures and/or skipped + %{failed: failed, skipped: skipped, no_cache: no_cache, success: success} -> + result = %Cache.Result{key: key, success: :skipped, result: nil, cached: false} + Cache.put_result(result, key) + + %Run{ + key: key, + result: result, + no_cache: no_cache, + success: success, + failed: failed, + skipped: skipped + } + end + end + + @doc """ + I run an example with the cached results. + If there is cached result, I return that. + If there is no result in the cache I run the example. + """ + @spec run_example_with_cache({atom(), atom()}, [any()]) :: Cache.Result.t() + def run_example_with_cache({module, func}, arguments) do + deps_hash = dependency_hash({module, func}) + key = %Cache.Key{module: module, function: func, arguments: arguments, deps_hash: deps_hash} - {:error, :skipped_or_failed, map} + case Cache.get_result(key) do + {:ok, result} -> + if module.rerun?(result.result) do + run_example({module, func}, arguments) + else + %{result | result: module.copy(result.result)} + end + + {:error, :no_result} -> + run_example({module, func}, arguments) end end - # @doc """ - # I run an example in a module and wrap its output in - # something that can be cached. - # """ - @spec run_example(atom(), atom(), list(term()), atom(), any()) :: Cache.Result.t() - defp run_example(module, func, arguments, example_name, deps_hash) do - key = %Cache.Key{ - module: module, - function: example_name, - arguments: arguments, - deps_hash: deps_hash - } + @doc """ + I run an example directly. I do not consult the cache for a previous result. + I return a result of this execution and put it in the cache. + """ + @spec run_example({atom(), atom()}, [any()]) :: Cache.Result.t() + def run_example({module, func}, arguments) do + deps_hash = dependency_hash({module, func}) + key = %Cache.Key{module: module, function: func, arguments: arguments, deps_hash: deps_hash} result = try do - %Cache.Result{key: key, success: :success, result: apply(module, func, [])} + {module, func} = ExExample.hidden_name({module, func}) + result = apply(module, func, arguments) + %Cache.Result{key: key, success: :success, result: result} rescue e -> - Logger.error(inspect(e)) %Cache.Result{key: key, success: :failed, result: e} end - # put the result of this invocation in the cache. + # store the result in the cache Cache.put_result(result, key) - result + %{result | cached: false} end - # @doc """ - # Given a result from a previous invocation and a copy function, I create a copy of the result. - # """ - defp copy_result(%Cache.Result{} = result, {_, nil}), do: result - - defp copy_result(%Cache.Result{} = result, {module, func}) do - %{result | result: apply(module, func, [result.result])} + @doc """ + Given an example, I return a hash of all its dependencies. + This hash can be used to determine of an example was run with + an older version of a dependency. + """ + @spec deps_hash(list(ExExample.dependency())) :: non_neg_integer() + def deps_hash(dependencies) do + dependencies + |> Enum.map(fn {{module, _func}, _arity} -> + module.__info__(:attributes)[:vsn] + end) + |> :erlang.phash2() end end diff --git a/lib/ex_example/run.ex b/lib/ex_example/run.ex new file mode 100644 index 0000000..a329a4f --- /dev/null +++ b/lib/ex_example/run.ex @@ -0,0 +1,23 @@ +defmodule ExExample.Run do + @moduledoc """ + I am the result of running an example. + + I contain meta-data about this particular invocation such as + whether the example was found in cache, the state of its dependencies, + and the key. + """ + alias ExExample.Cache.Key + alias ExExample.Cache.Result + + use TypedStruct + + typedstruct do + field(:cached, boolean(), default: true) + field(:key, Key.t()) + field(:result, Result.t()) + field(:skipped, [ExExample.dependency()], default: []) + field(:failed, [ExExample.dependency()], default: []) + field(:no_cache, [ExExample.dependency()], default: []) + field(:success, [ExExample.dependency()], default: []) + end +end diff --git a/lib/ex_example/tests.ex b/lib/ex_example/tests.ex new file mode 100644 index 0000000..4b5214e --- /dev/null +++ b/lib/ex_example/tests.ex @@ -0,0 +1,25 @@ +defmodule ExExample.Tests do + @moduledoc """ + I generate a test for the given module that runs all of its examples. + """ + defmacro __using__(for: module) do + alias ExExample.Cache + + module_to_test = Macro.expand(module, __CALLER__) + examples = ExExample.execution_order(module_to_test) + + for {mod, func} <- examples do + quote do + test "#{inspect(unquote(mod))}.#{Atom.to_string(unquote(func))}" do + case ExExample.Executor.attempt_example({unquote(mod), unquote(func)}, []) do + %{result: %Cache.Result{success: :failed} = result} -> + raise result.result + + _ -> + :ok + end + end + end + end + end +end diff --git a/lib/examples/stack.ex b/lib/examples/stack.ex index 6861f7a..a837d64 100644 --- a/lib/examples/stack.ex +++ b/lib/examples/stack.ex @@ -11,9 +11,9 @@ defmodule Stack do field(:elements, [any()], default: []) end - @spec create() :: {:ok, t()} - def create do - {:ok, %Stack{}} + @spec create([any()]) :: {:ok, t()} + def create(xs \\ []) do + {:ok, %Stack{elements: xs}} end # yesyesyes diff --git a/lib/examples/stack_examples.ex b/lib/examples/stack_examples.ex index 31e0ed6..b0c1945 100644 --- a/lib/examples/stack_examples.ex +++ b/lib/examples/stack_examples.ex @@ -1,4 +1,5 @@ defmodule Examples.Stack do + # all exmaples must return a Stack @moduledoc """ I contain examples that test the `Stack` implementation. """ @@ -6,21 +7,22 @@ defmodule Examples.Stack do import ExUnit.Assertions - @copy :do_copy example new_stack do - {:ok, stack} = Stack.create() - assert stack == %Stack{} + {:ok, stack} = Stack.create([]) + assert stack == %Stack{elements: []} stack end example empty_stack_should_be_empty do stack = new_stack() assert Stack.empty?(stack) + stack end example push_stack do stack = new_stack() {:ok, stack} = Stack.push(stack, 1) + assert stack == %Stack{elements: [1]} stack end @@ -30,7 +32,11 @@ defmodule Examples.Stack do stack end - def do_copy(stack) do + @spec copy(any()) :: Stack.t() + def copy(stack) do %Stack{elements: stack.elements} end + + @spec rerun?(any()) :: boolean() + def rerun?(_), do: false end diff --git a/test/stack_test.exs b/test/stack_test.exs index 73a60c9..aabe1bd 100644 --- a/test/stack_test.exs +++ b/test/stack_test.exs @@ -1,8 +1,5 @@ defmodule StackTest do use ExUnit.Case doctest ExExample - - test "greets the world" do - Examples.Stack.__run_examples__() - end + use ExExample.Tests, for: Examples.Stack end