1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
|
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveDataTypeable #-}
module Network.Wai.Test
( -- * Session
Session
, runSession
-- * Requests
, request
, srequest
, SRequest (..)
, SResponse (..)
, defaultRequest
, setPath
, setRawPathInfo
-- * Assertions
, assertStatus
, assertContentType
, assertBody
, assertBodyContains
, assertHeader
, assertNoHeader
, WaiTestFailure (..)
) where
import Network.Wai
import Network.Wai.Internal (ResponseReceived (ResponseReceived))
import Control.Monad.IO.Class (liftIO)
import Control.Monad.Trans.State (StateT, evalStateT)
import Control.Monad.Trans.Reader (ReaderT, runReaderT, ask)
import Control.Monad (unless)
import Control.DeepSeq (deepseq)
import Control.Exception (throwIO, Exception)
import Data.Typeable (Typeable)
import Data.Map (Map)
import qualified Data.Map as Map
import Data.ByteString (ByteString)
import qualified Data.ByteString.Char8 as S8
import Blaze.ByteString.Builder (toLazyByteString)
import qualified Blaze.ByteString.Builder as B
import qualified Data.ByteString.Lazy as L
import qualified Data.ByteString.Lazy.Char8 as L8
import qualified Network.HTTP.Types as H
import Data.CaseInsensitive (CI)
import qualified Data.ByteString as S
import qualified Data.Text as T
import qualified Data.Text.Encoding as TE
import Data.IORef
import Data.Monoid (mempty, mappend)
type Session = ReaderT Application (StateT ClientState IO)
data ClientState = ClientState
{ _clientCookies :: Map ByteString ByteString
}
initState :: ClientState
initState = ClientState Map.empty
runSession :: Session a -> Application -> IO a
runSession session app = evalStateT (runReaderT session app) initState
data SRequest = SRequest
{ simpleRequest :: Request
, simpleRequestBody :: L.ByteString
}
data SResponse = SResponse
{ simpleStatus :: H.Status
, simpleHeaders :: H.ResponseHeaders
, simpleBody :: L.ByteString
}
deriving (Show, Eq)
request :: Request -> Session SResponse
request = srequest . flip SRequest L.empty
-- | Set whole path (request path + query string).
setPath :: Request -> S8.ByteString -> Request
setPath req path = req {
pathInfo = segments
, rawPathInfo = B.toByteString (H.encodePathSegments segments)
, queryString = query
, rawQueryString = (H.renderQuery True query)
}
where
(segments, query) = H.decodePath path
setRawPathInfo :: Request -> S8.ByteString -> Request
setRawPathInfo r rawPinfo =
let pInfo = dropFrontSlash $ T.split (== '/') $ TE.decodeUtf8 rawPinfo
in r { rawPathInfo = rawPinfo, pathInfo = pInfo }
where
dropFrontSlash ("":"":[]) = [] -- homepage, a single slash
dropFrontSlash ("":path) = path
dropFrontSlash path = path
srequest :: SRequest -> Session SResponse
srequest (SRequest req bod) = do
app <- ask
refChunks <- liftIO $ newIORef $ L.toChunks bod
let req' = req
{ requestBody = atomicModifyIORef refChunks $ \bss ->
case bss of
[] -> ([], S.empty)
x:y -> (y, x)
}
liftIO $ do
ref <- newIORef $ error "runResponse gave no result"
ResponseReceived <- app req' (runResponse ref)
readIORef ref
-- FIXME cookie processing
--return sres
runResponse :: IORef SResponse -> Response -> IO ResponseReceived
runResponse ref res = do
refBuilder <- newIORef mempty
let add y = atomicModifyIORef refBuilder $ \x -> (x `mappend` y, ())
withBody $ \body -> body add (return ())
builder <- readIORef refBuilder
let lbs = toLazyByteString builder
len = L.length lbs
-- Force evaluation of the body to have exceptions thrown at the right
-- time.
seq len $ writeIORef ref $ SResponse s h $ toLazyByteString builder
return ResponseReceived
where
(s, h, withBody) = responseToStream res
assertBool :: String -> Bool -> Session ()
assertBool s b = unless b $ assertFailure s
assertString :: String -> Session ()
assertString s = unless (null s) $ assertFailure s
assertFailure :: String -> Session ()
assertFailure msg = msg `deepseq` liftIO (throwIO (WaiTestFailure msg))
data WaiTestFailure = WaiTestFailure String
deriving (Show, Eq, Typeable)
instance Exception WaiTestFailure
assertContentType :: ByteString -> SResponse -> Session ()
assertContentType ct SResponse{simpleHeaders = h} =
case lookup "content-type" h of
Nothing -> assertString $ concat
[ "Expected content type "
, show ct
, ", but no content type provided"
]
Just ct' -> assertBool (concat
[ "Expected content type "
, show ct
, ", but received "
, show ct'
]) (go ct == go ct')
where
go = S8.takeWhile (/= ';')
assertStatus :: Int -> SResponse -> Session ()
assertStatus i SResponse{simpleStatus = s} = assertBool (concat
[ "Expected status code "
, show i
, ", but received "
, show sc
]) $ i == sc
where
sc = H.statusCode s
assertBody :: L.ByteString -> SResponse -> Session ()
assertBody lbs SResponse{simpleBody = lbs'} = assertBool (concat
[ "Expected response body "
, show $ L8.unpack lbs
, ", but received "
, show $ L8.unpack lbs'
]) $ lbs == lbs'
assertBodyContains :: L.ByteString -> SResponse -> Session ()
assertBodyContains lbs SResponse{simpleBody = lbs'} = assertBool (concat
[ "Expected response body to contain "
, show $ L8.unpack lbs
, ", but received "
, show $ L8.unpack lbs'
]) $ strict lbs `S.isInfixOf` strict lbs'
where
strict = S.concat . L.toChunks
assertHeader :: CI ByteString -> ByteString -> SResponse -> Session ()
assertHeader header value SResponse{simpleHeaders = h} =
case lookup header h of
Nothing -> assertString $ concat
[ "Expected header "
, show header
, " to be "
, show value
, ", but it was not present"
]
Just value' -> assertBool (concat
[ "Expected header "
, show header
, " to be "
, show value
, ", but received "
, show value'
]) (value == value')
assertNoHeader :: CI ByteString -> SResponse -> Session ()
assertNoHeader header SResponse{simpleHeaders = h} =
case lookup header h of
Nothing -> return ()
Just s -> assertString $ concat
[ "Unexpected header "
, show header
, " containing "
, show s
]
|
