This module allows you to easily integrate the Hedgehog library with Test.Hspec test-suites.

To get started, check out the hedgehog function, which lets you embed a PropertyT directly.

spec :: Spec
spec =
  describe "my great test" $ do
    it "generates stuff" $
      hedgehog $ do
        a <- forAll generator
        a === expected

Truth be told, the functionality is in the two orphan instances of Example for PropertyT. You can directly use code in the PropertyT IO type. However, because most Hedgehog functions are abstract in MonadTest, you might get errors about ambiguous types. The hedgehog function fixes the type to PropertyT IO (), which works out just fine.

You can use all of hspec's hooks with this, of course.

spec :: Spec
spec = before (pure "Hello!") $ do
  describe "with a string" $ do
    it "gets a string" $ \ str ->
      hedgehog $ do
        wrongLen <- forAll $ integral (linear 0 3)
        length str /== wrongLen

The function before will make all the following spec items a function, accepting that as a parameter. You should call hedgehog after the lambda.

If you are morally opposed to the pattern:

it "message" $ hedgehog $ do
  True === False

Then you can alternatively force the type some other way. One option is to use a no-op function, like this:

it "message" $ do
  pure () :: PropertyT IO ()
  True === False

This style has the advantage that parameters via hooks are less difficult to get right.

before (pure "Hello!") $ do
  it "message" $ \str -> do
    pure () :: PropertyT IO ()
    wrongLen <- forAll $ integral (linear 0 3)
    length str /== wrongLen

You don't have to remember to put the hedgehog call after the lambda.