How to test a behaviour?

behaviours
tdd
dynamic-dispatch

#1

I have a Behaviour that forces whoever implements it to implement a couple functions. For the sake of this discussion, let’s take the examples from the behaviours documentation.

defmodule Parser do
  @callback parse(String.t) :: {:ok, term} | {:error, String.t}
  @callback extensions() :: [String.t]
end

Now, let’s imagine that I see some repetition in the modules that implement this behaviour or that I want to add an universal parse! method. The preferred approach for this would be to use dynamic dispatching:

defmodule Parser do
  @callback parse(String.t) :: {:ok, term} | {:error, String.t}
  @callback extensions() :: [String.t]

  def parse!(implementation, contents) do
    case implementation.parse(contents) do
      {:ok, data} -> data
      {:error, error} -> raise ArgumentError, "parsing error: #{error}"
    end
  end
end

But now I am left with a question. How would I test parse! ?
Since this is pretty much working like an abstarct class at this point, how would you test it?

The only way I see it would be to use a Mock for the implementation parameter, but I am not sure about this approach.

Any ideas?


#2

I’d go for a bit of macros and implement a module that has the repetitive pars and is used by other modules that can override this functionality. S. GenServer for an example: https://github.com/elixir-lang/elixir/blob/v1.7.3/lib/elixir/lib/gen_server.ex#L732-L734 unless your server module implements it’s own terminate/2 the default is called.


#3

Creating a ‘fake’, or ‘simple’ implementation of the behaviour for testing purposes is a very common approach, so you do not have to feel unsure about this one :slight_smile:.

Of course, this only is able to test the behaviour itself, not the various implementations of it.