Mock configuration. When running production, use the defaultMockConfig without adding mocks to it - it would call the real functions.

The key or type of the mock created in a test suite may accidentally mismatch the key or type at the place where a mock is used. Silently calling the real functions would make the test suite fragile. So, when running on a test suite, protect against the mismatches by requiring that the mocks are present. Set mcShouldFailOnNotFound to return True or allow a few special cases:

testMockConfig = defaultMockConfig {
  mcShouldFailOnNotFound = \\key tRep -> key ``notElem`` whitelist where
    -- Functions that are allowed to be called during tests.
    whitelist = ["readFile"]
}

Wraps the function into a Mock. For successful lookup at the call site, the type of the passed function must match the type of the mocked function.

If the mocked function has polymorphic arguments, such as print :: Show a => a -> IO (), create a mock for each case. For example, if an app prints Int and Strings, create two mocks:

mockConf <- addMocksToConfig defaultConf <$> sequence
  [ makeMock "print" (const $ pure () :: Int -> IO ()),
  , makeMock "print" (const $ pure () :: String -> IO ())
  ]

For mocking functions with many arguments it is convenient to use constN and asTypeOf. Using asTypeOf lets you omit the type annotation. These definitions create the same mock:

makeMock "someAction" ((\_ _ _ -> pure "result") :: Arg1 -> Arg2 -> Arg3 -> SomeMonad ())
makeMock "someAction" (constN $ pure "result" :: Arg1 -> Arg2 -> Arg3 -> SomeMonad ())
makeMock "someAction" (constN $ pure "result" `asTypeOf` someAction)

A helper function to lookup the function. Likely you want to write a wrapper that retrieves the MockConfig from the environment.

withMock :: String -> f -> AppMonad f
withMock key f = do
  mockConf <- getMockConfig <$> getEnv
  pure $ fromMaybe f (lookupMockFunction mockConf key)

withMock "getSomething" getSomething >>= \f -> f someArg

Constant function for an arbitrary number of arguments.

let const2 = constN :: x -> a -> b -> x

>>> zipWith3 (constN 1) [1..10] [1..5] ["a", "b", "c"] :: [Int]
[1,1,1]

Description of what value for mock call the assertions expect

Find a mock by name. If there are several mocks under the same name, use lookupMockTyped.

Find a mock by name and type.

Build helpers using mocks in your application with this. The conversion is for the case when the type of a function stored in mock does not match the mocked function. Usually this is a case for a newtype wrapper over a polymorphic monad like MockMonadIO.

Assert that all expected calls were made in the given order.

mock <- lookupMockInEnv "name"  -- user-defined helper function for your app env
liftIO $ assertHasCalls [expectCall "arg1" "arg2"] mock

Assert the mock was never called.

Assert that the expected call happened at least once.

Get list of calls. Use together with callMatches when the existing assert* functions are not flexible enough.

Use this to create ExpectedCallRecord

Examples:

expectCall "email@example.com" True

Assert that mock returned the given result. Sometimes it is more convenient than checking arguments.

The expected call record matches the actual one. Note that it throws error for the logic bugs when a mismatch is caused by wrong number of arguments or wrong types.

Reuse the mocks between the test items

Reuse the mocks between the test items

Helper for making polymorphic mock functions.

Changes the return type of a function from MockMonadIO x to m x. The m must be a concrete type at the call site. If the caller is in a polymorphic monad, use one of the unMockMonadION instead.

The family of functions unMockMonadION is specialized with the number of arguments. Unlike fromMockMonadIO, the monad m can be polymorphic at the call site.