package httptest

Import Path
	net/http/httptest (on go.dev)

Dependency Relation
	imports 19 packages, and imported by 0 packages


Involved Source Files

	
		Package httptest provides utilities for HTTP testing.

	    recorder.go
	    server.go


Code Examples

	
		package main
		
		import (
			"fmt"
			"io"
			"log"
			"net/http"
			"net/http/httptest"
		)
		
		func main() {
			ts := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				fmt.Fprintln(w, "Hello, client")
			}))
			defer ts.Close()
		
			client := ts.Client()
			res, err := client.Get(ts.URL)
			if err != nil {
				log.Fatal(err)
			}
		
			greeting, err := io.ReadAll(res.Body)
			res.Body.Close()
			if err != nil {
				log.Fatal(err)
			}
		
			fmt.Printf("%s", greeting)
		}

	
		package main
		
		import (
			"fmt"
			"io"
			"net/http"
			"net/http/httptest"
		)
		
		func main() {
			handler := func(w http.ResponseWriter, r *http.Request) {
				io.WriteString(w, "<html><body>Hello World!</body></html>")
			}
		
			req := httptest.NewRequest("GET", "http://example.com/foo", nil)
			w := httptest.NewRecorder()
			handler(w, req)
		
			resp := w.Result()
			body, _ := io.ReadAll(resp.Body)
		
			fmt.Println(resp.StatusCode)
			fmt.Println(resp.Header.Get("Content-Type"))
			fmt.Println(string(body))
		
		}

	
		package main
		
		import (
			"fmt"
			"io"
			"log"
			"net/http"
			"net/http/httptest"
		)
		
		func main() {
			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				fmt.Fprintln(w, "Hello, client")
			}))
			defer ts.Close()
		
			res, err := http.Get(ts.URL)
			if err != nil {
				log.Fatal(err)
			}
			greeting, err := io.ReadAll(res.Body)
			res.Body.Close()
			if err != nil {
				log.Fatal(err)
			}
		
			fmt.Printf("%s", greeting)
		}

	
		package main
		
		import (
			"fmt"
			"io"
			"log"
			"net/http"
			"net/http/httptest"
		)
		
		func main() {
			ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				fmt.Fprintf(w, "Hello, %s", r.Proto)
			}))
			ts.EnableHTTP2 = true
			ts.StartTLS()
			defer ts.Close()
		
			res, err := ts.Client().Get(ts.URL)
			if err != nil {
				log.Fatal(err)
			}
			greeting, err := io.ReadAll(res.Body)
			res.Body.Close()
			if err != nil {
				log.Fatal(err)
			}
			fmt.Printf("%s", greeting)
		
		}




