Mox

https://hexdocs.pm/mox
Admin
Mox is an Elixir library for defining concurrent mocks based on explicit contracts, supporting...
Tokens:7,631
Snippets:67
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Example Application Code for Displaying Weather

Source: https://hexdocs.pm/mox/index

This Elixir code defines a module `MyApp.HumanizedWeather` that fetches and formats weather information. It depends on `MyApp.WeatherAPI` to get the temperature and humidity for a given location.

```elixir
defmodule MyApp.HumanizedWeather do
  def display_temp({lat, long}) do
    {:ok, temp} = MyApp.WeatherAPI.temp({lat, long})
    "Current temperature is #{temp} degrees"
  end

  def display_humidity({lat, long}) do
    {:ok, humidity} = MyApp.WeatherAPI.humidity({lat, long})
    "Current humidity is #{humidity}%"
  end
end
```

--------------------------------

### Global Mode Collaboration in Elixir Tests

Source: https://hexdocs.pm/mox/index

This Elixir code demonstrates using Mox in global mode, where any process can utilize mocks defined in tests. It uses `setup :set_mox_from_context` and `setup :verify_on_exit!` and then defines expectations for a Task to consume.

```Elixir
setup :set_mox_from_context
setup :verify_on_exit!

test "invokes add and mult from a task" do
  MyApp.MockWeatherAPI
  |> expect(:temp, fn _loc -> {:ok, 30} end)
  |> expect(:humidity, fn _loc -> {:ok, 60} end)

  Task.async(fn ->
    assert MyApp.HumanizedWeather.display_temp({50.06, 19.94}) ==
              "Current temperature is 30 degrees"

    assert MyApp.HumanizedWeather.display_humidity({50.06, 19.94}) ==
              "Current humidity is 60%"
  end)
  |> Task.await
end
```

--------------------------------

### Verify Expectations on Process Exit

Source: https://hexdocs.pm/mox/index

Verifies that all expectations are met when the current process exits. This can be used as a setup callback to ensure all mocks are called throughout a test.

```elixir
setup :verify_on_exit!
```

--------------------------------

### Elixir: Automatic Mode Selection for Mox Mocks

Source: https://context7.com/context7/hexdocs_pm_mox/llms.txt

Demonstrates how Mox automatically selects private or global mock modes based on the `async` flag in ExUnit tests. The `set_mox_from_context` setup function in Elixir leverages test tags to determine the appropriate mocking strategy.

```elixir
defmodule MyApp.FlexibleTest do
  use ExUnit.Case
  import Mox

  setup :set_mox_from_context  # Uses private for async: true, global for async: false
  setup :verify_on_exit!

  @tag async: true
  test "runs in private mode" do
    expect(MyApp.MockWeatherAPI, :temp, fn _loc -> {:ok, 28} end)
    assert {:ok, 28} = MyApp.MockWeatherAPI.temp({50.06, 19.94})
  end
end

# Explicit private mode (default)
setup :set_mox_private

```

--------------------------------

### Set Expectations and Verify Mocks in Elixir Tests

Source: https://hexdocs.pm/mox/index

This Elixir test module demonstrates how to use Mox to mock `MyApp.WeatherAPI`. It sets expectations for `temp` and `humidity` functions using `expect/4` and ensures these expectations are verified upon test completion using `setup :verify_on_exit!`.

```elixir
defmodule MyApp.HumanizedWeatherTest do
  use ExUnit.Case, async: true

  import Mox

  setup :verify_on_exit!

  test "gets and formats temperature and humidity" do
    MyApp.MockWeatherAPI
    |> expect(:temp, fn {_lat, _long} -> {:ok, 30} end)
    |> expect(:humidity, fn {_lat, _long} -> {:ok, 60} end)

    assert MyApp.HumanizedWeather.display_temp({50.06, 19.94}) ==
             "Current temperature is 30 degrees"

    assert MyApp.HumanizedWeather.display_humidity({50.06, 19.94}) ==
             "Current humidity is 60%"
  end
end
```

--------------------------------

### Allowing Mock Access with `allow/3`

Source: https://hexdocs.pm/mox/index

