Documentation

Here eff represents the effect being mocked and m is the side-effect the mock implementation uses to keep MockState up to date.

Consder a Teletype effect defined as following that needs to be mocked:

data Teletype (m :: * -> *) a where
  Read :: Teletype m String
  Write :: String -> Teletype m ()

makeSem ''Teletype

A simple Mock instance for Teletype which always reads "Something" when the Read action is called and records all the Write actions could look like this:

instance Mock Teletype Identity where
  data MockImpl Teletype Identity m a where
    MockRead :: MockImpl Teletype Identity m String
    MockWrite :: String -> MockImpl Teletype Identity m String
    MockWriteCalls :: MockImpl Teletype Identity m [String]

  data MockState Teletype Identity = MockState {writes :: [String]}

  initialMockState = MockState []

  mock = interpret $ case
    Read -> send (MockImpl Teletype Identity) MockRead
    Write s -> send (MockImpl Teletype Identity) $ MockWrite s

  mockToState = reinterpretH $ case
    MockRead -> pureT "Something"
    MockWrite s -> do
      (MockState w) <- get (MockState Teletype Identity)
      put $ MockState (w ++ [s])
      pureT ()
    MockWriteCalls -> do
      (MockState w) <- get (MockState Teletype Identity)
      pureT w

Now with the help of this mock, a function which uses the Teletype effect can be tested. Considering this is the function being tested:

program :: Member Teletype r => Sem r ()
program = do
 name <- read
 write $ "Hello " <> name

A test could look like this (using hspec):

spec :: Spec
spec = describe "program" $ do
  it "writes hello message" $ do
    let MockState recorededWrites =
          runIdentity . runM . execMock $
            mock Teletype Identity program
    recorededWrites shouldBe ["Hello Something"]

Such a test can be written even without using this library. This class and the library are more useful when used with the template haskell generator for the mocks. The generator will produce a different mock than written above and it can be used like this:

genMock ''Teletype

spec :: Spec
spec = describe "program" $ do
  it "writes hello message" $ runM IO . evalMock do
    -- Setup what the Read action must return
    mockReadReturns $ pure "Something"

    -- Mock the Teletype effect while running the program
    mock Teletype @IO program

    -- Retrieve all the writes
    recordedWrites <- mockWriteCalls

    -- Make assertions about expected writes
    embed $ recordedWrites shouldBe ["Hello Something"]

Run a mocked effect to get MockState and the effect value

Like runMock but discards the MockState

Like runMock but only returns the MockState

Mock many effects

Constraint to assert existence of mocks for each effect in xs for state effect m

Append type level lists