Package-Level Type Names (total 2)


	/* sort by:  |  */
	
		ResponseRecorder is an implementation of [http.ResponseWriter] that
		records its mutations for later inspection in tests.

		
			
				Body is the buffer to which the Handler's Write calls are sent.
				If nil, the Writes are silently discarded.

			
				Code is the HTTP response code set by WriteHeader.
				
				Note that if a Handler never calls WriteHeader or Write,
				this might end up being 0, rather than the implicit
				http.StatusOK. To get the implicit value, use the Result
				method.

			
				Flushed is whether the Handler called Flush.

			
				HeaderMap contains the headers explicitly set by the Handler.
				It is an internal detail.
				
				Deprecated: HeaderMap exists for historical compatibility
				and should not be used. To access the headers returned by a handler,
				use the Response.Header map as returned by the Result method.

		
			
				Flush implements [http.Flusher]. To test whether Flush was
				called, see rw.Flushed.

			
				Header implements [http.ResponseWriter]. It returns the response
				headers to mutate within a handler. To test the headers that were
				written after a handler completes, use the [ResponseRecorder.Result] method and see
				the returned Response value's Header.

			
				Result returns the response generated by the handler.
				
				The returned Response will have at least its StatusCode,
				Header, Body, and optionally Trailer populated.
				More fields may be populated in the future, so callers should
				not DeepEqual the result in tests.
				
				The Response.Header is a snapshot of the headers at the time of the
				first write call, or at the time of this call, if the handler never
				did a write.
				
				The Response.Body is guaranteed to be non-nil and Body.Read call is
				guaranteed to not return any error other than [io.EOF].
				
				Result must only be called after the handler has finished running.

			
				Write implements http.ResponseWriter. The data in buf is written to
				rw.Body, if not nil.

			
				WriteHeader implements [http.ResponseWriter].

			
				WriteString implements [io.StringWriter]. The data in str is written
				to rw.Body, if not nil.

		
			*ResponseRecorder : net/http.Flusher
			*ResponseRecorder : net/http.ResponseWriter
			*ResponseRecorder : internal/bisect.Writer
			*ResponseRecorder : io.StringWriter
			*ResponseRecorder : io.Writer
		
			func NewRecorder() *ResponseRecorder


	
		A Server is an HTTP server listening on a system-chosen port on the
		local loopback interface, for use in end-to-end HTTP tests.

		
			
				Config may be changed after calling NewUnstartedServer and
				before Start or StartTLS.

			
				EnableHTTP2 controls whether HTTP/2 is enabled
				on the server. It must be set between calling
				NewUnstartedServer and calling Server.StartTLS.

			Listener net.Listener
			
				TLS is the optional TLS configuration, populated with a new config
				after TLS is started. If set on an unstarted server before StartTLS
				is called, existing fields are copied into the new config.

			
				// base URL of form http://ipaddr:port with no trailing slash

		
			
				Certificate returns the certificate used by the server, or nil if
				the server doesn't use TLS.

			
				Client returns an HTTP client configured for making requests to the server.
				It is configured to trust the server's TLS test certificate and will
				close its idle connections on [Server.Close].
				Use Server.URL as the base URL to send requests to the server.

			
				Close shuts down the server and blocks until all outstanding
				requests on this server have completed.

			
				CloseClientConnections closes any open HTTP connections to the test Server.

			
				Start starts a server from NewUnstartedServer.

			
				StartTLS starts TLS on a server from NewUnstartedServer.

		
			func NewServer(handler http.Handler) *Server
			func NewTLSServer(handler http.Handler) *Server
			func NewUnstartedServer(handler http.Handler) *Server




Package-Level Functions (total 6)


	
		NewRecorder returns an initialized [ResponseRecorder].


	
		NewRequest wraps NewRequestWithContext using context.Background.


	
		NewRequestWithContext returns a new incoming server Request, suitable
		for passing to an [http.Handler] for testing.
		
		The target is the RFC 7230 "request-target": it may be either a
		path or an absolute URL. If target is an absolute URL, the host name
		from the URL is used. Otherwise, "example.com" is used.
		
		The TLS field is set to a non-nil dummy value if target has scheme
		"https".
		
		The Request.Proto is always HTTP/1.1.
		
		An empty method means "GET".
		
		The provided body may be nil. If the body is of type *bytes.Reader,
		*strings.Reader, or *bytes.Buffer, the Request.ContentLength is
		set.
		
		NewRequest panics on error for ease of use in testing, where a
		panic is acceptable.
		
		To generate a client HTTP request instead of a server request, see
		the NewRequest function in the net/http package.


	
		NewServer starts and returns a new [Server].
		The caller should call Close when finished, to shut it down.


	
		NewTLSServer starts and returns a new [Server] using TLS.
		The caller should call Close when finished, to shut it down.


	
		NewUnstartedServer returns a new [Server] but doesn't start it.
		
		After changing its configuration, the caller should call Start or
		StartTLS.
		
		The caller should call Close when finished, to shut it down.




Package-Level Constants (only one)


	
		DefaultRemoteAddr is the default remote address to return in RemoteAddr if
		an explicit DefaultRemoteAddr isn't set on [ResponseRecorder].