The `allow/3` function permits other processes to share expectations and stubs defined by an owner process. It accepts a mock, the owner's PID, and either a PID, a named process, or a function that resolves to a PID. If the process is not yet started, it can be provided as a function, but it must resolve to a PID upon invocation for the expectation to succeed.

```Elixir
allow(MyMock, self(), child_pid)
allow(MyMock, self(), SomeChildProcess)
allow(MyMock, self(), fn -> GenServer.whereis(Deferred) end)
```

--------------------------------

### Define Mock for Multiple Elixir Behaviors

Source: https://hexdocs.pm/mox/index

This Elixir code shows how to use `Mox.defmock/2` to create a single mock that can handle multiple behaviors. In this example, `MyApp.MockWeatherAPI` is defined to mock both `MyApp.Weather` and `MyApp.PastWeather` behaviors.

```elixir
Mox.defmock(MyApp.MockWeatherAPI, for: [MyApp.Weather, MyApp.PastWeather])
```

--------------------------------

### Mox Blocking on Expectations Across Processes (Elixir)

Source: https://hexdocs.pm/mox/Mox

Shows a potential race condition when calling a mock from a different process and how to resolve it. This example initially presents the problem and then provides a solution using message passing to synchronize.

```elixir
test "calling a mock from a different process" do
  expect(MyApp.MockWeatherAPI, :temp, fn _loc -> {:ok, 30} end)

  spawn(fn -> MyApp.HumanizedWeather.temp({50.06, 19.94}) end)

  verify!()
end
```

```elixir
test "calling a mock from a different process" do
  parent = self()
  ref = make_ref()

  expect(MyApp.MockWeatherAPI, :temp, fn _loc ->
    send(parent, {ref, :temp})
    {:ok, 30}
  end)

  spawn(fn -> MyApp.HumanizedWeather.temp({50.06, 19.94}) end)

  assert_receive {^ref, :temp}

  verify!()
end
```

--------------------------------

### Create a Mock for WeatherAPI Behavior

Source: https://hexdocs.pm/mox/index

This Elixir code uses Mox to define a mock named `MyApp.MockWeatherAPI` for the `MyApp.WeatherAPI` behavior. It's typically placed in `test_helper.exs` or a `setup_all` block and configures the application to use this mock.

```elixir
Mox.defmock(MyApp.MockWeatherAPI, for: MyApp.WeatherAPI)
Application.put_env(:my_app, :weather, MyApp.MockWeatherAPI)
```

--------------------------------

### Configure Elixir Project for Compile-Time Mock Availability

Source: https://hexdocs.pm/mox/index

This Elixir configuration demonstrates how to make mocks available during project compilation. It involves defining the mock in `test/support/mocks.ex` and updating the `mix.exs` file to include the `test/support` directory in the `elixirc_paths` for the test environment.

```elixir
def project do
  [
    ...
    elixirc_paths: elixirc_paths(Mix.env),
    ...
  ]
end

defp elixirc_paths(:test), do: ["test/support", "lib"]
defp elixirc_paths(_),     do: ["lib"]
```

--------------------------------

### Individual Stubbing for Callbacks

Source: https://hexdocs.pm/mox/index

Demonstrates the equivalent of `stub_with/2` by individually stubbing each callback function from a shared behavior module.

```elixir
stub(MyApp.MockWeatherAPI, :temp, &MyApp.StubWeatherAPI.temp/1)
stub(MyApp.MockWeatherAPI, :humidity, &MyApp.StubWeatherAPI.humidity/1)
```

--------------------------------

### Defining Mocks with `defmock/2`

Source: https://hexdocs.pm/mox/index

The `defmock/2` function defines a new mock module for specified behaviors. It takes the mock name and a list of options, primarily `:for`, which specifies the module(s) the mock should implement. Optional arguments include `:moduledoc` for the mock's documentation and `:skip_optional_callbacks` to exclude optional callbacks from the generated mock.

```Elixir
Mox.defmock(MyMock, for: MyBehaviour)
Mox.defmock(MyMock, for: [MyBehaviour, MyOtherBehaviour])
Mox.defmock(MyMock, for: MyBehaviour, skip_optional_callbacks: [on_success: 2])
Mox.defmock(MyMock, for: MyBehaviour, moduledoc: false)
Mox.defmock(MyMock, for: MyBehaviour, moduledoc: "My mock module.")
```

