11package httptest
22
33import (
4+ "bytes"
45 "errors"
56 "fmt"
7+ "io"
68 "net"
79 "net/http"
8- "regexp "
10+ "net/url "
911 "sync"
12+
13+ "github.com/gin-gonic/gin"
1014)
1115
1216// Server is a mock http server for testing.
1317type Server struct {
1418 httpServer * http.Server
15- // calls store map[method][path]count
16- calls map [string ]map [string ]int
19+ engine * gin.Engine
20+ // nCalls store map[method][path]count
21+ nCalls map [string ]map [string ]int
1722 // routes store map[method][path]handler
1823 routes map [string ]map [string ]ServerHandlerFunc
24+ calls map [string ]map [string ][]RequestMade
1925
2026 mu sync.Mutex
2127}
@@ -25,6 +31,13 @@ type Request struct {
2531 Params Params
2632}
2733
34+ type RequestMade struct {
35+ Body []byte
36+ Headers http.Header
37+ Query url.Values
38+ Params map [string ]string
39+ }
40+
2841// ServerHandlerFunc is the interface of the handler function.
2942type ServerHandlerFunc func (w ResponseWriter , r * Request )
3043
@@ -35,20 +48,28 @@ type ServerConfig struct {
3548// NewServer creates and starts new http test server.
3649// address is the address to listen on, e.g. "localhost:3001".
3750func NewServer (address string , config ServerConfig ) (* Server , error ) {
51+ // Set gin to release mode to avoid unnecessary logs.
52+ gin .SetMode (gin .ReleaseMode )
53+
54+ // Start listener first to make sure the address is available.
3855 l , err := net .Listen ("tcp" , address )
3956 if err != nil {
40- panic ( err )
57+ return nil , fmt . Errorf ( "net.Listen: %w" , err )
4158 }
4259
60+ r := gin .Default ()
61+
4362 httpServer := & http.Server {
4463 Addr : address ,
45- Handler : http . NewServeMux (),
64+ Handler : r . Handler (),
4665 }
4766
4867 server := & Server {
68+ engine : r ,
4969 httpServer : httpServer ,
50- calls : map [string ]map [string ]int {},
70+ nCalls : map [string ]map [string ]int {},
5171 routes : map [string ]map [string ]ServerHandlerFunc {},
72+ calls : map [string ]map [string ][]RequestMade {},
5273 }
5374
5475 go func () {
@@ -65,24 +86,43 @@ func (s *Server) Close() error {
6586 return s .httpServer .Close ()
6687}
6788
68- // GetNCalls returns the number of calls for a path.
89+ // GetNCalls returns the number of nCalls for a path.
6990func (s * Server ) GetNCalls (method , path string ) int {
70- calls , ok := s.calls [method ][path ]
91+ calls , ok := s.nCalls [method ][path ]
7192 if ! ok {
7293 return 0
7394 }
7495
7596 return calls
7697}
7798
78- // ResetNCalls resets the number of calls for all paths.
99+ // ResetNCalls resets the number of nCalls for all paths.
79100func (s * Server ) ResetNCalls () {
80101 s .mu .Lock ()
81102 defer s .mu .Unlock ()
82103
104+ for path := range s .nCalls {
105+ for method := range s .nCalls [path ] {
106+ s.nCalls [path ][method ] = 0
107+ }
108+ }
109+ }
110+
111+ // GetCalls returns the calls for a path.
112+ func (s * Server ) GetCalls (method , path string ) []RequestMade {
113+ return s.calls [method ][path ]
114+ }
115+
116+ // ResetCalls resets the calls & nCalls for all paths.
117+ // It does not reset the handlers.
118+ func (s * Server ) ResetCalls () {
119+ s .mu .Lock ()
120+ defer s .mu .Unlock ()
121+
122+ s .ResetNCalls ()
83123 for path := range s .calls {
84124 for method := range s .calls [path ] {
85- s.calls [path ][method ] = 0
125+ s.calls [path ][method ] = [] RequestMade {}
86126 }
87127 }
88128}
@@ -93,69 +133,92 @@ func (s *Server) RegisterHandler(method string, path string, handler ServerHandl
93133 s .mu .Lock ()
94134 defer s .mu .Unlock ()
95135
96- if s .calls [method ] == nil {
97- s .calls [method ] = map [string ]int {}
136+ if s .nCalls [method ] == nil {
137+ s .nCalls [method ] = map [string ]int {}
98138 }
99139 if s .routes [method ] == nil {
100140 s .routes [method ] = map [string ]ServerHandlerFunc {}
101141 }
142+ if s .calls [method ] == nil {
143+ s .calls [method ] = map [string ][]RequestMade {}
144+ }
102145
103146 if s .routes [method ] != nil && s.routes [method ][path ] != nil {
104147 // Regenerate the handler and re-register all handlers.
105- serveMux := http . NewServeMux ()
148+ s . engine = gin . Default ()
106149 for m , p := range s .routes {
107150 for k , v := range p {
151+ // Skip same one, we'll register it below.
108152 if m == method && k == path {
109153 continue
110154 }
111- serveMux .HandleFunc (k , func (w http.ResponseWriter , r * http.Request ) {
112- s .IncrNCalls (m , k )
113- v (ResponseWriter {w : w }, & Request {Request : r , Params : Params {request : r }})
155+ s .engine .Handle (m , k , func (c * gin.Context ) {
156+ s .incrNCalls (m , k )
157+ s .storeCall (m , k , c )
158+ v (ResponseWriter {w : c .Writer }, & Request {Request : c .Request , Params : Params {ginContext : c }})
114159 })
115160 }
116161 }
117- s .httpServer .Handler = serveMux
162+ s .httpServer .Handler = s . engine . Handler ()
118163 }
119164 s.routes [method ][path ] = handler
120165
121- serveMux := s . httpServer . Handler .( * http. ServeMux )
122- serveMux . HandleFunc ( s . combinePath (method , path ), func ( w http. ResponseWriter , r * http. Request ) {
123- s .IncrNCalls (method , path )
124- handler (ResponseWriter {w : w }, & Request {Request : r , Params : Params {request : r }})
166+ s . engine . Handle ( method , path , func ( c * gin. Context ) {
167+ s . incrNCalls (method , path )
168+ s .storeCall (method , path , c )
169+ handler (ResponseWriter {w : c . Writer }, & Request {Request : c . Request , Params : Params {ginContext : c }})
125170 })
126171
127- s .httpServer .Handler = serveMux
172+ s .httpServer .Handler = s . engine . Handler ()
128173}
129174
130- // IncrNCalls increments the number of calls for a path.
131- func (s * Server ) IncrNCalls (method , path string ) {
175+ // incrNCalls increments the number of nCalls for a path.
176+ func (s * Server ) incrNCalls (method , path string ) {
132177 s .mu .Lock ()
133178 defer s .mu .Unlock ()
134179
135- s.calls [method ][path ]++
180+ s.nCalls [method ][path ]++
136181}
137182
138- // ResetAll resets all the calls and handlers .
139- func (s * Server ) ResetAll ( ) {
183+ // storeCall stores the call for a path .
184+ func (s * Server ) storeCall ( method , path string , c * gin. Context ) {
140185 s .mu .Lock ()
141186 defer s .mu .Unlock ()
142187
143- s .httpServer .Handler = http .NewServeMux ()
144- s .calls = map [string ]map [string ]int {}
145- s .routes = map [string ]map [string ]ServerHandlerFunc {}
188+ // If body is not empty, read it into byte.
189+ var body []byte
190+ if c .Request .Body != nil {
191+ body , _ = io .ReadAll (c .Request .Body )
192+ // Restore the body.
193+ c .Request .Body = io .NopCloser (bytes .NewBuffer (body ))
194+ }
195+
196+ s.calls [method ][path ] = append (s.calls [method ][path ], RequestMade {
197+ Body : body ,
198+ Headers : c .Request .Header ,
199+ Query : c .Request .URL .Query (),
200+ Params : s .getAllParams (c ),
201+ })
146202}
147203
148- // combinePath combines method and path & converts the path.
149- // Example: combinePath(GET, /path/:param) -> GET /path/{param}
150- func (s * Server ) combinePath (method , path string ) string {
151- return fmt .Sprintf ("%s %s" , method , s .convertPathParams (path ))
204+ func (s * Server ) getAllParams (c * gin.Context ) map [string ]string {
205+ params := make (map [string ]string )
206+
207+ for _ , param := range c .Params {
208+ params [param .Key ] = param .Value
209+ }
210+
211+ return params
152212}
153213
154- // convertPathParams converts from "/path/:param" to "/path/{param}" to comply with the standard library.
155- func (s * Server ) convertPathParams (input string ) string {
156- pattern := `:([^/]+)`
157- re := regexp .MustCompile (pattern )
158- converted := re .ReplaceAllString (input , "{$1}" )
214+ // ResetAll resets all the nCalls, handlers, and calls.
215+ func (s * Server ) ResetAll () {
216+ s .mu .Lock ()
217+ defer s .mu .Unlock ()
159218
160- return converted
219+ s .engine = gin .Default ()
220+ s .httpServer .Handler = s .engine .Handler ()
221+ s .nCalls = map [string ]map [string ]int {}
222+ s .routes = map [string ]map [string ]ServerHandlerFunc {}
223+ s .calls = map [string ]map [string ][]RequestMade {}
161224}
0 commit comments