diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +Copyright (c) 2011-2014 Simon Hengel +Copyright (c) 2011-2012 Trystan Spangler +Copyright (c) 2011-2011 Greg Weber + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/Setup.lhs b/Setup.lhs new file mode 100644 --- /dev/null +++ b/Setup.lhs @@ -0,0 +1,3 @@ +#!/usr/bin/env runhaskell +> import Distribution.Simple +> main = defaultMain diff --git a/hspec-contrib.cabal b/hspec-contrib.cabal new file mode 100644 --- /dev/null +++ b/hspec-contrib.cabal @@ -0,0 +1,58 @@ +name: hspec-contrib +version: 0.1.0 +license: MIT +license-file: LICENSE +copyright: (c) 2011-2014 Simon Hengel, + (c) 2014 Junji Hashimoto + +maintainer: Simon Hengel +build-type: Simple +cabal-version: >= 1.10 +category: Testing +stability: experimental +bug-reports: https://github.com/hspec/hspec/issues +homepage: http://hspec.github.io/ +synopsis: Contributed functionality for Hspec +description: Contributed functionality for Hspec + +source-repository head + type: git + location: https://github.com/hspec/hspec + subdir: hspec-contrib + +library + ghc-options: + -Wall + hs-source-dirs: + src + build-depends: + base == 4.* + , hspec-core + , HUnit + exposed-modules: + Test.Hspec.Contrib.Retry + Test.Hspec.Contrib.HUnit + other-modules: + default-language: Haskell2010 + +test-suite spec + type: + exitcode-stdio-1.0 + hs-source-dirs: + test + main-is: + Spec.hs + other-modules: + Test.Hspec.Contrib.RetrySpec + Test.Hspec.Contrib.HUnitSpec + ghc-options: + -Wall + build-depends: + base == 4.* + , hspec-core + , HUnit + + , hspec-contrib + , hspec + , QuickCheck + default-language: Haskell2010 diff --git a/src/Test/Hspec/Contrib/HUnit.hs b/src/Test/Hspec/Contrib/HUnit.hs new file mode 100644 --- /dev/null +++ b/src/Test/Hspec/Contrib/HUnit.hs @@ -0,0 +1,23 @@ +module Test.Hspec.Contrib.HUnit ( +-- * Interoperability with HUnit + fromHUnitTest +) where + +import Test.Hspec.Core.Spec +import Test.HUnit (Test (..)) + +-- | +-- Convert a HUnit test suite to a spec. This can be used to run existing +-- HUnit tests with Hspec. +fromHUnitTest :: Test -> Spec +fromHUnitTest t = case t of + TestList xs -> mapM_ go xs + x -> go x + where + go :: Test -> Spec + go t_ = case t_ of + TestLabel s (TestCase e) -> it s e + TestLabel s (TestList xs) -> describe s (mapM_ go xs) + TestLabel s x -> describe s (go x) + TestList xs -> describe "" (mapM_ go xs) + TestCase e -> it "" e diff --git a/src/Test/Hspec/Contrib/Retry.hs b/src/Test/Hspec/Contrib/Retry.hs new file mode 100644 --- /dev/null +++ b/src/Test/Hspec/Contrib/Retry.hs @@ -0,0 +1,24 @@ +{-# LANGUAGE TypeFamilies #-} +module Test.Hspec.Contrib.Retry (retryWith) where + +import Test.Hspec.Core.Spec + +data Retry a = Retry Int a + +instance Example a => Example (Retry a) where + type Arg (Retry a) = Arg a + evaluateExample (Retry n example) a b c = do + v <- evaluateExample example a b c + case v of + Success -> return v + _ | n > 1 -> evaluateExample (Retry (pred n) example) a b c + _ -> return v + +-- | Retry evaluating example that may be failed until success. +retryWith :: Int + -- ^ number of retries, when this number is 1, just evaluate example and finish. + -> a + -- ^ retried example + -> Retry a + -- ^ Retry is instance of Example. +retryWith = Retry diff --git a/test/Spec.hs b/test/Spec.hs new file mode 100644 --- /dev/null +++ b/test/Spec.hs @@ -0,0 +1,1 @@ +{-# OPTIONS_GHC -F -pgmF hspec-discover #-} diff --git a/test/Test/Hspec/Contrib/HUnitSpec.hs b/test/Test/Hspec/Contrib/HUnitSpec.hs new file mode 100644 --- /dev/null +++ b/test/Test/Hspec/Contrib/HUnitSpec.hs @@ -0,0 +1,46 @@ +{-# OPTIONS_GHC -fno-warn-orphans #-} +module Test.Hspec.Contrib.HUnitSpec (main, spec) where + +import Test.Hspec +import Test.QuickCheck +import Control.Applicative + +import Test.Hspec.Core.Spec +import Test.Hspec.Contrib.HUnit +import Test.HUnit + +main :: IO () +main = hspec spec + +shouldYield :: Test -> [Tree (ActionWith ()) String] -> Expectation +a `shouldYield` b = map (Blind . fmap itemRequirement) <$> runSpecM (fromHUnitTest a) `shouldReturn` map Blind b + +instance Eq a => Eq (Tree c a) where + x == y = case (x, y) of + (Node s1 xs, Node s2 ys) -> s1 == s2 && xs == ys + (Leaf x1, Leaf x2) -> x1 == x2 + _ -> False + +spec :: Spec +spec = do + describe "fromHUnitTest" $ do + let e = TestCase $ pure () + + it "works for a TestCase" $ do + e `shouldYield` [Leaf ""] + + it "works for a labeled TestCase" $ do + TestLabel "foo" e + `shouldYield` [Leaf "foo"] + + it "works for a TestCase with nested labels" $ do + (TestLabel "foo" . TestLabel "bar") e + `shouldYield` [Node "foo" [Leaf "bar"]] + + it "works for a flat TestList" $ do + TestList [e, e, e] + `shouldYield` [Leaf "", Leaf "", Leaf ""] + + it "works for a nested TestList" $ do + (TestLabel "foo" . TestLabel "bar" . TestList) [TestLabel "one" e, TestLabel "two" e, TestLabel "three" e] + `shouldYield` [Node "foo" [Node "bar" [Leaf "one", Leaf "two", Leaf "three"]]] diff --git a/test/Test/Hspec/Contrib/RetrySpec.hs b/test/Test/Hspec/Contrib/RetrySpec.hs new file mode 100644 --- /dev/null +++ b/test/Test/Hspec/Contrib/RetrySpec.hs @@ -0,0 +1,22 @@ +module Test.Hspec.Contrib.RetrySpec (main, spec) where + +import Data.IORef + +import Test.Hspec +import Test.Hspec.Contrib.Retry + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "retry test" $ do + ref <- runIO $ newIORef (0::Int) + it "retry 11 times, then check the value" $ do + let incr :: IO Int + incr = do + val <- readIORef ref + writeIORef ref (val+1) + return val + retryWith 11 $ do + incr `shouldReturn` (10::Int)