@@ -4,13 +4,7 @@
44{-# LANGUAGE RecordWildCards #-}
55{-# LANGUAGE StandaloneDeriving #-}
66{-# LANGUAGE TypeApplications #-}
7−{-# LANGUAGE RankNTypes #-}
8−{-# LANGUAGE FlexibleContexts #-}
9−{-# LANGUAGE AllowAmbiguousTypes #-}
10−{-# LANGUAGE ScopedTypeVariables #-}
11−{-# LANGUAGE DataKinds #-}
127{-# OPTIONS_GHC -fno-warn-orphans #-}
13−{-# LANGUAGE TypeFamilies #-}
148
159import qualified Breakdown
1610import Data.Dynamic (toDyn)
@@ -21,134 +15,100 @@ import qualified Foo
2115import qualified Headers
2216import qualified Nested
2317import qualified Post
24−import qualified Put
2518import qualified Product
26−import qualified QueryParams
27−import qualified Roboservant as R
28−import qualified Roboservant.Server as RS
29−import qualified Roboservant.Client as RC
19+import qualified Roboservant as RS
3020import qualified Seeded
3121import Test.Hspec
3222import Test.Hspec.Core.Spec (FailureReason (Reason), ResultStatus (Failure, Success), itemExample, mapSpecItem_, resultStatus)
3323import qualified Valid
34−import Servant ( Server, Proxy(..), serve, Endpoints, HasServer )
35−
36−import Servant.Client(ClientEnv, mkClientEnv, baseUrlPort, parseBaseUrl,HasClient,ClientM)
37−import Network.Wai(Application)
38−import qualified Network.Wai.Handler.Warp as Warp
39−import Network.HTTP.Client (newManager, defaultManagerSettings)
40−import Control.Monad((>=>))
4124
4225main :: IO ()
4326main = hspec spec
4427
45−fuzzBoth
46− :: forall a .
47− (R.ToReifiedApi (Endpoints a), HasServer a '[], RS.FlattenServer a, RC.ToReifiedClientApi (Endpoints a), RC.FlattenClient a,
48− HasClient ClientM a)
49− => String -> Server a -> R.Config -> (Maybe R.Report -> IO ()) -> Spec
50−fuzzBoth name server config condition = do
51− it (name <> " via server") $
52− RS.fuzz @a server config >>= condition
53−
54− around (withServer (serve (Proxy :: Proxy a) server)) $
55− it (name <> " via client") $ \(clientEnv::ClientEnv) -> do
56− RC.fuzz @a clientEnv config >>= condition
57−
58−withServer :: Application -> ActionWith ClientEnv -> IO ()
59−withServer app action = Warp.testWithApplication (pure app) (genClientEnv >=> action)
60− where genClientEnv port = do
61− baseUrl <- parseBaseUrl "http://localhost"
62− manager <- newManager defaultManagerSettings
63− pure $ mkClientEnv manager (baseUrl { baseUrlPort = port })
64−
6528spec :: Spec
6629spec = do
6730 describe "Basic usage" $ do
6831 describe "noError" $ do
69− fuzzBoth @Valid.Api "find no error in a basic app" Valid.server R.defaultConfig (`shouldSatisfy` isNothing)
70− fuzzBoth @Valid.RoutedApi "finds no error in a valid generic app" Valid.routedServer R.defaultConfig (`shouldSatisfy` isNothing)
71− fuzzBoth @Valid.Api "fails coverage check" Valid.server R.defaultConfig {R.coverageThreshold = 0.6}
72− (\r ->
73− fmap (R.failureReason . R.rsException) r
74− `shouldSatisfy` ( \case
75− Just (R.InsufficientCoverage _) -> True
76− _ -> False
77− ))
78− describe "posted body" $
79− fuzzBoth @Post.Api "passes a coverage check using a posted body" Post.server R.defaultConfig {R.coverageThreshold = 0.99}
80− (`shouldSatisfy` isNothing)
81−
82−
83− describe "PUTted body" $
84− fuzzBoth @Put.Api "passes a coverage check using a posted body" Put.server R.defaultConfig {R.coverageThreshold = 0.99}
85− (`shouldSatisfy` isNothing)
86−
87−
32+ it "finds no error in a valid app" $ do
33+ RS.fuzz @Valid.Api Valid.server RS.defaultConfig
34+ >>= (`shouldSatisfy` isNothing)
35+ it "finds no error in a valid generic app" $ do
36+ RS.fuzz @Valid.RoutedApi Valid.routedServer RS.defaultConfig
37+ >>= (`shouldSatisfy` isNothing)
38+ it "does fail coverage check" $ do
39+ r <- RS.fuzz @Valid.Api Valid.server RS.defaultConfig {RS.coverageThreshold = 0.6}
40+ fmap (RS.failureReason . RS.rsException) r
41+ `shouldSatisfy` ( \case
42+ Just (RS.InsufficientCoverage _) -> True
43+ _ -> False
44+ )
45+ describe "posted body" $ do
46+ it "passes a coverage check using a posted body" $ do
47+ RS.fuzz @Post.Api Post.server RS.defaultConfig {RS.coverageThreshold = 0.99}
48+ >>= (`shouldSatisfy` isNothing)
8849 describe "seeded" $ do
89− let res = Seeded.Seed 1
90− shouldFail $ fuzzBoth @Seeded.Api "finds an error using information passed in" Seeded.server
91− (R.defaultConfig {R.seed = [(toDyn res, hash res)]})
92− (`shouldSatisfy` isNothing)
93−
94− describe "Foo" $
95− fuzzBoth @Foo.Api "finds an error in a basic app" Foo.server R.defaultConfig (`shouldSatisfy` serverFailure)
96−
97− describe "QueryParams" $
98− fuzzBoth @QueryParams.Api "can handle query params" QueryParams.server R.defaultConfig { R.seed = [R.hashedDyn (12::Int)] }
99− (`shouldSatisfy` isNothing)
100−
50+ shouldFail
51+ $ it "finds an error using information passed in"
52+ $ let res = Seeded.Seed 1
53+ in RS.fuzz @Seeded.Api Seeded.server (RS.defaultConfig {RS.seed = [(toDyn res, hash res)]})
54+ >>= (`shouldSatisfy` isNothing)
55+ describe "Foo" $ do
56+ it "finds an error in a basic app" $
57+ RS.fuzz @Foo.Api Foo.server RS.defaultConfig
58+ >>= (`shouldSatisfy` serverFailure)
10159 describe "BuildFrom" $ do
102− describe "headers (and sum types)" $
103− fuzzBoth @Headers.Api "should find a failure that's dependent on using header info" Headers.server R.defaultConfig
104− (`shouldSatisfy` serverFailure)
105− describe "product types" $
106− fuzzBoth @Product.Api "should find a failure that's dependent on creating a product" Product.server
107− R.defaultConfig {R.seed = [R.hashedDyn 'a', R.hashedDyn (1 :: Int)]}
108− (`shouldSatisfy` serverFailure)
60+ describe "headers (and sum types)" $ do
61+ it "should find a failure that's dependent on using header info" $ do
62+ RS.fuzz @Headers.Api Headers.server RS.defaultConfig
63+ >>= (`shouldSatisfy` serverFailure)
64+ describe "product types" $ do
65+ it "should find a failure that's dependent on creating a product" $ do
66+ RS.fuzz @Product.Api Product.server RS.defaultConfig {RS.seed = [RS.hashedDyn 'a', RS.hashedDyn (1 :: Int)]}
67+ >>= (`shouldSatisfy` serverFailure)
10968 describe "Breakdown" $ do
110− fuzzBoth @Breakdown.ProductApi "handles products" Breakdown.productServer R.defaultConfig
111− (`shouldSatisfy` serverFailure)
112− fuzzBoth @Breakdown.SumApi "handles sums" Breakdown.sumServer R.defaultConfig
113− (`shouldSatisfy` serverFailure)
114− describe "flattening" $
115− fuzzBoth @Nested.FlatApi "can handle nested apis" Nested.server R.defaultConfig {R.coverageThreshold = 0.99}
116− (`shouldSatisfy` isNothing)
117−
118−serverFailure :: Maybe R.Report -> Bool
69+ it "handles products" $ do
70+ RS.fuzz @Breakdown.ProductApi Breakdown.productServer RS.defaultConfig
71+ >>= (`shouldSatisfy` serverFailure)
72+ it "handles sums" $ do
73+ RS.fuzz @Breakdown.SumApi Breakdown.sumServer RS.defaultConfig
74+ >>= (`shouldSatisfy` serverFailure)
75+ describe "flattening" $ do
76+ -- we don't actually do much here, this is just here to document the appropriate response
77+ -- if you get a type error with a nested api.
78+ it "can handle nested apis" $ do
79+ RS.fuzz @(Nested.FlatApi) Nested.server RS.defaultConfig {RS.coverageThreshold = 0.99}
80+ >>= (`shouldSatisfy` isNothing)
81+
82+serverFailure :: Maybe RS.Report -> Bool
11983serverFailure = \case
120− Just R.Report {..} ->
121− let R.RoboservantException {..} = rsException
122− in failureReason /= R.NoPossibleMoves
84+ Just RS.Report {..} ->
85+ let RS.RoboservantException {..} = rsException
86+ in failureReason /= RS.NoPossibleMoves
12387 _ -> False
12488
125−deriving via (R.Atom Foo.Foo) instance R.Breakdown Foo.Foo
126−
127−deriving via (R.Atom Foo.Foo) instance R.BuildFrom Foo.Foo
128−
129−deriving via (R.Atom Headers.Foo) instance R.Breakdown Headers.Foo
89+deriving via (RS.Atom Foo.Foo) instance RS.Breakdown Foo.Foo
13090
131−deriving via (R.Atom Headers.Foo) instance R.BuildFrom Headers.Foo
91+deriving via (RS.Atom Foo.Foo) instance RS.BuildFrom Foo.Foo
13292
133−deriving via (R.Atom Seeded.Seed) instance R.Breakdown Seeded.Seed
93+deriving via (RS.Atom Headers.Foo) instance RS.Breakdown Headers.Foo
13494
135−deriving via (R.Atom Seeded.Seed) instance R.BuildFrom Seeded.Seed
95+deriving via (RS.Atom Headers.Foo) instance RS.BuildFrom Headers.Foo
13696
137−deriving via (R.Atom Void) instance R.BuildFrom Void
97+deriving via (RS.Atom Seeded.Seed) instance RS.Breakdown Seeded.Seed
13898
139−deriving via (R.Atom Post.FooPost) instance R.Breakdown Post.FooPost
140−deriving via (R.Atom Post.FooPost) instance R.BuildFrom Post.FooPost
99+deriving via (RS.Atom Seeded.Seed) instance RS.BuildFrom Seeded.Seed
141100
142−deriving via (R.Atom Put.Foo) instance R.Breakdown Put.Foo
143−deriving via (R.Atom Put.Foo) instance R.BuildFrom Put.Foo
101+deriving via (RS.Atom Void) instance RS.BuildFrom Void
144102
103+deriving via (RS.Atom Post.FooPost) instance RS.Breakdown Post.FooPost
145104
105+deriving via (RS.Atom Post.FooPost) instance RS.BuildFrom Post.FooPost
146106
147−deriving via (R.Compound Breakdown.Foo) instance R.Breakdown Breakdown.Foo
107+deriving via (RS.Compound Breakdown.Foo) instance RS.Breakdown Breakdown.Foo
148108
149−deriving via (R.Compound Product.Foo) instance R.BuildFrom Product.Foo
109+deriving via (RS.Compound Product.Foo) instance RS.BuildFrom Product.Foo
150110
151−deriving via (R.Compound Breakdown.SomeSum) instance R.Breakdown Breakdown.SomeSum
111+deriving via (RS.Compound Breakdown.SomeSum) instance RS.Breakdown Breakdown.SomeSum
152112
153113-- | `shouldFail` allows you to assert that a given `Spec` should contain at least one failing test.
154114-- this is often useful when testing tests.
@@ -158,7 +118,7 @@ shouldFail =
158118 ( \i ->
159119 i
160120 { itemExample = \p a cb -> do
161− r <- itemExample i p a cb
121+ r <- (itemExample i) p a cb
162122 pure
163123 r
164124 { resultStatus = case resultStatus r of