Hey guys, I wrote a blog post about trying to write a simple pure, testable, effectful program in PureScript and the issues I ran into along the way. I’d appreciate any feedback y’all have. It also might be helpful for anyone new to the effect system in PureScript.
Is there a link to this blog post?
whoops, lol, there is now!
I think mtl style is probably the simplest option for achieving what you want, and would be a good starting point based on where you are now. You start by defining a type class for the operations you want:
class MonadFileSystem m where readFile :: String -> m String writeFile :: String -> String -> m Unit
and then write your code using constraints rather than concrete monads/ monad transformer stacks:
getSignedMessage :: forall m. MonadFileSystem m => m String
And finally you define instances for both the type you want to use in production as well as in testing:
instance MonadFileSystem (ExceptT Error Effect) where [...] instance MonadFileSystem (Writer (Array String)) where readFile path = do tell ["Read file: " <> path] pure "pretend file contents" writeFile path _ = do tell ["Wrote file: " <> path]
Of course the instance you use for testing will depend on exactly how you want to test. You might want a state monad which can keep track of the ‘files’ you’ve written to so that reading files returns whatever you’ve previously written to them, for example.
Personally, I don’t derive nearly as much value out of automated testing for effectful code than what you have to put in. Especially when mocking the effects themselves, so the effectiveness of the tests relies on the developer already understanding the exact behavior of those effects. I get a lot more mileage out of extracting as much logic as possible out into pure functions and testing that logic with my unit tests. On a good day, the remaining effectful code is so straightforward that any sort of test involving mocks would be strictly tautological. Then I’ll try to cover it in my system tests that actually run the real effects so your tests are covering the real interactions of your system, rather than the perceived interactions of whoever built the mocks.
I’m very, very interested in hearing other opinions on the matter, because I could be way off in the deep end with my perspective. Has anyone derived any value out of mocked out integration tests of effectful code? Like they’ve caught legitimate bugs with it?
Rad. This looks like it will work. I was originally looking into free monads, but it was a little more heavy-weight than I was ready for.
Personally, I don’t understand the fascination with free monads. I think they’re overly complicated and often not that useful; imo you don’t want them in the vast majority of cases.
I tend to agree that testing effectful code can have diminishing returns. Anytime you start mocking things, your tests provide less value. However, there are many times when your logic depends heavily on the result of an effect, and therefore can’t be extracted without a bunch of indirection.
Have you looked at purescript-run? I’m enjoying it a lot more than mtl style