有没有办法在编译时向 elixir 模块添加函数？

Question

我正在使用 elixir 并遵循来自 http://blog.plataformatec.com.br/2015/10/mocks-and-explicit-contracts/ 博文。

我遇到了跟​​踪哪个模拟函数对应的问题 哪个测试。我为 api 包装器的测试环境添加了一个模拟模块。当我向 mock api 模块添加模拟函数时，我发现我不记得编写了哪些函数来返回哪些测试的结果。

我一直在尝试找出一种方法来使用宏在测试附近定义模拟方法。作为学习练习，我也对这个问题感兴趣。

以下是我设想的工作方式：

defmodule SomeMockModule do
end

defmodule MockUtil do
  defmacro add_mock module, block do
    # <THE MISSING PIECE>
  end
end

defmodule Test do
  use ExUnit.Case
  require MockUtil

  MockUtil.add_mock SomeMockModule do
    def some_func do
      "mock value"
    end
  end

  test "The mock value is returned" do
    assert SomeMockModule.some_func == "mock value"
  end
end

这类似于关于开放模块的问题： Open modules in Elixir? 但是我想知道如何在编译时而不是运行时做到这一点。

我环顾四周，没有发现任何说它可以或不能在编译时完成。

在某种程度上，这是一个花哨的复制和粘贴:)

到目前为止我所尝试的：

1）以下工作，但似乎相当混乱。它需要更改模拟模块。我想弄清楚是否有办法在没有之前编译的情况下做到这一点。

defmodule MockUtil do
  defmacro register_function( _module, do: block )do
    Module.put_attribute Test, :func_attr, block
  end
end

defmodule Test do
  require MockUtil
  Module.register_attribute __MODULE__,
      :func_attr,
      accumulate: true, persist: false

  defmacro define_functions(_env) do
    @func_attr
  end

  MockUtil.register_function SomeMockModule do
    def foo_bar do
      IO.puts "Inside foo_bar."
    end
  end
end

defmodule SomeMockModule do
  @before_compile {Test, :define_functions}
end

SomeMockModule.foo_bar

2）我也试过，代替：

Module.eval_quoted module, block

但是它会引发错误：

could not call eval_quoted on module {:__aliases__, [counter: 0, line: 10], [:SomeMockModule]} because it was already compiled

我想我遇到了编译问题。

有没有办法在编译时向模块添加函数？

Answer 1

您是否尝试过use 宏？你可以阅读更多关于它的信息here。如果我正确理解了您的问题，您似乎需要使用 &__using__/1 回调将功能注入您的模块。

编辑： 我只是不确定有没有办法在编译时在没有宏的情况下向模块添加函数......我们使用以下宏：

defmacro define(name, value) do
  quote do
    def unquote(name), do: unquote(value)
  end
end

要定义常量，也许您可​​以收到block 而不是value？

Answer 2

我能够弄清楚以下几点：

ExUnit.start

defmodule MockUtil do
  defmacro __using__(_opts) do
    quote do
      defmacro __using__(_env) do
        test_module = __MODULE__
        mock_module = __CALLER__.module
                      |> Atom.to_string
                      |> String.downcase
                      |> String.split(".")
                      |> tl
        name = "#{mock_module}_functions_attr" |> String.to_atom
        quote do
          unquote(test_module).unquote(name)()
        end
      end
    end
  end

  defmacro add_mock_function( module, do: block ) do
    mock_module = Macro.expand_once( module, __CALLER__)
                  |> Atom.to_string
                  |> String.downcase
                  |> String.split(".")
                  |> tl

    test_module = __CALLER__.module
    functions_attribute = "#{mock_module}_functions_attr" |> String.downcase |> String.to_atom

    first_time? = Module.get_attribute test_module, functions_attribute

    Module.register_attribute test_module,
        functions_attribute,
        accumulate: true, persist: false

    Module.put_attribute test_module, functions_attribute, block

    if first_time? == nil do
      ast = {:@, [], [{functions_attribute, [], test_module}]}
      name = "#{mock_module}_functions_attr" |> String.to_atom
      quote do
        defmacro unquote(name)(), do: unquote(ast)
      end
    end
  end
end

defmodule Test do
  use ExUnit.Case
  use MockUtil


  MockUtil.add_mock_function Mock do
    def foo do
      "Inside foo."
    end
  end

  test "Register function adds foo function" do
    assert  "Inside foo." == Mock.foo
  end

  MockUtil.add_mock_function Mock do
    def bar do
      "Inside bar."
    end
  end

  test "Register function adds bar function" do
    assert  "Inside bar." == Mock.bar
  end

  MockUtil.add_mock_function MockAgain do
    def baz do
      "Inside bar."
    end
  end

  test "Register function adds baz function" do
    assert  "Inside bar." == MockAgain.baz
  end
end

defmodule Mock do
  use Test
end

defmodule MockAgain do
  use Test
end

我最初试图避免调用“使用”，但我需要它们以便编译顺序正确，而且我认为无论如何都无法将代码注入其他模块。

Answer 3

您能否提供更多关于“我遇到了跟​​踪哪个模拟函数对应于哪个测试的问题”的更多信息，因为我认为您可能过于复杂了。

根据您链接的文章，您将使用 OTP 应用程序配置来指定在哪个环境中使用哪个模块。例如，在prod 中，您可能希望使用“真正的”HTTP 客户端。

# config/dev.exs
config :your_app, :module_to_mock, YourApp.Module.Sandbox

# config/test.exs
config :your_app, :module_to_mock, YourApp.Module.InMemory

# config/prod.exs
config :your_app, :module_to_mock, YourApp.Module.RealHTTP

然后，当您想使用该模块时，您只需使用它来抓取它

Application.get_env(:your_app, :module_to_mock)

在本例中，上述模块的行为将遵循...

1. YourApp.Module.Sandbox - Hit 是您正在与之交互的任何 API 的开发沙箱，如果有的话。在开发过程中简单地使用YourApp.Module.InMemory 也很常见。只取决于您使用它的目的。
2. YourApp.Module.InMemory - 此模块中的所有 API 交互只会返回静态的内联数据。例如代表真实 API 将发回的内容的结构列表
3. YourApp.Module.RealHTTP - 真正的 HTTP 交互。

正如文章还指出的，上述每个模块都将实现相同的行为（即，通过 @behaviour 实现的 Elixir 行为，这确保每个模块都实现了必要的功能，因此您知道您的 InMemory 模块将像可靠地作为您的 RealHTTP 模块。

我意识到我几乎只是重复了一些文章，但除此之外，我并没有真正理解您的问题。