Tiny example showing how to force your Haskell code to be 100% deterministic under unit tests

TestableIO.hs

{-# LANGUAGE FlexibleInstances #-}
module Main where

import Control.Applicative ((<$>))
import Control.Monad.State.Lazy as S

class Monad m => World m where
    writeLine :: String -> m ()

instance World IO where
    writeLine = putStrLn

data FakeState = FS { fsWrittenLines :: [String] }
    deriving (Show)

def :: FakeState
def = FS { fsWrittenLines = [] }

instance World (S.State FakeState) where
    writeLine s = do
        oldLines <- fsWrittenLines <$> S.get
        S.put FS { fsWrittenLines = s:oldLines }

runFakeWorld :: b -> State b a -> (a, b)
runFakeWorld = flip S.runState

importantBusinessAction :: World m => m String
importantBusinessAction = do
    writeLine "This action is prohibited from doing any untestable IO."
    writeLine "Writing to stdout is testable, though, so this is all ok."
    return "Pickles"

main :: IO ()
main = do
    _ <- importantBusinessAction

    let (result, endState) = runFakeWorld def importantBusinessAction

    print endState
    print result