local_mock() temporarily substitutes implementations of package functions. This is useful for testing code that relies on functions that are slow, have unintended side effects or access resources that may not be available when testing.

with_mock() substitutes, runs code locally, and restores in one go.

local_mock(
  ...,
  .parent = parent.frame(),
  .env = get_mock_env(.parent),
  .defer_env = parent.frame()
)

with_mock(..., .parent = parent.frame(), .env = get_mock_env(.parent))

Arguments

...

[any]
Named arguments redefine mocked functions. An unnamed argument containing code in braces ({}) should be provided to with_mock(), it will be evaluated after mocking the functions. Use := to mock functions that start with a dot to avoid potential collision with current or future arguments to with_mock() or local_mock(). Passing more than one unnamed argument to with_mock(), or code that is not inside braces, gives a warning.

.parent

[environment]
the environment in which to evaluate the expressions, defaults to parent.frame(). Usually doesn't need to be changed.

.env

[environment]
the environment in which to patch the functions, defaults to topenv(). Usually doesn't need to be changed.

.defer_env

[environment]
Attach exit handlers to this environment. Typically, this should be either the current environment or a parent frame (accessed through parent.frame()). This argument is passed on as envir to withr::defer().

Value

local_mock() returns NULL, invisibly. with_mock() returns the result of the last unnamed argument. Visibility is preserved.

Details

This works by adding a shadow environment as a parent of the environment in which the expressions are evaluated. Everything happens at the R level, but only functions in your own package can be mocked. Otherwise, the implementation is modeled after the original version in the testthat package, which is now deprecated.

References

Suraj Gupta (2012): How R Searches And Finds Stuff

Examples

some_func <- function() stop("oops")
some_other_func <- function() some_func()
my_env <- environment()

tester_func <- function() {
  # The default for .env works well most of the time,
  # unfortunately not in examples
  local_mock(some_func = function() 42, .env = my_env)
  some_other_func()
}
try(some_other_func())
#> Error in some_func() : oops
tester_func()
#> [1] 42

tester_func_with <- function() {
  with_mock(
    some_func = function() 42,
    .env = my_env,
    {
      some_other_func()
    }
  )
}
tester_func_with()
#> [1] 42