hspec-hedgehog: Integrate Hedgehog and Hspec!

[ bsd3, library, testing ] [ Propose Tags ]

Please see the README on GitHub at https://github.com/parsonsmatt/hspec-hedgehog#readme


[Skip to Readme]
Versions [faq] 0.0.0.1, 0.0.1.0, 0.0.1.1, 0.0.1.2 (info)
Change log ChangeLog.md
Dependencies base (>=4.7 && <5), hedgehog (>=1.0.2 && <2), hspec (>=2.5.8 && <3), hspec-core (>=2.5.8 && <3), HUnit (>=1.5 && <2), QuickCheck (>=2.9.2 && <3), splitmix (>=0.0.1 && <1) [details]
License BSD-3-Clause
Copyright 2020 Matt Parsons
Author Matt Parsons
Maintainer parsonsmatt@gmail.com
Revised Revision 1 made by parsonsmatt at 2020-10-13T15:38:54Z
Category Testing
Home page https://github.com/parsonsmatt/hspec-hedgehog#readme
Bug tracker https://github.com/parsonsmatt/hspec-hedgehog/issues
Source repo head: git clone https://github.com/parsonsmatt/hspec-hedgehog
Uploaded by parsonsmatt at 2020-04-13T21:58:29Z
Distributions Arch:0.0.1.2, NixOS:0.0.1.2
Downloads 1613 total (202 in the last 30 days)
Rating 2.25 (votes: 2) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Hackage Matrix CI
Docs available [build log]
Last success reported on 2020-04-13 [all 1 reports]

Modules

[Index] [Quick Jump]

Downloads

Note: This package has metadata revisions in the cabal description newer than included in the tarball. To unpack the package including the revisions, use 'cabal get'.

Maintainer's Corner

For package maintainers and hackage trustees


Readme for hspec-hedgehog-0.0.1.2

[back to package description]

hspec-hedgehog

Build Status

An integration library for hspec and hedgehog.

Example:

import           Control.Concurrent     (threadDelay)
import           Control.Monad.IO.Class (liftIO)
import qualified Hedgehog.Gen           as Gen
import qualified Hedgehog.Range         as Range
import           Test.Hspec             (before, describe, hspec, it, shouldBe)
import           Test.Hspec.Hedgehog    (PropertyT, diff, forAll, hedgehog,
                                         (/==), (===))

main :: IO ()
main = hspec $ do
    describe "regular tests" $ do
        it "works" $ do
            True `shouldBe` True

    describe "hedgehog" $ do
        it "is useful if you get an ambiguous error" $ hedgehog $ do
            "no ambiguity" === "no ambiguity"

    describe "hedgehog tests" $ do
        it "lets you use PropertyT directly" $ hedgehog $ do
            x <- forAll $ Gen.integral (Range.linear 0 1000)
            y <- forAll $ Gen.integral (Range.linear 0 5000)
            diff (x + y) (>=) x

        it "renders a progress bit" $ hedgehog $ do
            x <- forAll $ Gen.integral (Range.linear 0 1000)
            y <- forAll $ Gen.integral (Range.linear 1 5000)
            liftIO $ threadDelay (100 * x + y)

    describe "with hooks" $ do
        before (pure "Hello!") $ do
            it "has functions" $ \str -> hedgehog $
                str === "Hello!"

            it "goes before or after" $ \str -> do
                pure () :: PropertyT IO ()
                str === "Hello!"

            it "generates" $ \str -> hedgehog $ do
                wrongLen <- forAll $ Gen.integral (Range.linear 0 3)
                length str /== wrongLen

How does this differ from hw-hspec-hedgehog?

Good question!

The hw-spec-hedgehog implementation does the easy thing. It calls Hedgehog's check function on the property, and if the property returns True, then it passes the test. If the property fails, then it renders an uninformative failure message - it's hardcoded to be:

Hedgehog property test failed

And that's all you get!

This library preserves Hedgehog's error message formatting, so you get rich, insightful error messages just like Hedgehog intended.

Furthermore, this library integrates with hspec's support for the QuickCheck library. Any option that works with QuickCheck should work with hedgehog properties, so you can use modifyMaxSuccess (\_ -> 10) to set the total tests to be 10, rather than the default 100.

Because it integrates directly with hspec, it also renders a familiar progress message while the test is running.