@@ -26,44 +26,59 @@
2626#include "overlapping-compat.h"
2727module Servant.ClientSpec where
2828
29−import Control.Arrow (left)
30−import Control.Concurrent (forkIO, killThread, ThreadId)
31−import Control.Exception (bracket)
32−import Control.Monad.Error.Class (throwError )
29+import Control.Arrow (left)
30+import Control.Concurrent (ThreadId, forkIO,
31+ killThread)
32+import Control.Exception (bracket)
33+import Control.Monad.Error.Class (throwError)
3334import Data.Aeson
34−import qualified Data.ByteString.Lazy as BS
35−import Data.Char (chr, isPrint)
36−import Data.Foldable (forM_)
37−import Data.Monoid hiding (getLast)
35+import qualified Data.ByteString.Lazy as BS
36+import Data.Char (chr, isPrint)
37+import Data.Foldable (forM_)
38+import Data.Monoid hiding (getLast)
3839import Data.Proxy
39−import qualified Generics.SOP as SOP
40−import GHC.Generics (Generic)
41−import qualified Network.HTTP.Client as C
40+import qualified Generics.SOP as SOP
41+import GHC.Generics (Generic)
42+import qualified Network.HTTP.Client as C
4243import Network.HTTP.Media
43−import qualified Network.HTTP.Types as HTTP
44+import qualified Network.HTTP.Types as HTTP
4445import Network.Socket
45−import Network.Wai (Request, requestHeaders, responseLBS)
46+import qualified Network.Wai as Wai
4647import Network.Wai.Handler.Warp
47−import Prelude ()
48+import Prelude ()
4849import Prelude.Compat
49−import System.IO.Unsafe (unsafePerformIO)
50−import Test.HUnit
50+import System.IO.Unsafe (unsafePerformIO)
5151import Test.Hspec
5252import Test.Hspec.QuickCheck
53+import Test.HUnit
5354import Test.QuickCheck
54−import Web.FormUrlEncoded (FromForm, ToForm)
55−
56−import Servant.API
55+import Web.FormUrlEncoded (FromForm, ToForm)
56+
57+import Servant.API ((:<|>) ((:<|>)),
58+ (:>), AuthProtect,
59+ BasicAuth,
60+ BasicAuthData (..),
61+ Capture,
62+ CaptureAll, Delete,
63+ DeleteNoContent,
64+ EmptyAPI,
65+ FormUrlEncoded,
66+ Get, Header,
67+ Headers, JSON,
68+ NoContent, Post,
69+ Put, QueryFlag,
70+ QueryParam,
71+ QueryParams,
72+ ReqBody)
5773import Servant.API.Internal.Test.ComprehensiveAPI
5874import Servant.Client
59−import Servant.Client.Generic
60−import qualified Servant.Common.Req as SCR
61−import qualified Servant.Client.HttpClient as SCR
75+{-import qualified Servant.Common.Req as SCR-}
76+{-import qualified Servant.Client.HttpClient as SCR-}
6277import Servant.Server
6378import Servant.Server.Experimental.Auth
6479
6580-- This declaration simply checks that all instances are in place.
66−_ = client inClientM comprehensiveAPI
81+_ = client comprehensiveAPI
6782
6883spec :: Spec
6984spec = describe "Servant.Client" $ do
@@ -76,17 +91,16 @@ spec = describe "Servant.Client" $ do
7691
7792-- * test data types
7893
79−data Person = Person {
80− name :: String,
81− age :: Integer
82− }
83− deriving (Eq, Show, Generic)
94+data Person = Person
95+ { name :: String
96+ , age :: Integer
97+ } deriving (Eq, Show, Generic)
8498
8599instance ToJSON Person
86100instance FromJSON Person
87101
88−instance ToForm Person where
89−instance FromForm Person where
102+instance ToForm Person
103+instance FromForm Person
90104
91105alice :: Person
92106alice = Person "Alice" 42
@@ -117,22 +131,22 @@ type Api =
117131api :: Proxy Api
118132api = Proxy
119133
120−getGet :: SCR.ClientM Person
121−getDeleteEmpty :: SCR.ClientM NoContent
122−getCapture :: String -> SCR.ClientM Person
123−getCaptureAll :: [String] -> SCR.ClientM [Person]
124−getBody :: Person -> SCR.ClientM Person
125−getQueryParam :: Maybe String -> SCR.ClientM Person
126−getQueryParams :: [String] -> SCR.ClientM [Person]
127−getQueryFlag :: Bool -> SCR.ClientM Bool
134+getGet :: ClientM Person
135+getDeleteEmpty :: ClientM NoContent
136+getCapture :: String -> ClientM Person
137+getCaptureAll :: [String] -> ClientM [Person]
138+getBody :: Person -> ClientM Person
139+getQueryParam :: Maybe String -> ClientM Person
140+getQueryParams :: [String] -> ClientM [Person]
141+getQueryFlag :: Bool -> ClientM Bool
128142getRawSuccess :: HTTP.Method
129− -> SCR.ClientM (Int, BS.ByteString, MediaType, [HTTP.Header], C.Response BS.ByteString)
143+ -> ClientM Response
130144getRawFailure :: HTTP.Method
131− -> SCR.ClientM (Int, BS.ByteString, MediaType, [HTTP.Header], C.Response BS.ByteString)
145+ -> ClientM (Int, BS.ByteString, MediaType, [HTTP.Header], C.Response BS.ByteString)
132146getMultiple :: String -> Maybe Int -> Bool -> [(String, [Rational])]
133− -> SCR.ClientM (String, Maybe Int, Bool, [(String, [Rational])])
134−getRespHeaders :: SCR.ClientM (Headers TestHeaders Bool)
135−getDeleteContentType :: SCR.ClientM NoContent
147+ -> ClientM (String, Maybe Int, Bool, [(String, [Rational])])
148+getRespHeaders :: ClientM (Headers TestHeaders Bool)
149+getDeleteContentType :: ClientM NoContent
136150
137151getGet
138152 :<|> getDeleteEmpty
@@ -147,7 +161,7 @@ getGet
147161 :<|> getMultiple
148162 :<|> getRespHeaders
149163 :<|> getDeleteContentType
150− :<|> EmptyClient = client inClientM api
164+ :<|> EmptyClient = client api
151165
152166server :: Application
153167server = serve api (
@@ -162,8 +176,8 @@ server = serve api (
162176 Nothing -> throwError $ ServantErr 400 "missing parameter" "" [])
163177 :<|> (\ names -> return (zipWith Person names [0..]))
164178 :<|> return
165− :<|> (Tagged $ \ _request respond -> respond $ responseLBS HTTP.ok200 [] "rawSuccess")
166− :<|> (Tagged $ \ _request respond -> respond $ responseLBS HTTP.badRequest400 [] "rawFailure")
179+ :<|> (Tagged $ \ _request respond -> respond $ Wai.responseLBS HTTP.ok200 [] "rawSuccess")
180+ :<|> (Tagged $ \ _request respond -> respond $ Wai.responseLBS HTTP.badRequest400 [] "rawFailure")
167181 :<|> (\ a b c d -> return (a, b, c, d))
168182 :<|> (return $ addHeader 1729 $ addHeader "eg2" True)
169183 :<|> return NoContent
@@ -179,9 +193,9 @@ failApi = Proxy
179193
180194failServer :: Application
181195failServer = serve failApi (
182− (Tagged $ \ _request respond -> respond $ responseLBS HTTP.ok200 [] "")
183− :<|> (\ _capture -> Tagged $ \_request respond -> respond $ responseLBS HTTP.ok200 [("content-type", "application/json")] "")
184− :<|> (Tagged $ \_request respond -> respond $ responseLBS HTTP.ok200 [("content-type", "fooooo")] "")
196+ (Tagged $ \ _request respond -> respond $ Wai.responseLBS HTTP.ok200 [] "")
197+ :<|> (\ _capture -> Tagged $ \_request respond -> respond $ Wai.responseLBS HTTP.ok200 [("content-type", "application/json")] "")
198+ :<|> (Tagged $ \_request respond -> respond $ Wai.responseLBS HTTP.ok200 [("content-type", "fooooo")] "")
185199 )
186200
187201-- * basic auth stuff
@@ -237,7 +251,7 @@ type GenericClientAPI
237251 :<|> Capture "foo" String :> NestedAPI1
238252
239253data GenericClient = GenericClient
240− { getSqr :: Maybe Int -> SCR.ClientM Int
254+ { getSqr :: Maybe Int -> ClientM Int
241255 , mkNestedClient1 :: String -> NestedClient1
242256 } deriving Generic
243257instance SOP.Generic GenericClient
@@ -249,7 +263,7 @@ type NestedAPI1
249263
250264data NestedClient1 = NestedClient1
251265 { mkNestedClient2 :: Maybe Int -> NestedClient2
252− , idChar :: Maybe Char -> SCR.ClientM Char
266+ , idChar :: Maybe Char -> ClientM Char
253267 } deriving Generic
254268instance SOP.Generic NestedClient1
255269instance (Client ClientM NestedAPI1 ~ client) => ClientLike client NestedClient1
@@ -259,8 +273,8 @@ type NestedAPI2
259273 :<|> "void" :> Post '[JSON] ()
260274
261275data NestedClient2 = NestedClient2
262− { getSum :: Int -> Int -> SCR.ClientM Int
263− , doNothing :: SCR.ClientM ()
276+ { getSum :: Int -> Int -> ClientM Int
277+ , doNothing :: ClientM ()
264278 } deriving Generic
265279instance SOP.Generic NestedClient2
266280instance (Client ClientM NestedAPI2 ~ client) => ClientLike client NestedClient2
@@ -277,50 +291,52 @@ genericClientServer = serve (Proxy :: Proxy GenericClientAPI) (
277291 nestedServer1 _str = nestedServer2 :<|> (maybe (throwError $ ServantErr 400 "missing parameter" "" []) return)
278292 nestedServer2 _int = (\ x y -> return (x + y)) :<|> return ()
279293
280−{-# NOINLINE manager #-}
281−manager :: C.Manager
282−manager = unsafePerformIO $ C.newManager C.defaultManagerSettings
294+{-# NOINLINE manager' #-}
295+manager' :: C.Manager
296+manager' = unsafePerformIO $ C.newManager C.defaultManagerSettings
297+
298+runClient x = runClientM x (ClientEnv manager' baseUrl)
283299
284300sucessSpec :: Spec
285301sucessSpec = beforeAll (startWaiApp server) $ afterAll endWaiApp $ do
286302
287303 it "Servant.API.Get" $ \(_, baseUrl) -> do
288− (left show <$> (runClientM getGet (ClientEnv manager baseUrl))) `shouldReturn` Right alice
304+ (left show <$> runClient getGet) `shouldReturn` Right alice
289305
290306 describe "Servant.API.Delete" $ do
291307 it "allows empty content type" $ \(_, baseUrl) -> do
292− (left show <$> (runClientM getDeleteEmpty (ClientEnv manager baseUrl))) `shouldReturn` Right NoContent
308+ (left show <$> (runClient getDeleteEmpty)) `shouldReturn` Right NoContent
293309
294310 it "allows content type" $ \(_, baseUrl) -> do
295− (left show <$> (runClientM getDeleteContentType (ClientEnv manager baseUrl))) `shouldReturn` Right NoContent
311+ (left show <$> (runClient getDeleteContentType)) `shouldReturn` Right NoContent
296312
297313 it "Servant.API.Capture" $ \(_, baseUrl) -> do
298− (left show <$> (runClientM (getCapture "Paula") (ClientEnv manager baseUrl))) `shouldReturn` Right (Person "Paula" 0)
314+ (left show <$> (runClient (getCapture "Paula"))) `shouldReturn` Right (Person "Paula" 0)
299315
300316 it "Servant.API.CaptureAll" $ \(_, baseUrl) -> do
301317 let expected = [(Person "Paula" 0), (Person "Peta" 1)]
302− (left show <$> (runClientM (getCaptureAll ["Paula", "Peta"]) (ClientEnv manager baseUrl))) `shouldReturn` Right expected
318+ (left show <$> (runClient (getCaptureAll ["Paula", "Peta"]))) `shouldReturn` Right expected
303319
304320 it "Servant.API.ReqBody" $ \(_, baseUrl) -> do
305321 let p = Person "Clara" 42
306− (left show <$> runClientM (getBody p) (ClientEnv manager baseUrl)) `shouldReturn` Right p
322+ (left show <$> runClient (getBody p)) `shouldReturn` Right p
307323
308324 it "Servant.API.QueryParam" $ \(_, baseUrl) -> do
309− left show <$> runClientM (getQueryParam (Just "alice")) (ClientEnv manager baseUrl) `shouldReturn` Right alice
310− Left FailureResponse{..} <- runClientM (getQueryParam (Just "bob")) (ClientEnv manager baseUrl)
311− responseStatus `shouldBe` HTTP.Status 400 "bob not found"
325+ left show <$> runClient (getQueryParam (Just "alice")) `shouldReturn` Right alice
326+ Left (FailureResponse r) <- runClient (getQueryParam (Just "bob"))
327+ responseStatusCode r `shouldBe` HTTP.Status 400 "bob not found"
312328
313329 it "Servant.API.QueryParam.QueryParams" $ \(_, baseUrl) -> do
314− (left show <$> runClientM (getQueryParams []) (ClientEnv manager baseUrl)) `shouldReturn` Right []
315− (left show <$> runClientM (getQueryParams ["alice", "bob"]) (ClientEnv manager baseUrl))
330+ (left show <$> runClient (getQueryParams [])) `shouldReturn` Right []
331+ (left show <$> runClient (getQueryParams ["alice", "bob"]))
316332 `shouldReturn` Right [Person "alice" 0, Person "bob" 1]
317333
318334 context "Servant.API.QueryParam.QueryFlag" $
319335 forM_ [False, True] $ \ flag -> it (show flag) $ \(_, baseUrl) -> do
320− (left show <$> runClientM (getQueryFlag flag) (ClientEnv manager baseUrl)) `shouldReturn` Right flag
336+ (left show <$> runClient (getQueryFlag flag)) `shouldReturn` Right flag
321337
322338 it "Servant.API.Raw on success" $ \(_, baseUrl) -> do
323− res <- runClientM (getRawSuccess HTTP.methodGet) (ClientEnv manager baseUrl)
339+ res <- runClient (getRawSuccess HTTP.methodGet)
324340 case res of
325341 Left e -> assertFailure $ show e
326342 Right (code, body, ct, _, response) -> do
@@ -329,15 +345,16 @@ sucessSpec = beforeAll (startWaiApp server) $ afterAll endWaiApp $ do
329345 C.responseStatus response `shouldBe` HTTP.ok200
330346
331347 it "Servant.API.Raw should return a Left in case of failure" $ \(_, baseUrl) -> do
332− res <- runClientM (getRawFailure HTTP.methodGet) (ClientEnv manager baseUrl)
348+ res <- runClient (getRawFailure HTTP.methodGet)
333349 case res of
334350 Right _ -> assertFailure "expected Left, but got Right"
335− Left e -> do
336− Servant.Client.responseStatus e `shouldBe` HTTP.status400
337− Servant.Client.responseBody e `shouldBe` "rawFailure"
351+ Left (FailureResponse r) -> do
352+ responseStatusCode r `shouldBe` HTTP.status400
353+ responseBody r `shouldBe` "rawFailure"
354+ Left e -> assertFailure $ "expected FailureResponse, but got " ++ show e
338355
339356 it "Returns headers appropriately" $ \(_, baseUrl) -> do
340− res <- runClientM getRespHeaders (ClientEnv manager baseUrl)
357+ res <- runClient getRespHeaders
341358 case res of
342359 Left e -> assertFailure $ show e
343360 Right val -> getHeaders val `shouldBe` [("X-Example1", "1729"), ("X-Example2", "eg2")]
@@ -346,7 +363,7 @@ sucessSpec = beforeAll (startWaiApp server) $ afterAll endWaiApp $ do
346363 it "works for a combination of Capture, QueryParam, QueryFlag and ReqBody" $ \(_, baseUrl) ->
347364 property $ forAllShrink pathGen shrink $ \(NonEmpty cap) num flag body ->
348365 ioProperty $ do
349− result <- left show <$> runClientM (getMultiple cap num flag body) (ClientEnv manager baseUrl)
366+ result <- left show <$> runClient (getMultiple cap num flag body)
350367 return $
351368 result === Right (cap, num, flag, body)
352369
@@ -358,10 +375,10 @@ wrappedApiSpec = describe "error status codes" $ do
358375 let test :: (WrappedApi, String) -> Spec
359376 test (WrappedApi api, desc) =
360377 it desc $ bracket (startWaiApp $ serveW api) endWaiApp $ \(_, baseUrl) -> do
361− let getResponse :: SCR.ClientM ()
362− getResponse = client inClientM api
363− Left FailureResponse{..} <- runClientM getResponse (ClientEnv manager baseUrl)
364− responseStatus `shouldBe` (HTTP.Status 500 "error message")
378+ let getResponse :: ClientM ()
379+ getResponse = client api
380+ Left (FailureResponse r) <- runClient getResponse
381+ responseStatusCode r `shouldBe` (HTTP.Status 500 "error message")
365382 in mapM_ test $
366383 (WrappedApi (Proxy :: Proxy (Delete '[JSON] ())), "Delete") :
367384 (WrappedApi (Proxy :: Proxy (Get '[JSON] ())), "Get") :
@@ -374,43 +391,43 @@ failSpec = beforeAll (startWaiApp failServer) $ afterAll endWaiApp $ do
374391
375392 context "client returns errors appropriately" $ do
376393 it "reports FailureResponse" $ \(_, baseUrl) -> do
377− let (_ :<|> getDeleteEmpty :<|> _) = client inClientM api
378− Left res <- runClientM getDeleteEmpty (ClientEnv manager baseUrl)
394+ let (_ :<|> getDeleteEmpty :<|> _) = client api
395+ Left res <- runClient getDeleteEmpty
379396 case res of
380− FailureResponse _ (HTTP.Status 404 "Not Found") _ _ -> return ()
397+ FailureResponse r | responseStatusCode r == 404 -> return ()
381398 _ -> fail $ "expected 404 response, but got " <> show res
382399
383400 it "reports DecodeFailure" $ \(_, baseUrl) -> do
384− let (_ :<|> _ :<|> getCapture :<|> _) = client inClientM api
385− Left res <- runClientM (getCapture "foo") (ClientEnv manager baseUrl)
401+ let (_ :<|> _ :<|> getCapture :<|> _) = client api
402+ Left res <- runClient (getCapture "foo") (ClientEnv manager baseUrl)
386403 case res of
387− DecodeFailure _ ("application/json") _ -> return ()
404+ DecodeFailure _ _ -> return ()
388405 _ -> fail $ "expected DecodeFailure, but got " <> show res
389406
390407 it "reports ConnectionError" $ \_ -> do
391− let (getGetWrongHost :<|> _) = client inClientM api
408+ let (getGetWrongHost :<|> _) = client api
392409 Left res <- runClientM getGetWrongHost (ClientEnv manager (BaseUrl Http "127.0.0.1" 19872 ""))
393410 case res of
394411 ConnectionError _ -> return ()
395412 _ -> fail $ "expected ConnectionError, but got " <> show res
396413
397414 it "reports UnsupportedContentType" $ \(_, baseUrl) -> do
398− let (getGet :<|> _ ) = client inClientM api
399− Left res <- runClientM getGet (ClientEnv manager baseUrl)
415+ let (getGet :<|> _ ) = client api
416+ Left res <- runClient getGet
400417 case res of
401418 UnsupportedContentType ("application/octet-stream") _ -> return ()
402419 _ -> fail $ "expected UnsupportedContentType, but got " <> show res
403420
404421 it "reports InvalidContentTypeHeader" $ \(_, baseUrl) -> do
405− let (_ :<|> _ :<|> _ :<|> _ :<|> getBody :<|> _) = client inClientM api
406− Left res <- runClientM (getBody alice) (ClientEnv manager baseUrl)
422+ let (_ :<|> _ :<|> _ :<|> _ :<|> getBody :<|> _) = client api
423+ Left res <- runClient (getBody alice)
407424 case res of
408− InvalidContentTypeHeader "fooooo" _ -> return ()
425+ InvalidContentTypeHeader _ -> return ()
409426 _ -> fail $ "expected InvalidContentTypeHeader, but got " <> show res
410427
411428data WrappedApi where
412429 WrappedApi :: (HasServer (api :: *) '[], Server api ~ Handler a,
413− HasClient ClientM api, Client ClientM api ~ SCR.ClientM ()) =>
430+ HasClient ClientM api, Client ClientM api ~ ClientM ()) =>
414431 Proxy api -> WrappedApi
415432
416433basicAuthSpec :: Spec
@@ -418,50 +435,50 @@ basicAuthSpec = beforeAll (startWaiApp basicAuthServer) $ afterAll endWaiApp $ d
418435 context "Authentication works when requests are properly authenticated" $ do
419436
420437 it "Authenticates a BasicAuth protected server appropriately" $ \(_,baseUrl) -> do
421− let getBasic = client inClientM basicAuthAPI
438+ let getBasic = client basicAuthAPI
422439 let basicAuthData = BasicAuthData "servant" "server"
423− (left show <$> runClientM (getBasic basicAuthData) (ClientEnv manager baseUrl)) `shouldReturn` Right alice
440+ (left show <$> runClient (getBasic basicAuthData)) `shouldReturn` Right alice
424441
425442 context "Authentication is rejected when requests are not authenticated properly" $ do
426443
427444 it "Authenticates a BasicAuth protected server appropriately" $ \(_,baseUrl) -> do
428− let getBasic = client inClientM basicAuthAPI
445+ let getBasic = client basicAuthAPI
429446 let basicAuthData = BasicAuthData "not" "password"
430− Left FailureResponse{..} <- runClientM (getBasic basicAuthData) (ClientEnv manager baseUrl)
431− responseStatus `shouldBe` HTTP.Status 403 "Forbidden"
447+ Left (FailureResponse r) <- runClient (getBasic basicAuthData)
448+ responseStatusCode r `shouldBe` HTTP.Status 403 "Forbidden"
432449
433450genAuthSpec :: Spec
434451genAuthSpec = beforeAll (startWaiApp genAuthServer) $ afterAll endWaiApp $ do
435452 context "Authentication works when requests are properly authenticated" $ do
436453
437454 it "Authenticates a AuthProtect protected server appropriately" $ \(_, baseUrl) -> do
438− let getProtected = client inClientM genAuthAPI
439− let authRequest = mkAuthenticateReq () (\_ req -> SCR.addHeader "AuthHeader" ("cool" :: String) req)
440− (left show <$> runClientM (getProtected authRequest) (ClientEnv manager baseUrl)) `shouldReturn` Right alice
455+ let getProtected = client genAuthAPI
456+ let authRequest = mkAuthenticateReq () (\_ req -> addHeader "AuthHeader" ("cool" :: String) req)
457+ (left show <$> runClient (getProtected authRequest) ) `shouldReturn` Right alice
441458
442459 context "Authentication is rejected when requests are not authenticated properly" $ do
443460
444461 it "Authenticates a AuthProtect protected server appropriately" $ \(_, baseUrl) -> do
445− let getProtected = client inClientM genAuthAPI
446− let authRequest = mkAuthenticateReq () (\_ req -> SCR.addHeader "Wrong" ("header" :: String) req)
447− Left FailureResponse{..} <- runClientM (getProtected authRequest) (ClientEnv manager baseUrl)
448− responseStatus `shouldBe` (HTTP.Status 401 "Unauthorized")
462+ let getProtected = client genAuthAPI
463+ let authRequest = mkAuthenticateReq () (\_ req -> addHeader "Wrong" ("header" :: String) req)
464+ Left (FailureResponse r) <- runClient (getProtected authRequest)
465+ responseStatusCode r `shouldBe` (HTTP.Status 401 "Unauthorized")
449466
450467genericClientSpec :: Spec
451468genericClientSpec = beforeAll (startWaiApp genericClientServer) $ afterAll endWaiApp $ do
452469 describe "Servant.Client.Generic" $ do
453470
454− let GenericClient{..} = mkClient (client inClientM (Proxy :: Proxy GenericClientAPI))
471+ let GenericClient{..} = mkClient (client (Proxy :: Proxy GenericClientAPI))
455472 NestedClient1{..} = mkNestedClient1 "example"
456473 NestedClient2{..} = mkNestedClient2 (Just 42)
457474
458475 it "works for top-level client inClientM function" $ \(_, baseUrl) -> do
459− (left show <$> (runClientM (getSqr (Just 5)) (ClientEnv manager baseUrl))) `shouldReturn` Right 25
476+ (left show <$> (runClient (getSqr (Just 5)))) `shouldReturn` Right 25
460477
461478 it "works for nested clients" $ \(_, baseUrl) -> do
462− (left show <$> (runClientM (idChar (Just 'c')) (ClientEnv manager baseUrl))) `shouldReturn` Right 'c'
463− (left show <$> (runClientM (getSum 3 4) (ClientEnv manager baseUrl))) `shouldReturn` Right 7
464− (left show <$> (runClientM doNothing (ClientEnv manager baseUrl))) `shouldReturn` Right ()
479+ (left show <$> (runClient (idChar (Just 'c')))) `shouldReturn` Right 'c'
480+ (left show <$> (runClient (getSum 3 4))) `shouldReturn` Right 7
481+ (left show <$> (runClient doNothing )) `shouldReturn` Right ()
465482
466483-- * utils
467484