--------------------------------

### Setting Mox Mode from Context

Source: https://hexdocs.pm/mox/index

Configures the Mox mocking mode based on the provided context. It defaults to global mode unless `async: true` is specified, in which case private mode is used.

```elixir
setup :set_mox_from_context
```

--------------------------------

### Define Mock Module from Behavior (Elixir)

Source: https://context7.com/context7/hexdocs_pm_mox/llms.txt

This snippet demonstrates how to define a mock module in Elixir using Mox. It shows how to create mocks from single or multiple behaviors, skip optional callbacks, and configure them for compile-time availability. The mock module replaces a real implementation, often configured via `Application.put_env`.

```elixir
defmodule MyApp.WeatherAPI do
  @callback temp(MyApp.LatLong.t()) :: {:ok, integer()}
  @callback humidity(MyApp.LatLong.t()) :: {:ok, integer()}

  def temp(lat_long), do: impl().temp(lat_long)
  def humidity(lat_long), do: impl().humidity(lat_long)
  defp impl, do: Application.get_env(:my_app, :weather, MyApp.ExternalWeatherAPI)
end

# In test_helper.exs
Mox.defmock(MyApp.MockWeatherAPI, for: MyApp.WeatherAPI)
Application.put_env(:my_app, :weather, MyApp.MockWeatherAPI)

# Mock multiple behaviours
defmodule MyApp.PastWeather do
  @callback past_temp(MyApp.LatLong.t(), DateTime.t()) :: {:ok, integer()}
end

Mox.defmock(MyApp.MockWeatherAPI, for: [MyApp.WeatherAPI, MyApp.PastWeather])

# Skip optional callbacks
Mox.defmock(MyApp.MockWeatherAPI,
  for: MyApp.WeatherAPI,
  skip_optional_callbacks: [on_success: 2]
)

# Compile-time mock in test/support/mocks.ex
# Update mix.exs:
# defp elixirc_paths(:test), do: ["test/support", "lib"]
# defp elixirc_paths(_), do: ["lib"]

```

--------------------------------

### Create Stubs for Unverified Function Calls (Elixir)

Source: https://context7.com/context7/hexdocs_pm_mox/llms.txt

This Elixir code demonstrates how to create stubs in Mox, which provide fallback implementations for functions that can be called any number of times without verification. Stubs are executed after all expectations are met and can be defined individually or within a test case template for reuse.

```elixir
defmodule MyApp.Case do
  use ExUnit.CaseTemplate

  setup _ do
    # Stub individual functions
    MyApp.MockWeatherAPI
    |> stub(:temp, fn _loc -> {:ok, 25} end)
    |> stub(:humidity, fn _loc -> {:ok, 50} end)

    :ok
  end
end

# Using the case template
defmodule MyApp.FeatureTest do
  use MyApp.Case

  test "uses stub when no expectation defined" do
    # Calls the stub defined in setup
    assert {:ok, 25} = MyApp.MockWeatherAPI.temp({50.06, 19.94})
  end

  test "expectation overrides stub" do
    # This expectation takes precedence
    expect(MyApp.MockWeatherAPI, :temp, fn _loc -> {:ok, 35} end)

    assert {:ok, 35} = MyApp.MockWeatherAPI.temp({50.06, 19.94})
    # After expectation is fulfilled, stub would be used for additional calls
  end
end

# Note: stub/3 overwrites previous stubs for the same function

```

--------------------------------

### Stub All Behavior Functions with Implementation Module

Source: https://context7.com/context7/hexdocs_pm_mox/llms.txt

Automatically generates stubs for all callbacks by delegating to a concrete implementation module. This is useful for establishing default fallback behaviors across an entire test suite. It requires defining a behavior module, a stub implementation module, and then using `defmock` and `stub_with`.

