Passing parameters into defmacros

Questions / Help
, ,
1

Hello all,

I’m recently doing something similar to ExUnit, keeping a bunch of variables on “setup” block and then pass it to the next block which is “test” just like below.

defmodule MyTest do
  use ExUnit.Case, async: true

  setup do
    {:ok, %{message: "hi"}}
  end

  test "my test title", %{message, msg} do
    IO.puts(msg)
  end
end

However, I didn’t managed to do this on my own.

defmodule XUnit do

    defmacro __using__(_opts) do
        quote do
            import XUnit
            
            @setups []
            @tests []
            
            @before_compile XUnit
            
            def run() do
                IO.puts("Running....")
                run_setups()
                run_displays()
            end
        end
    end
    
    defmacro setup(do: block) do
        fn_name = String.to_atom("setup")
        quote do
            def unquote(fn_name)(), do: unquote(block)
            @setups [unquote(fn_name) | @setups]
        end
    end
    
    defmacro test(message, var, do: block) do
        var = Macro.escape(var)
        
        quote bind_quoted: [message: message, var: var, block: block] do
            fn_name = String.to_atom("test " <> message)
            def unquote(fn_name)(unquote(var)), do: unquote(block)
            @tests [{fn_name, var} | @tests]
        end
    end
    
    defmacro __before_compile__(_opts) do
        quote do
            def run_setups() do
                @setups
                |> Enum.each(fn setup_fn -> apply(__MODULE__, setup_fn, []) end)
            end
            
            def run_displays() do
                @tests
                |> Enum.each(fn {test_fn, params} ->
                    apply(__MODULE__, test_fn, [params])
                end)
            end
        end
    end

end

defmodule Test do
    use XUnit
    
    setup do
        %{message: "hi"}
    end
    
    test "my test title", %{message: msg} do
        IO.puts("print from test, #{msg}")
    end

end

Test.run()

It turns out this error message.

warning: variable "msg" does not exist and is being expanded to "msg()", please use parentheses to remove the ambiguity or change the variable name
  Main.exs:64: Test

** (CompileError) Main.exs:64: undefined function msg/0
    (elixir) src/elixir_bitstring.erl:142: :elixir_bitstring.expand_expr/4
    (elixir) src/elixir_bitstring.erl:27: :elixir_bitstring.expand/8
    (elixir) src/elixir_bitstring.erl:20: :elixir_bitstring.expand/4
    expanding macro: XUnit.test/3

I tried many ways but it still not really work as my expectation. This is my first question on elixir forum, so please could anyone give me some idea how to mimic the way that ex_unit was doing?

Thanks so much

2

Hello and welcome,

You do have a syntax error,

It should be…

test "my test title", %{message: msg} do
2 Likes
3

Your test macro handles arguments differently than the one in ExUnit:

I suspect that’s the cause of your immediate error.

You’ll also need to figure out how the return values of setup blocks make their way to the actual test functions; right now you’re passing the AST received by test. Enum.each is likely not the function you want here.

4

this is just an example…

5

really… I put Enum.each because it would be multiple test macros.

6

Example or not, unless your test cases have some kind of side-effect you won’t get any results from Enum.each besides :ok.

7

There is a trick:

defmacro test(message, param, do: block) do
  quote do
    def unquote(:"test_#{message}")(param) do
      unquote(param) = param
      unquote(block)
    end
  end
end
1 Like
8

Ahh, I was overthinking, this should works already.

defmacro test(message, param, do: block) do
  quote do
    def unquote(:"test_#{message}")(unquote(param)) do
      unquote(block)
    end
  end
end

But your problem is you didn’t pass results that setup returns to tests, something like:

def run_tests() do
  setup_result = @setups
  |> Enum.reduce(%{}, fn setup_fn, params
    -> apply(__MODULE__, setup_fn, [params])
  end)

  @tests
  |> Enum.each(fn test_fn ->
    apply(__MODULE__, test_fn, [setup_result])
  end)
end
1 Like
9

wow that works like a charm!
Thank you @Kabie, @al2o3cr for helping. I’m actually digging into the ExUnit source code see if I could find any clue but it’s quite complex tho.