Testing the absence of optional dependencies within a library

Why do you have a specific error in the first place?

Consider you have an optional dependency named ABC and you have an adapter called ABCAdapter, then you can just do

if Code.ensure_loaded?(ABC) do
  defmodule ABCAdapter do
    ...
  end
end

If your library user writes code like ABCAdapter.call(...) in their own project, where your library is installed as a dependency, but abc is not installed, there will be no compile-time error, only a runtime one, and this error would be self-descriptive, saying something like “Module ABCAdapter is undefined”. Why do you raise a special error and why do you want to test it?

What you described is exactly what I’m doing at the moment. In this case I’d want to write this test case in the library:

test “fails to run if ABC is missing” do
  assert_raise UndefinedFunctionError, fn → ABCAdapter.call(…) end
end

I’d want to test this because I’d want to make sure that optional dependencies are truly optional, as well as automate this in CI. Maybe it’s not a common use case since I don’t see any other “adapter” pattern libraries that have a test like this.

If I were you, I’d just not test it, cause it is too much effort for a single and very simple if.

There is no “good” way to test this, only hacks. I love hacks, so I can suggest these two things

1. Use mix_tester. Set up two mix projects. One which installs your dependency (you can specify it as {:my_library, path: "path/to/my_library"}) and abc. Another one which installs your library, but not abc. Then compile them and run some basic test in them.
   This approach is slow, since each test run will install abc, set up mix project and run a couple of binaries (hex usually caches dependencies locally, but still does network lookup to check for source hash changes), but it is the most real-world test you can get

2. Use repatch. In the async: false test introduce a global (or maybe shared) patch on the Code.ensure_loaded?/1 function to return false for ABC argument. Then delete the module and call something like Code.compile_file(ABCAdapter.module_info()[:compile][:source]), then assert that it fails. Then remove the patch. Then call the compile_file again, to bring the module back

You might be able to work with the --no-optional-deps flag on mix compile. You cannot toggle that out at runtime though. I generally only use that to test for compile time errors and warnings, but running tests might be possible as well.

Introduce the separate env :ci, exclude this library from it, mark the tests with @tag :ci and run MIX_ENV=ci mix test –-only ci.

These are all good suggestions! I’m sure they would all work. What I ended up doing is creating a script that runs once for each optional dependency, i.e. elixir check_optional_dependency.exs dependency_name, in CI. It calls Mix.install/2 to install the dependency, then runs a function to see if the adapter module is available. It also makes sure the adapters for the other optional dependencies throw errors when they are used:

try do
  {:ok, _} = adapter.fun(param1, param2)
  raise "#{adapter} should not be available!"
rescue
  UndefinedFunctionError -> :ok
  e -> raise e
end