```elixir
defmodule MyApp.WeatherAPI do
  @callback temp(MyApp.LatLong.t()) :: {:ok, integer()}
  @callback humidity(MyApp.LatLong.t()) :: {:ok, integer()}
end

defmodule MyApp.StubWeatherAPI do
  @behaviour MyApp.WeatherAPI

  def temp(_loc), do: {:ok, 30}
  def humidity(_loc), do: {:ok, 60}
end

defmock(MyApp.MockWeatherAPI, for: MyApp.WeatherAPI)

# In a shared case template
defmodule MyApp.Case do
  use ExUnit.CaseTemplate

  setup _ do
    stub_with(MyApp.MockWeatherAPI, MyApp.StubWeatherAPI)
    :ok
  end
end

# This is equivalent to:
# stub(MyApp.MockWeatherAPI, :temp, &MyApp.StubWeatherAPI.temp/1)
# stub(MyApp.MockWeatherAPI, :humidity, &MyApp.StubWeatherAPI.humidity/1)

defmodule MyApp.FeatureTest do
  use MyApp.Case

  test "uses stub implementation by default" do
    assert {:ok, 30} = MyApp.MockWeatherAPI.temp({50.06, 19.94})
    assert {:ok, 60} = MyApp.MockWeatherAPI.humidity({50.06, 19.94})
  end

  test "can still set expectations that override stubs" do
    expect(MyApp.MockWeatherAPI, :temp, fn _loc -> {:ok, 15} end)
    assert {:ok, 15} = MyApp.MockWeatherAPI.temp({50.06, 19.94})
  end
end
```

--------------------------------

### Sequential Expectations for MockWeatherAPI.get_temp/1

Source: https://hexdocs.pm/mox/Mox

Allows defining multiple, sequential behaviors for the same function across different calls. This is useful for testing scenarios where a function might fail initially and then succeed.

```elixir
MockWeatherAPI
|> expect(:get_temp, 2, fn _loc -> {:error, :unreachable} end)
|> expect(:get_temp, 1, fn _loc -> {:ok, 30} end)

log = capture_log(fn ->
  assert Weather.current_temp(location)
    == "It's currently 30 degrees"
end)

assert log =~ "attempt 1 failed"
assert log =~ "attempt 2 failed"
assert log =~ "attempt 3 succeeded"
```

```elixir
MockWeatherAPI
|> expect(:get_temp, 3, fn _loc -> {:error, :unreachable} end)

assert Weather.current_temp(location) == "Current temperature is unavailable"
```

--------------------------------

### Verify All Expectations in Current Process

Source: https://hexdocs.pm/mox/index

Ensures that all expectations set by the current process have been met. This is typically called at the end of a test case.

```elixir
verify!()
```

--------------------------------

### Multiple Expectations for MockWeatherAPI.get_temp/1

Source: https://hexdocs.pm/mox/index

Allows defining different behaviors for MockWeatherAPI.get_temp/1 across multiple invocations. This is useful for testing retry logic or sequential API calls.

```elixir
MockWeatherAPI
|> expect(:get_temp, 2, fn _loc -> {:error, :unreachable} end)
|> expect(:get_temp, 1, fn _loc -> {:ok, 30} end)
```

--------------------------------

### Expect MockWeatherAPI.get_temp/1 Zero Times

Source: https://hexdocs.pm/mox/index

Sets an expectation that MockWeatherAPI.get_temp/1 should not be called. This is equivalent to using `deny/3`.

```elixir
expect(MockWeatherAPI, :get_temp, 0, fn _ -> {:ok, 30} end)
```

--------------------------------

### Stub with Alternative Implementation in Elixir Tests

Source: https://hexdocs.pm/mox/index

This Elixir code defines a custom test case `MyApp.Case` that uses `Mox.stub_with/2` to set a fallback implementation (`MyApp.StubWeatherAPI`) for `MyApp.MockWeatherAPI`. This ensures that if no explicit expectations are set, the stub implementation is used.

```elixir
defmodule MyApp.Case do
  use ExUnit.CaseTemplate

  setup _ do
    Mox.stub_with(MyApp.MockWeatherAPI, MyApp.StubWeatherAPI)
    :ok
  end
end
```

--------------------------------

### Handling Race Conditions with Mocks in Different Processes (Elixir)

Source: https://hexdocs.pm/mox/index

This Elixir snippet illustrates a potential race condition when a mock is called from a different process than the test process. It shows how `verify!()` might be called before the expectation is met, leading to test failures.

```Elixir
test "calling a mock from a different process" do
  expect(MyApp.MockWeatherAPI, :temp, fn _loc -> {:ok, 30} end)

  spawn(fn -> MyApp.HumanizedWeather.temp({50.06, 19.94}) end)

  verify!()
end
```

