33279c5 · servant · git.iko.soy

git.iko.soy/servant

on master help sign in

Merge pull request #11 from anchor/content-types

33279c5Julian Arni12 years ago

servant-client.cabal+3

compare with master

unifiedsplit

@@ -45,6 +45,7 @@ library

45 , exceptions

46 , http-client

47 , http-client-tls

48+ , http-media

48 , http-types

49 , http-types

49 , network-uri >= 2.6

50 , network-uri >= 2.6

50 , safe

51 , safe

@@ -70,11 +71,13 @@ test-suite spec

70 , deepseq

71 , deepseq

71 , either

72 , either

72 , hspec == 2.*

73 , hspec == 2.*

74+ , http-media

73 , http-types

75 , http-types

74 , network >= 2.6

76 , network >= 2.6

75 , QuickCheck >= 2.7

77 , QuickCheck >= 2.7

76 , servant >= 0.2.1

78 , servant >= 0.2.1

77 , servant-client

79 , servant-client

78 , servant-server >= 0.2.1

80 , servant-server >= 0.2.1

81+ , text

79 , wai

82 , wai

80 , warp

83 , warp

src/Servant/Client.hs+19−15

@@ -1,3 +1,4 @@

1+{-# LANGUAGE DataKinds #-}

1{-# LANGUAGE InstanceSigs #-}

2{-# LANGUAGE InstanceSigs #-}

2{-# LANGUAGE TypeFamilies #-}

3{-# LANGUAGE TypeFamilies #-}

3{-# LANGUAGE TypeOperators #-}

4{-# LANGUAGE TypeOperators #-}

@@ -22,8 +23,10 @@ import Data.Proxy

22import Data.String.Conversions

23import Data.String.Conversions

23import Data.Text (unpack)

24import Data.Text (unpack)

24import GHC.TypeLits

25import GHC.TypeLits

26+import Network.HTTP.Media

25import qualified Network.HTTP.Types as H

27import qualified Network.HTTP.Types as H

26import Servant.API

28import Servant.API

29+import Servant.API.ContentTypes

27import Servant.Common.BaseUrl

30import Servant.Common.BaseUrl

28import Servant.Common.Req

31import Servant.Common.Req

29import Servant.Common.Text

32import Servant.Common.Text

@@ -115,10 +118,10 @@ instance HasClient Delete where

115-- side querying function that is created when calling 'client'

118-- side querying function that is created when calling 'client'

116-- will just require an argument that specifies the scheme, host

119-- will just require an argument that specifies the scheme, host

117-- and port to send the request to.

120-- and port to send the request to.

118−instance FromJSON result => HasClient (Get result) where

121+instance (MimeUnrender ct result) => HasClient (Get (ct ': cts) result) where

119− type Client (Get result) = BaseUrl -> EitherT String IO result

122+ type Client (Get (ct ': cts) result) = BaseUrl -> EitherT String IO result

120 clientWithRoute Proxy req host =

123 clientWithRoute Proxy req host =

121− performRequestJSON H.methodGet req 200 host

124+ performRequestCT (Proxy :: Proxy ct) H.methodGet req 200 host

122

125

123-- | If you use a 'Header' in one of your endpoints in your API,

126-- | If you use a 'Header' in one of your endpoints in your API,

124-- the corresponding querying function will automatically take

127-- the corresponding querying function will automatically take

@@ -161,21 +164,21 @@ instance (KnownSymbol sym, ToText a, HasClient sublayout)

161-- side querying function that is created when calling 'client'

164-- side querying function that is created when calling 'client'

162-- will just require an argument that specifies the scheme, host

165-- will just require an argument that specifies the scheme, host

163-- and port to send the request to.

166-- and port to send the request to.

164−instance FromJSON a => HasClient (Post a) where

167+instance (MimeUnrender ct a) => HasClient (Post (ct ': cts) a) where

165− type Client (Post a) = BaseUrl -> EitherT String IO a

168+ type Client (Post (ct ': cts) a) = BaseUrl -> EitherT String IO a

166

169

167 clientWithRoute Proxy req uri =

170 clientWithRoute Proxy req uri =

168− performRequestJSON H.methodPost req 201 uri

171+ performRequestCT (Proxy :: Proxy ct) H.methodPost req 201 uri

169

172

170-- | If you have a 'Put' endpoint in your API, the client

173-- | If you have a 'Put' endpoint in your API, the client

171-- side querying function that is created when calling 'client'

174-- side querying function that is created when calling 'client'

172-- will just require an argument that specifies the scheme, host

175-- will just require an argument that specifies the scheme, host

173-- and port to send the request to.

176-- and port to send the request to.

174−instance FromJSON a => HasClient (Put a) where

177+instance (MimeUnrender ct a) => HasClient (Put (ct ': cts) a) where

175− type Client (Put a) = BaseUrl -> EitherT String IO a

178+ type Client (Put (ct ': cts) a) = BaseUrl -> EitherT String IO a

176

179

177 clientWithRoute Proxy req host =

180 clientWithRoute Proxy req host =

178− performRequestJSON H.methodPut req 200 host

181+ performRequestCT (Proxy :: Proxy ct) H.methodPut req 200 host

179

182

180-- | If you use a 'QueryParam' in one of your endpoints in your API,

183-- | If you use a 'QueryParam' in one of your endpoints in your API,

181-- the corresponding querying function will automatically take

184-- the corresponding querying function will automatically take

@@ -411,7 +414,7 @@ instance (KnownSymbol sym, HasClient sublayout)

411-- | Pick a 'Method' and specify where the server you want to query is. You get

414-- | Pick a 'Method' and specify where the server you want to query is. You get

412-- back the status code and the response body as a 'ByteString'.

415-- back the status code and the response body as a 'ByteString'.

413instance HasClient Raw where

416instance HasClient Raw where

414− type Client Raw = H.Method -> BaseUrl -> EitherT String IO (Int, ByteString)

417+ type Client Raw = H.Method -> BaseUrl -> EitherT String IO (Int, ByteString, MediaType)

415

418

416 clientWithRoute :: Proxy Raw -> Req -> Client Raw

419 clientWithRoute :: Proxy Raw -> Req -> Client Raw

417 clientWithRoute Proxy req httpMethod host =

420 clientWithRoute Proxy req httpMethod host =

@@ -435,15 +438,16 @@ instance HasClient Raw where

435-- > addBook :: Book -> BaseUrl -> EitherT String IO Book

438-- > addBook :: Book -> BaseUrl -> EitherT String IO Book

436-- > addBook = client myApi

439-- > addBook = client myApi

437-- > -- then you can just use "addBook" to query that endpoint

440-- > -- then you can just use "addBook" to query that endpoint

438−instance (ToJSON a, HasClient sublayout)

441+instance (MimeRender ct a, HasClient sublayout)

439− => HasClient (ReqBody a :> sublayout) where

442+ => HasClient (ReqBody (ct ': cts) a :> sublayout) where

440

443

441− type Client (ReqBody a :> sublayout) =

444+ type Client (ReqBody (ct ': cts) a :> sublayout) =

442 a -> Client sublayout

445 a -> Client sublayout

443

446

444 clientWithRoute Proxy req body =

447 clientWithRoute Proxy req body =

445− clientWithRoute (Proxy :: Proxy sublayout) $

448+ clientWithRoute (Proxy :: Proxy sublayout) $ do

449+ let ctProxy = Proxy :: Proxy ct

446− setRQBody (encode body) req

450+ setRQBody (toByteString ctProxy body) (contentType ctProxy) req

447

451

448-- | Make the querying function append @path@ to the request path.

452-- | Make the querying function append @path@ to the request path.

449instance (KnownSymbol path, HasClient sublayout) => HasClient (path :> sublayout) where

453instance (KnownSymbol path, HasClient sublayout) => HasClient (path :> sublayout) where

src/Servant/Common/Req.hs+42−34

@@ -9,19 +9,18 @@ import Control.Monad

9import Control.Monad.Catch (MonadThrow)

10import Control.Monad.IO.Class

11import Control.Monad.Trans.Either

12−import Data.Aeson

13−import Data.Aeson.Parser

14−import Data.Aeson.Types

15−import Data.Attoparsec.ByteString

16−import Data.ByteString.Lazy hiding (pack)

12+import Data.ByteString.Lazy hiding (pack, filter, map, null)

17import Data.String

13import Data.String

18import Data.String.Conversions

14import Data.String.Conversions

19−import Data.Text

15+import Data.Proxy

16+import Data.Text (Text)

20import Data.Text.Encoding

17import Data.Text.Encoding

21−import Network.HTTP.Client

18+import Network.HTTP.Client hiding (Proxy)

22import Network.HTTP.Client.TLS

19import Network.HTTP.Client.TLS

20+import Network.HTTP.Media

23import Network.HTTP.Types

21import Network.HTTP.Types

24import Network.URI

22import Network.URI

23+import Servant.API.ContentTypes

25import Servant.Common.BaseUrl

24import Servant.Common.BaseUrl

26import Servant.Common.Text

25import Servant.Common.Text

27import System.IO.Unsafe

26import System.IO.Unsafe

@@ -29,14 +28,15 @@ import System.IO.Unsafe

29import qualified Network.HTTP.Client as Client

28import qualified Network.HTTP.Client as Client

31data Req = Req

30data Req = Req

32− { reqPath :: String

31+ { reqPath :: String

33− , qs :: QueryText

32+ , qs :: QueryText

34− , reqBody :: ByteString

33+ , reqBody :: Maybe (ByteString, MediaType)

34+ , reqAccept :: [MediaType]

35− , headers :: [(String, Text)]

35+ , headers :: [(String, Text)]

36 }

38defReq :: Req

39−defReq = Req "" [] "" []

39+defReq = Req "" [] Nothing [] []

41appendToPath :: String -> Req -> Req

42appendToPath p req =

@@ -62,12 +62,12 @@ addHeader name val req = req { headers = headers req

62 ++ [(name, toText val)]

63 }

65−setRQBody :: ByteString -> Req -> Req

65+setRQBody :: ByteString -> MediaType -> Req -> Req

66−setRQBody b req = req { reqBody = b }

66+setRQBody b t req = req { reqBody = Just (b, t) }

68reqToRequest :: (Functor m, MonadThrow m) => Req -> BaseUrl -> m Request

69reqToRequest req (BaseUrl reqScheme reqHost reqPort) =

70− fmap (setheaders . setrqb . setQS ) $ parseUrl url

70+ fmap (setheaders . setAccept . setrqb . setQS ) $ parseUrl url

72 where url = show $ nullURI { uriScheme = case reqScheme of

73 Http -> "http:"

@@ -80,10 +80,17 @@ reqToRequest req (BaseUrl reqScheme reqHost reqPort) =

80 , uriPath = reqPath req

81 }

83+ setrqb r = case reqBody req of

84+ Nothing -> r

83− setrqb r = r { requestBody = RequestBodyLBS (reqBody req) }

85+ Just (b,t) -> r { requestBody = RequestBodyLBS b

86+ , requestHeaders = requestHeaders r

87+ ++ [(hContentType, cs . show $ t)] }

84 setQS = setQueryString $ queryTextToQuery (qs req)

88 setQS = setQueryString $ queryTextToQuery (qs req)

89+ setheaders r = r { requestHeaders = requestHeaders r

85− setheaders r = r { requestHeaders = Prelude.map toProperHeader (headers req) }

90+ <> fmap toProperHeader (headers req) }

86−

91+ setAccept r = r { requestHeaders = filter ((/= "Accept") . fst) (requestHeaders r)

92+ <> [("Accept", renderHeader $ reqAccept req)

93+ | not . null . reqAccept $ req] }

87 toProperHeader (name, val) =

94 toProperHeader (name, val) =

88 (fromString name, encodeUtf8 val)

95 (fromString name, encodeUtf8 val)

@@ -104,7 +111,7 @@ displayHttpRequest :: Method -> String

104displayHttpRequest httpmethod = "HTTP " ++ cs httpmethod ++ " request"

111displayHttpRequest httpmethod = "HTTP " ++ cs httpmethod ++ " request"

105

112

106

113

107−performRequest :: Method -> Req -> (Int -> Bool) -> BaseUrl -> EitherT String IO (Int, ByteString)

114+performRequest :: Method -> Req -> (Int -> Bool) -> BaseUrl -> EitherT String IO (Int, ByteString, MediaType)

108performRequest reqMethod req isWantedStatus reqHost = do

115performRequest reqMethod req isWantedStatus reqHost = do

109 partialRequest <- liftIO $ reqToRequest req reqHost

116 partialRequest <- liftIO $ reqToRequest req reqHost

110

117

@@ -123,20 +130,28 @@ performRequest reqMethod req isWantedStatus reqHost = do

123 let status = Client.responseStatus response

130 let status = Client.responseStatus response

124 unless (isWantedStatus (statusCode status)) $

131 unless (isWantedStatus (statusCode status)) $

125 left (displayHttpRequest reqMethod ++ " failed with status: " ++ showStatus status)

132 left (displayHttpRequest reqMethod ++ " failed with status: " ++ showStatus status)

133+ ct <- case lookup "Content-Type" $ Client.responseHeaders response of

134+ Nothing -> pure $ "application"//"octet-stream"

135+ Just t -> case parseAccept t of

136+ Nothing -> left $ "invalid Content-Type header: " <> cs t

137+ Just t' -> pure t'

126− return $ (statusCode status, Client.responseBody response)

138+ return (statusCode status, Client.responseBody response, ct)

127 where

139 where

128 showStatus (Status code message) =

140 showStatus (Status code message) =

129 show code ++ " - " ++ cs message

141 show code ++ " - " ++ cs message

130

142

131−

143+performRequestCT :: MimeUnrender ct result =>

132−performRequestJSON :: FromJSON result =>

133− Method -> Req -> Int -> BaseUrl -> EitherT String IO result

144+ Proxy ct -> Method -> Req -> Int -> BaseUrl -> EitherT String IO result

134−performRequestJSON reqMethod req wantedStatus reqHost = do

145+performRequestCT ct reqMethod req wantedStatus reqHost = do

146+ let acceptCT = contentType ct

147+ (_status, respBody, respCT) <-

135− (_status, respBody) <- performRequest reqMethod req (== wantedStatus) reqHost

148+ performRequest reqMethod (req { reqAccept = [acceptCT] }) (== wantedStatus) reqHost

149+ unless (matches respCT (acceptCT)) $

150+ left $ "requested Content-Type " <> show acceptCT <> ", but got " <> show respCT

136 either

151 either

137− (\ message -> left (displayHttpRequest reqMethod ++ " returned invalid json: " ++ message))

152+ (left . ((displayHttpRequest reqMethod ++ " returned invalid response of type" ++ show respCT) ++))

138 return

153 return

139− (decodeLenient respBody)

154+ (fromByteString ct respBody)

140

155

141

156

142catchStatusCodeException :: IO a -> IO (Either Status a)

157catchStatusCodeException :: IO a -> IO (Either Status a)

@@ -145,10 +160,3 @@ catchStatusCodeException action =

145 case e of

160 case e of

146 Client.StatusCodeException status _ _ -> return $ Left status

161 Client.StatusCodeException status _ _ -> return $ Left status

147 exc -> throwIO exc

162 exc -> throwIO exc

148−

149−-- | Like 'Data.Aeson.decode' but allows all JSON values instead of just

150−-- objects and arrays.

151−decodeLenient :: FromJSON a => ByteString -> Either String a

152−decodeLenient input = do

153− v :: Value <- parseOnly (Data.Aeson.Parser.value <* endOfInput) (cs input)

154− parseEither parseJSON v

test/Servant/ClientSpec.hs+45−25

@@ -3,6 +3,7 @@

3{-# LANGUAGE ViewPatterns #-}

4{-# LANGUAGE DeriveGeneric #-}

5{-# LANGUAGE TypeOperators #-}

6+{-# LANGUAGE RecordWildCards #-}

6{-# LANGUAGE OverloadedStrings #-}

7{-# LANGUAGE OverloadedStrings #-}

7{-# OPTIONS_GHC -fcontext-stack=25 #-}

8{-# OPTIONS_GHC -fcontext-stack=25 #-}

8module Servant.ClientSpec where

9module Servant.ClientSpec where

@@ -14,9 +15,11 @@ import Data.Aeson

14import Data.ByteString.Lazy (ByteString)

15import Data.ByteString.Lazy (ByteString)

15import Data.Char

16import Data.Char

16import Data.Foldable (forM_)

17import Data.Foldable (forM_)

18+import Data.Monoid

17import Data.Proxy

19import Data.Proxy

18−import Data.Typeable

20+import qualified Data.Text as T

19import GHC.Generics

21import GHC.Generics

22+import Network.HTTP.Media

20import Network.HTTP.Types

23import Network.HTTP.Types

21import Network.Socket

24import Network.Socket

22import Network.Wai

25import Network.Wai

@@ -26,6 +29,7 @@ import Test.Hspec.QuickCheck

26import Test.QuickCheck

29import Test.QuickCheck

28import Servant.API

31import Servant.API

32+import Servant.API.ContentTypes

29import Servant.Client

33import Servant.Client

30import Servant.Server

34import Servant.Server

@@ -40,28 +44,43 @@ data Person = Person {

40instance ToJSON Person

44instance ToJSON Person

41instance FromJSON Person

45instance FromJSON Person

47+instance ToFormUrlEncoded Person where

48+ toFormUrlEncoded Person{..} =

49+ [("name", T.pack name), ("age", T.pack (show age))]

50+

51+lookupEither :: (Show a, Eq a) => a -> [(a,b)] -> Either String b

52+lookupEither x xs = do

53+ maybe (Left $ "could not find key " <> show x) return $ lookup x xs

54+

55+instance FromFormUrlEncoded Person where

56+ fromFormUrlEncoded xs = do

57+ n <- lookupEither "name" xs

58+ a <- lookupEither "age" xs

59+ return $ Person (T.unpack n) (read $ T.unpack a)

60+

61+

43alice :: Person

62alice :: Person

44alice = Person "Alice" 42

63alice = Person "Alice" 42

46type Api =

65type Api =

47− "get" :> Get Person

66+ "get" :> Get '[JSON] Person

48 :<|> "delete" :> Delete

67 :<|> "delete" :> Delete

49− :<|> "capture" :> Capture "name" String :> Get Person

68+ :<|> "capture" :> Capture "name" String :> Get '[JSON,FormUrlEncoded] Person

50− :<|> "body" :> ReqBody Person :> Post Person

69+ :<|> "body" :> ReqBody '[FormUrlEncoded,JSON] Person :> Post '[JSON] Person

51− :<|> "param" :> QueryParam "name" String :> Get Person

70+ :<|> "param" :> QueryParam "name" String :> Get '[FormUrlEncoded,JSON] Person

52− :<|> "params" :> QueryParams "names" String :> Get [Person]

71+ :<|> "params" :> QueryParams "names" String :> Get '[JSON] [Person]

53− :<|> "flag" :> QueryFlag "flag" :> Get Bool

72+ :<|> "flag" :> QueryFlag "flag" :> Get '[JSON] Bool

54− :<|> "matrixparam" :> MatrixParam "name" String :> Get Person

73+ :<|> "matrixparam" :> MatrixParam "name" String :> Get '[JSON] Person

55− :<|> "matrixparams" :> MatrixParams "name" String :> Get [Person]

74+ :<|> "matrixparams" :> MatrixParams "name" String :> Get '[JSON] [Person]

56− :<|> "matrixflag" :> MatrixFlag "flag" :> Get Bool

75+ :<|> "matrixflag" :> MatrixFlag "flag" :> Get '[JSON] Bool

57 :<|> "rawSuccess" :> Raw

76 :<|> "rawSuccess" :> Raw

58 :<|> "rawFailure" :> Raw

77 :<|> "rawFailure" :> Raw

59 :<|> "multiple" :>

78 :<|> "multiple" :>

60 Capture "first" String :>

79 Capture "first" String :>

61 QueryParam "second" Int :>

80 QueryParam "second" Int :>

62 QueryFlag "third" :>

81 QueryFlag "third" :>

63− ReqBody [(String, [Rational])] :>

82+ ReqBody '[JSON] [(String, [Rational])] :>

64− Get (String, Maybe Int, Bool, [(String, [Rational])])

83+ Get '[JSON] (String, Maybe Int, Bool, [(String, [Rational])])

65api :: Proxy Api

84api :: Proxy Api

66api = Proxy

85api = Proxy

@@ -101,8 +120,8 @@ getQueryFlag :: Bool -> BaseUrl -> EitherT String IO Bool

101getMatrixParam :: Maybe String -> BaseUrl -> EitherT String IO Person

120getMatrixParam :: Maybe String -> BaseUrl -> EitherT String IO Person

102getMatrixParams :: [String] -> BaseUrl -> EitherT String IO [Person]

121getMatrixParams :: [String] -> BaseUrl -> EitherT String IO [Person]

103getMatrixFlag :: Bool -> BaseUrl -> EitherT String IO Bool

122getMatrixFlag :: Bool -> BaseUrl -> EitherT String IO Bool

104−getRawSuccess :: Method -> BaseUrl -> EitherT String IO (Int, ByteString)

123+getRawSuccess :: Method -> BaseUrl -> EitherT String IO (Int, ByteString, MediaType)

105−getRawFailure :: Method -> BaseUrl -> EitherT String IO (Int, ByteString)

124+getRawFailure :: Method -> BaseUrl -> EitherT String IO (Int, ByteString, MediaType)

106getMultiple :: String -> Maybe Int -> Bool -> [(String, [Rational])]

125getMultiple :: String -> Maybe Int -> Bool -> [(String, [Rational])]

107 -> BaseUrl

126 -> BaseUrl

108 -> EitherT String IO (String, Maybe Int, Bool, [(String, [Rational])])

127 -> EitherT String IO (String, Maybe Int, Bool, [(String, [Rational])])

@@ -151,6 +170,7 @@ spec = do

151 it (show flag) $ withServer $ \ host -> do

170 it (show flag) $ withServer $ \ host -> do

152 runEitherT (getQueryFlag flag host) `shouldReturn` Right flag

171 runEitherT (getQueryFlag flag host) `shouldReturn` Right flag

153

172

173+{-

154 it "Servant.API.MatrixParam" $ withServer $ \ host -> do

174 it "Servant.API.MatrixParam" $ withServer $ \ host -> do

155 runEitherT (getMatrixParam (Just "alice") host) `shouldReturn` Right alice

175 runEitherT (getMatrixParam (Just "alice") host) `shouldReturn` Right alice

156 Left result <- runEitherT (getMatrixParam (Just "bob") host)

176 Left result <- runEitherT (getMatrixParam (Just "bob") host)

@@ -165,12 +185,13 @@ spec = do

165 forM_ [False, True] $ \ flag ->

185 forM_ [False, True] $ \ flag ->

166 it (show flag) $ withServer $ \ host -> do

186 it (show flag) $ withServer $ \ host -> do

167 runEitherT (getMatrixFlag flag host) `shouldReturn` Right flag

187 runEitherT (getMatrixFlag flag host) `shouldReturn` Right flag

188+-}

168

189

169 it "Servant.API.Raw on success" $ withServer $ \ host -> do

190 it "Servant.API.Raw on success" $ withServer $ \ host -> do

170− runEitherT (getRawSuccess methodGet host) `shouldReturn` Right (200, "rawSuccess")

191+ runEitherT (getRawSuccess methodGet host) `shouldReturn` Right (200, "rawSuccess", "application"//"octet-stream")

171

192

172 it "Servant.API.Raw on failure" $ withServer $ \ host -> do

193 it "Servant.API.Raw on failure" $ withServer $ \ host -> do

173− runEitherT (getRawFailure methodGet host) `shouldReturn` Right (400, "rawFailure")

194+ runEitherT (getRawFailure methodGet host) `shouldReturn` Right (400, "rawFailure", "application"//"octet-stream")

174

195

175 modifyMaxSuccess (const 20) $ do

196 modifyMaxSuccess (const 20) $ do

176 it "works for a combination of Capture, QueryParam, QueryFlag and ReqBody" $

197 it "works for a combination of Capture, QueryParam, QueryFlag and ReqBody" $

@@ -183,9 +204,9 @@ spec = do

183

204

184

205

185 context "client correctly handles error status codes" $ do

206 context "client correctly handles error status codes" $ do

186− let test :: WrappedApi -> Spec

207+ let test :: (WrappedApi, String) -> Spec

187− test (WrappedApi api) =

208+ test (WrappedApi api, desc) =

188− it (show (typeOf api)) $

209+ it desc $

189 withWaiDaemon (return (serve api (left (500, "error message")))) $

210 withWaiDaemon (return (serve api (left (500, "error message")))) $

190 \ host -> do

211 \ host -> do

191 let getResponse :: BaseUrl -> EitherT String IO ()

212 let getResponse :: BaseUrl -> EitherT String IO ()

@@ -193,16 +214,15 @@ spec = do

193 Left result <- runEitherT (getResponse host)

214 Left result <- runEitherT (getResponse host)

194 result `shouldContain` "error message"

215 result `shouldContain` "error message"

195 mapM_ test $

216 mapM_ test $

196− (WrappedApi (Proxy :: Proxy Delete)) :

217+ (WrappedApi (Proxy :: Proxy Delete), "Delete") :

197− (WrappedApi (Proxy :: Proxy (Get ()))) :

218+ (WrappedApi (Proxy :: Proxy (Get '[JSON] ())), "Delete") :

198− (WrappedApi (Proxy :: Proxy (Post ()))) :

219+ (WrappedApi (Proxy :: Proxy (Post '[JSON] ())), "Delete") :

199− (WrappedApi (Proxy :: Proxy (Put ()))) :

220+ (WrappedApi (Proxy :: Proxy (Put '[JSON] ())), "Delete") :

200 []

221 []

201

222

202data WrappedApi where

223data WrappedApi where

203 WrappedApi :: (HasServer api, Server api ~ EitherT (Int, String) IO a,

224 WrappedApi :: (HasServer api, Server api ~ EitherT (Int, String) IO a,

204− HasClient api, Client api ~ (BaseUrl -> EitherT String IO ()),

225+ HasClient api, Client api ~ (BaseUrl -> EitherT String IO ())) =>

205− Typeable api) =>

206 Proxy api -> WrappedApi

226 Proxy api -> WrappedApi

207

227

208

228