--------------------------------

### Set Expectations for Mock Function Calls (Elixir)

Source: https://context7.com/context7/hexdocs_pm_mox/llms.txt

This Elixir code illustrates how to set expectations for mock function calls using Mox. It shows defining specific return values for functions, setting call counts for retry logic, and asserting that functions are not called. These expectations are verified at test exit, ensuring the mock was used as intended.

```elixir
defmodule MyApp.HumanizedWeatherTest do
  use ExUnit.Case, async: true
  import Mox

  setup :verify_on_exit!

  test "gets and formats temperature and humidity" do
    MyApp.MockWeatherAPI
    |> expect(:temp, fn {_lat, _long} -> {:ok, 30} end)
    |> expect(:humidity, fn {_lat, _long} -> {:ok, 60} end)

    assert MyApp.HumanizedWeather.display_temp({50.06, 19.94}) ==
             "Current temperature is 30 degrees"

    assert MyApp.HumanizedWeather.display_humidity({50.06, 19.94}) ==
             "Current humidity is 60%"
  end

  test "expects function to be called five times" do
    expect(MyApp.MockWeatherAPI, :temp, 5, fn _ -> {:ok, 30} end)

    for _ <- 1..5 do
      MyApp.WeatherAPI.temp({50.06, 19.94})
    end
  end

  test "retries API call three times before succeeding" do
    MockWeatherAPI
    |> expect(:get_temp, 2, fn _loc -> {:error, :unreachable} end)
    |> expect(:get_temp, 1, fn _loc -> {:ok, 30} end)

    log = capture_log(fn ->
      assert Weather.current_temp(location) == "It's currently 30 degrees"
    end)

    assert log =~ "attempt 1 failed"
    assert log =~ "attempt 2 failed"
    assert log =~ "attempt 3 succeeded"
  end

  test "expects function never to be called" do
    expect(MyApp.MockWeatherAPI, :temp, 0, fn _ -> {:ok, 30} end)
    # Test logic that shouldn't call the function
  end
end

```

--------------------------------

### Explicit Allowances for Task Collaboration in Elixir

Source: https://hexdocs.pm/mox/index

This Elixir code snippet demonstrates how to use explicit allowances with Mox to enable a child Task process to use mock expectations defined in the parent process. It shows setting up expectations for `:temp` and `:humidity` and then allowing the parent PID to the child task.

```Elixir
test "invokes add and mult from a task" do
  MyApp.MockWeatherAPI
  |> expect(:temp, fn _loc -> {:ok, 30} end)
  |> expect(:humidity, fn _loc -> {:ok, 60} end)

  parent_pid = self()

  Task.async(fn ->
    MyApp.MockWeatherAPI |> allow(parent_pid, self())

    assert MyApp.HumanizedWeather.display_temp({50.06, 19.94}) ==
             "Current temperature is 30 degrees"

    assert MyApp.HumanizedWeather.display_humidity({50.06, 19.94}) ==
             "Current humidity is 60%"
  end)
  |> Task.await
end
```

--------------------------------

### Expect MockWeatherAPI.get_temp/1 Five Times

Source: https://hexdocs.pm/mox/index

Sets an expectation for MockWeatherAPI.get_temp/1 to be called exactly five times. The provided function dictates the return value for each invocation.

```elixir
expect(MockWeatherAPI, :get_temp, 5, fn _ -> {:ok, 30} end)
```

--------------------------------

### Setting Mox to Private Mode

Source: https://hexdocs.pm/mox/index

Configures Mox to use private mode, where mocks are confined to the process that defines them unless explicitly shared. This is the default mode when `async: true` is used.

```elixir
setup :set_mox_private
```

--------------------------------

### Stubbing MockWeatherAPI.get_temp/1 Any Number of Times

Source: https://hexdocs.pm/mox/index

Allows MockWeatherAPI.get_temp/1 to be called an arbitrary number of times without verification. Stubbing overwrites previous stub definitions for the same function and arity.

```elixir
stub(MockWeatherAPI, :get_temp, fn _loc -> {:ok, 30} end)
```

--------------------------------

### Setting Mox to Global Mode

Source: https://hexdocs.pm/mox/index

Configures Mox to use global mode, where mocks can be accessed by any process. Tests using global mocks cannot be run asynchronously.

```elixir
setup :set_mox_global
```

--------------------------------

### Elixir: Verify Mox Expectations Immediately or on Test Exit

Source: https://context7.com/context7/hexdocs_pm_mox/llms.txt

Illustrates how to verify Mox expectations in Elixir tests. Expectations can be verified automatically when the test exits using `verify_on_exit!`, or explicitly for specific mocks using `verify!(MockModule)`, or for all mocks in the current process using `verify!()`.

```elixir
defmodule MyApp.WeatherVerificationTest do
  use ExUnit.Case, async: true
  import Mox

  # Automatic verification when test exits
  setup :verify_on_exit!

  test "automatically verifies on test exit" do
    expect(MyApp.MockWeatherAPI, :temp, fn _loc -> {:ok, 30} end)

    MyApp.WeatherAPI.temp({50.06, 19.94})

    # No explicit verify! needed - happens automatically
  end

  test "manual verification for specific mock" do
    expect(MyApp.MockWeatherAPI, :temp, fn _loc -> {:ok, 30} end)

    MyApp.WeatherAPI.temp({50.06, 19.94})

    # Verify specific mock immediately
    verify!(MyApp.MockWeatherAPI)
  end

  test "verify all mocks in current process" do
    expect(MyApp.MockWeatherAPI, :temp, fn _loc -> {:ok, 30} end)
    expect(MyApp.MockOtherAPI, :fetch, fn _id -> {:ok, "data"} end)

    MyApp.WeatherAPI.temp({50.06, 19.94})
    MyApp.OtherAPI.fetch(123)

    # Verify all mocks at once
    verify!()
  end
end

```

--------------------------------

### Expect MockWeatherAPI.get_temp/1 Once

Source: https://hexdocs.pm/mox/index

Sets an expectation for MockWeatherAPI.get_temp/1 to be called exactly once. The provided function defines the return value for the mocked function.

```elixir
expect(MockWeatherAPI, :get_temp, fn _ -> {:ok, 30} end)
```

--------------------------------

### Synchronizing Mock Calls Across Processes with Messages (Elixir)

Source: https://hexdocs.pm/mox/index

This Elixir code provides a solution to the race condition described previously by synchronizing mock calls across processes. It uses `send/2` to notify the parent test process when the mock is called, ensuring `verify!()` is called only after the expectation is met.

```Elixir
test "calling a mock from a different process" do
  parent = self()
  ref = make_ref()

  expect(MyApp.MockWeatherAPI, :temp, fn _loc ->
    send(parent, {ref, :temp})
    {:ok, 30}
  end)

  spawn(fn -> MyApp.HumanizedWeather.temp({50.06, 19.94}) end)

  assert_receive {^ref, :temp}

  verify!()
end
```

--------------------------------

### Elixir: Handle Race Conditions with Async Mox Calls

Source: https://context7.com/context7/hexdocs_pm_mox/llms.txt

Shows how to manage race conditions in Elixir tests involving asynchronous Mox calls. This involves using `self()` and `send/2` to synchronize test execution with expectations called from spawned processes, and `assert_receive/1` to wait for these calls before verification.

```elixir
defmodule MyApp.RaceConditionTest do
  use ExUnit.Case, async: true
  import Mox

  setup :verify_on_exit!

  test "calling a mock from a different process without race condition" do
    parent = self()
    ref = make_ref()

    expect(MyApp.MockWeatherAPI, :temp, fn _loc ->
      # Send message to parent when expectation is called
      send(parent, {ref, :temp})
      {:ok, 30}
    end)

    spawn(fn ->
      MyApp.HumanizedWeather.temp({50.06, 19.94})
    end)

    # Wait for the expectation to be called before verify
    assert_receive {^ref, :temp}

    verify!()
  end

  test "waiting for multiple async calls" do
    parent = self()
    ref = make_ref()

    expect(MyApp.MockWeatherAPI, :temp, 3, fn _loc ->
      send(parent, {ref, :call})
      {:ok, 30}
    end)

    for _ <- 1..3 do
      spawn(fn -> MyApp.WeatherAPI.temp({50.06, 19.94}) end)
    end

    # Wait for all three calls
    assert_receive {^ref, :call}
    assert_receive {^ref, :call}
    assert_receive {^ref, :call}

    verify!()
  end
end

```

--------------------------------

### Verify Expectations in a Specific Mock

Source: https://hexdocs.pm/mox/index

Checks if all expectations defined within a particular mock object have been called. This allows for targeted verification of mock behavior.

```elixir
verify!(mock)
```

--------------------------------

### Set Global or Private Mode for Multi-Process Testing

Source: https://context7.com/context7/hexdocs_pm_mox/llms.txt

Controls whether mocks are accessible globally or only within the defining process. Global mode is useful for integration tests but prevents async execution, while private mode restricts mocks to the current process. This is configured using `set_mox_global` and requires `async: false` for global mode.

```elixir
defmodule MyApp.IntegrationTest do
  use ExUnit.Case, async: false  # Global mode requires async: false
  import Mox

  setup :set_mox_global
  setup :verify_on_exit!

  test "multiple processes access global mock" do
    MyApp.MockWeatherAPI
    |> expect(:temp, fn _loc -> {:ok, 30} end)
    |> expect(:humidity, fn _loc -> {:ok, 60} end)

    Task.async(fn ->
      # No explicit allowance needed in global mode
      assert MyApp.HumanizedWeather.display_temp({50.06, 19.94}) ==
               "Current temperature is 30 degrees"

      assert MyApp.HumanizedWeather.display_humidity({50.06, 19.94}) ==
               "Current humidity is 60%"
    end)
    |> Task.await
  end
end
```

--------------------------------

### Stubbing Multiple Functions with stub_with

Source: https://hexdocs.pm/mox/index

Stubs all functions defined by shared behaviors in a mock module with implementations from another module. This is a shorthand for stubbing each function individually.

```elixir
defmodule MyApp.WeatherAPI do
  @callback temp(MyApp.LatLong.t()) :: {:ok, integer()}
  @callback humidity(MyApp.LatLong.t()) :: {:ok, integer()}
end

defmodule MyApp.StubWeatherAPI do
  @behaviour MyApp.WeatherAPI
  def temp(_loc), do: {:ok, 30}
  def humidity(_loc), do: {:ok, 60}
end

defmock(MyApp.MockWeatherAPI, for: MyApp.WeatherAPI)

setup do
  stub_with(MyApp.MockWeatherAPI, MyApp.StubWeatherAPI)
  :ok
end
```

--------------------------------

### Define Application Behavior for Weather Data

Source: https://hexdocs.pm/mox/index

This Elixir code defines the behavior for retrieving weather data, including temperature and humidity, from a specified latitude and longitude. It dispatches to an implementation defined in the application's environment, defaulting to `MyApp.ExternalWeatherAPI`.

```elixir
defmodule MyApp.WeatherAPI do
  @callback temp(MyApp.LatLong.t()) :: {:ok, integer()}
  @callback humidity(MyApp.LatLong.t()) :: {:ok, integer()}

  def temp(lat_long), do: impl().temp(lat_long)
  def humidity(lat_long), do: impl().humidity(lat_long)
  defp impl, do: Application.get_env(:my_app, :weather, MyApp.ExternalWeatherAPI)
end
```

--------------------------------

### Expecting Mock Invocations with `expect/4`

Source: https://hexdocs.pm/mox/index

The `expect/4` function sets an expectation for a specific function within a mock to be invoked a certain number of times (`n`). It removes any prior stub for the same function, ensuring failures if called more than `n` times. A `stub/3` declared after `expect/4` will be used only after all expectations have been fulfilled.

```Elixir
expect(mock, name, n \\ 1, code)
```

--------------------------------

### Define Elixir Behavior for Past Weather Data

Source: https://hexdocs.pm/mox/index

This Elixir code defines a behavior for retrieving past weather data, specifically the past temperature, given a latitude/longitude pair and a specific date-time. It includes a callback specification.

```elixir
defmodule MyApp.PastWeather do
  @callback past_temp(MyApp.LatLong.t(), DateTime.t()) :: {:ok, integer()}
end
```

--------------------------------

### Allow Child Processes to Use Parent Expectations

Source: https://context7.com/context7/hexdocs_pm_mox/llms.txt

Permits child processes to consume expectations and stubs defined in the parent process, maintaining async test safety. Allowances can be explicit PIDs, named processes, or lazy functions. This is crucial for testing concurrent operations where child processes interact with mocks.

```elixir
defmodule MyApp.AsyncWeatherTest do
  use ExUnit.Case, async: true
  import Mox

  setup :verify_on_exit!

  test "invokes mock from a task with explicit allowance" do
    MyApp.MockWeatherAPI
    |> expect(:temp, fn _loc -> {:ok, 30} end)
    |> expect(:humidity, fn _loc -> {:ok, 60} end)

    parent_pid = self()

    Task.async(fn ->
      # Explicit allowance required for pre-1.8 or non-Task processes
      MyApp.MockWeatherAPI |> allow(parent_pid, self())

      assert MyApp.HumanizedWeather.display_temp({50.06, 19.94}) ==
               "Current temperature is 30 degrees"

      assert MyApp.HumanizedWeather.display_humidity({50.06, 19.94}) ==
               "Current humidity is 60%"
    end)
    |> Task.await
  end

  test "named process allowance" do
    expect(MyApp.MockWeatherAPI, :temp, fn _loc -> {:ok, 25} end)

    allow(MyApp.MockWeatherAPI, self(), MyApp.BackgroundWorker)

    MyApp.BackgroundWorker.fetch_temperature({50.06, 19.94})
  end

  test "lazy allowance for deferred processes" do
    expect(MyApp.MockWeatherAPI, :temp, fn _loc -> {:ok, 22} end)

    # Process doesn't exist yet at allowance time
    allow(MyApp.MockWeatherAPI, self(), fn -> GenServer.whereis(MyApp.DeferredWorker) end)

    # Start the process
    {:ok, _pid} = MyApp.DeferredWorker.start_link()
    MyApp.DeferredWorker.get_temp({50.06, 19.94})
  end
end

# Note: Elixir 1.8+ Tasks automatically use $callers for allowance
```

--------------------------------

### Expecting Mock Function Invocations with expect/4

Source: https://hexdocs.pm/mox/Mox

The `expect/4` function sets an expectation for a specific function (`name`/`arity`) in a mock to be invoked a certain number of times (`n`). It removes any prior stubs for that function, ensuring that calls exceeding `n` will fail. If a `stub/3` is called after `expect/4`, it will be used only after all expectations are met. This function is crucial for verifying interaction counts.

```elixir
expect(mock, :name, n, code)
```

--------------------------------

### Denying Mock Invocations with `deny/3`

Source: https://hexdocs.pm/mox/index

The `deny/3` function ensures that a specific function (identified by name and arity) within a mock is never invoked. Invoking `deny/3` removes any previously declared stub for that function, causing a failure if it's called. If a `stub/3` is declared after `deny/3`, the stub will take precedence and be used.

```Elixir
deny(MockWeatherAPI, :get_temp, 1)
```

--------------------------------

### Deny Function Calls to Ensure They Are Never Invoked

Source: https://context7.com/context7/hexdocs_pm_mox/llms.txt

Ensures a specific function is not called during a test by removing any previously declared stubs for that function. This is useful for verifying that certain external API calls are not made. It involves using the `deny/3` function.

```elixir
defmodule MyApp.CachingTest do
  use ExUnit.Case, async: true
  import Mox

  setup :verify_on_exit!

  test "uses cached value without calling external API" do
    # Ensure API is never called
    deny(MyApp.MockWeatherAPI, :temp, 1)

    # Setup cache
    MyApp.Cache.put({50.06, 19.94}, {:ok, 28})

    # Should use cached value, not call API
    assert {:ok, 28} = MyApp.WeatherAPI.temp({50.06, 19.94})
  end

  test "stub after deny takes precedence" do
    deny(MyApp.MockWeatherAPI, :temp, 1)
    # This stub overrides the deny
    stub(MyApp.MockWeatherAPI, :temp, fn _loc -> {:ok, 20} end)

    assert {:ok, 20} = MyApp.MockWeatherAPI.temp({50.06, 19.94})
  end
end
```
Tokens:
Raw