gin/gin_integration_test.go

// Copyright 2017 Manu Martinez-Almeida.  All rights reserved.
// Use of this source code is governed by a MIT style
// license that can be found in the LICENSE file.

package gin

import (
	"bufio"
	"crypto/tls"
	"fmt"
	"html/template"
	"io/ioutil"
	"net"
	"net/http"
	"net/http/httptest"
	"os"
	"sync"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
)

func testRequest(t *testing.T, url string) {
	tr := &http.Transport{
		TLSClientConfig: &tls.Config{
			InsecureSkipVerify: true,
		},
	}
	client := &http.Client{Transport: tr}

	resp, err := client.Get(url)
	assert.NoError(t, err)
	defer resp.Body.Close()

	body, ioerr := ioutil.ReadAll(resp.Body)
	assert.NoError(t, ioerr)
	assert.Equal(t, "it worked", string(body), "resp body should match")
	assert.Equal(t, "200 OK", resp.Status, "should get a 200")
}

func TestRunEmpty(t *testing.T) {
	os.Setenv("PORT", "")
	router := New()
	go func() {
		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
		assert.NoError(t, router.Run())
	}()
	// have to wait for the goroutine to start and run the server
	// otherwise the main thread will complete
	time.Sleep(5 * time.Millisecond)

	assert.Error(t, router.Run(":8080"))
	testRequest(t, "http://localhost:8080/example")
}

func TestRunTLS(t *testing.T) {
	router := New()
	go func() {
		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })

		assert.NoError(t, router.RunTLS(":8443", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))
	}()

	// have to wait for the goroutine to start and run the server
	// otherwise the main thread will complete
	time.Sleep(5 * time.Millisecond)

	assert.Error(t, router.RunTLS(":8443", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))
	testRequest(t, "https://localhost:8443/example")
}

func TestPusher(t *testing.T) {
	var html = template.Must(template.New("https").Parse(`
<html>
<head>
  <title>Https Test</title>
  <script src="/assets/app.js"></script>
</head>
<body>
  <h1 style="color:red;">Welcome, Ginner!</h1>
</body>
</html>
`))

	router := New()
	router.Static("./assets", "./assets")
	router.SetHTMLTemplate(html)

	go func() {
		router.GET("/pusher", func(c *Context) {
			if pusher := c.Writer.Pusher(); pusher != nil {
				pusher.Push("/assets/app.js", nil)
			}
			c.String(http.StatusOK, "it worked")
		})

		assert.NoError(t, router.RunTLS(":8449", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))
	}()

	// have to wait for the goroutine to start and run the server
	// otherwise the main thread will complete
	time.Sleep(5 * time.Millisecond)

	assert.Error(t, router.RunTLS(":8449", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))
	testRequest(t, "https://localhost:8449/pusher")
}

func TestRunEmptyWithEnv(t *testing.T) {
	os.Setenv("PORT", "3123")
	router := New()
	go func() {
		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
		assert.NoError(t, router.Run())
	}()
	// have to wait for the goroutine to start and run the server
	// otherwise the main thread will complete
	time.Sleep(5 * time.Millisecond)

	assert.Error(t, router.Run(":3123"))
	testRequest(t, "http://localhost:3123/example")
}

func TestRunTooMuchParams(t *testing.T) {
	router := New()
	assert.Panics(t, func() {
		assert.NoError(t, router.Run("2", "2"))
	})
}

func TestRunWithPort(t *testing.T) {
	router := New()
	go func() {
		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
		assert.NoError(t, router.Run(":5150"))
	}()
	// have to wait for the goroutine to start and run the server
	// otherwise the main thread will complete
	time.Sleep(5 * time.Millisecond)

	assert.Error(t, router.Run(":5150"))
	testRequest(t, "http://localhost:5150/example")
}

func TestUnixSocket(t *testing.T) {
	router := New()

	go func() {
		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
		assert.NoError(t, router.RunUnix("/tmp/unix_unit_test"))
	}()
	// have to wait for the goroutine to start and run the server
	// otherwise the main thread will complete
	time.Sleep(5 * time.Millisecond)

	c, err := net.Dial("unix", "/tmp/unix_unit_test")
	assert.NoError(t, err)

	fmt.Fprint(c, "GET /example HTTP/1.0\r\n\r\n")
	scanner := bufio.NewScanner(c)
	var response string
	for scanner.Scan() {
		response += scanner.Text()
	}
	assert.Contains(t, response, "HTTP/1.0 200", "should get a 200")
	assert.Contains(t, response, "it worked", "resp body should match")
}

func TestBadUnixSocket(t *testing.T) {
	router := New()
	assert.Error(t, router.RunUnix("#/tmp/unix_unit_test"))
}

func TestFileDescriptor(t *testing.T) {
	router := New()

	addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
	assert.NoError(t, err)
	listener, err := net.ListenTCP("tcp", addr)
	assert.NoError(t, err)
	socketFile, err := listener.File()
	assert.NoError(t, err)

	go func() {
		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
		assert.NoError(t, router.RunFd(int(socketFile.Fd())))
	}()
	// have to wait for the goroutine to start and run the server
	// otherwise the main thread will complete
	time.Sleep(5 * time.Millisecond)

	c, err := net.Dial("tcp", listener.Addr().String())
	assert.NoError(t, err)

	fmt.Fprintf(c, "GET /example HTTP/1.0\r\n\r\n")
	scanner := bufio.NewScanner(c)
	var response string
	for scanner.Scan() {
		response += scanner.Text()
	}
	assert.Contains(t, response, "HTTP/1.0 200", "should get a 200")
	assert.Contains(t, response, "it worked", "resp body should match")
}

func TestBadFileDescriptor(t *testing.T) {
	router := New()
	assert.Error(t, router.RunFd(0))
}

func TestWithHttptestWithAutoSelectedPort(t *testing.T) {
	router := New()
	router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })

	ts := httptest.NewServer(router)
	defer ts.Close()

	testRequest(t, ts.URL+"/example")
}

func TestConcurrentHandleContext(t *testing.T) {
	router := New()
	router.GET("/", func(c *Context) {
		c.Request.URL.Path = "/example"
		router.HandleContext(c)
	})
	router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })

	var wg sync.WaitGroup
	iterations := 200
	wg.Add(iterations)
	for i := 0; i < iterations; i++ {
		go func() {
			testGetRequestHandler(t, router, "/")
			wg.Done()
		}()
	}
	wg.Wait()
}

// func TestWithHttptestWithSpecifiedPort(t *testing.T) {
// 	router := New()
// 	router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })

// 	l, _ := net.Listen("tcp", ":8033")
// 	ts := httptest.Server{
// 		Listener: l,
// 		Config:   &http.Server{Handler: router},
// 	}
// 	ts.Start()
// 	defer ts.Close()

// 	testRequest(t, "http://localhost:8033/example")
// }

func testGetRequestHandler(t *testing.T, h http.Handler, url string) {
	req, err := http.NewRequest("GET", url, nil)
	assert.NoError(t, err)

	w := httptest.NewRecorder()
	h.ServeHTTP(w, req)

	assert.Equal(t, "it worked", w.Body.String(), "resp body should match")
	assert.Equal(t, 200, w.Code, "should get a 200")
}
Add license for some files (#940) 2017-06-12 09:04:52 +03:00			`// Copyright 2017 Manu Martinez-Almeida. All rights reserved.`
			`// Use of this source code is governed by a MIT style`
			`// license that can be found in the LICENSE file.`

unix socket integration test 2015-05-29 04:28:24 +03:00			`package gin`

			`import (`
			`"bufio"`
Fix LoadHTML* tests (#1559) Digging into the test code base I've found out that some of the tests for `LoadHTML*` methods are not reliable and efficient. They use timeouts to be sure that goroutine with the server has started. And even more, in old implementation, the server started only once – all the new instances silently failed due to the occupied network port. Here is a short overview of the proposed changes: - it's not necessary to rely on timeouts, the server starts listening synchronously and returns control when it is ready - once the server is run, it's stopped after a test passes - dry out http server setup - magic with empty closure return is eliminated - preserve router.RunTLS coverage with integration tests 2018-10-16 03:48:41 +03:00			`"crypto/tls"`
unix socket integration test 2015-05-29 04:28:24 +03:00			`"fmt"`
v1.4.0 + #1631 (remove go1.6/go1,7 support) (#1851) * remove go1.6 support * remove build tag * remove todo * remove go1.6 support: https://github.com/gin-gonic/gin/pull/1383/commits * update readme * remove go1.7 support * fix embedmd error * test * revert it * revert it * remove context_17 * add pusher test * v1.4.0 rc1 2019-05-07 13:32:32 +03:00			`"html/template"`
test standard router 2015-05-29 14:29:33 +03:00			`"io/ioutil"`
unix socket integration test 2015-05-29 04:28:24 +03:00			`"net"`
			`"net/http"`
lint code for import (#939) 2017-06-12 05:40:15 +03:00			`"net/http/httptest"`
router.Run() can be called without parameters. #405 2015-08-16 17:19:51 +03:00			`"os"`
removed use of sync.pool from HandleContext and added test coverage (#1565) As per #1230 there is an issue when using HandleContext where the context of the request is returned to the context sync.Pool before the parent request has finished, causing context to be used in a non-thread safe manner. I've removed the bug by not entering the context back in the pool and leaving that to ServeHTTP. There was no test coverage for this function so I've also added the test to cover it. As the bug only happens when there are concurrent requests, the tests issues hundreds of concurrent requests. Without the bug fixed the tests do consistently recreate the error. 2018-10-01 05:49:39 +03:00			`"sync"`
unix socket integration test 2015-05-29 04:28:24 +03:00			`"testing"`
			`"time"`

			`"github.com/stretchr/testify/assert"`
			`)`

router.Run() can be called without parameters. #405 2015-08-16 17:19:51 +03:00			`func testRequest(t *testing.T, url string) {`
Fix LoadHTML* tests (#1559) Digging into the test code base I've found out that some of the tests for `LoadHTML*` methods are not reliable and efficient. They use timeouts to be sure that goroutine with the server has started. And even more, in old implementation, the server started only once – all the new instances silently failed due to the occupied network port. Here is a short overview of the proposed changes: - it's not necessary to rely on timeouts, the server starts listening synchronously and returns control when it is ready - once the server is run, it's stopped after a test passes - dry out http server setup - magic with empty closure return is eliminated - preserve router.RunTLS coverage with integration tests 2018-10-16 03:48:41 +03:00			`tr := &http.Transport{`
			`TLSClientConfig: &tls.Config{`
			`InsecureSkipVerify: true,`
			`},`
			`}`
			`client := &http.Client{Transport: tr}`

			`resp, err := client.Get(url)`
router.Run() can be called without parameters. #405 2015-08-16 17:19:51 +03:00			`assert.NoError(t, err)`
Add Makefile to check the following thing (#947) * Add Makefile to check the following thing. * vet check * fmt check * embedmd check * misspell check Signed-off-by: Bo-Yi Wu <appleboy.tw@gmail.com> * remove unused variable. Signed-off-by: Bo-Yi Wu <appleboy.tw@gmail.com> 2017-06-13 05:50:42 +03:00			`defer resp.Body.Close()`
router.Run() can be called without parameters. #405 2015-08-16 17:19:51 +03:00
			`body, ioerr := ioutil.ReadAll(resp.Body)`
			`assert.NoError(t, ioerr)`
			`assert.Equal(t, "it worked", string(body), "resp body should match")`
			`assert.Equal(t, "200 OK", resp.Status, "should get a 200")`
			`}`

			`func TestRunEmpty(t *testing.T) {`
			`os.Setenv("PORT", "")`
test standard router 2015-05-29 14:29:33 +03:00			`router := New()`
			`go func() {`
			`router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })`
router.Run() can be called without parameters. #405 2015-08-16 17:19:51 +03:00			`assert.NoError(t, router.Run())`
test standard router 2015-05-29 14:29:33 +03:00			`}()`
			`// have to wait for the goroutine to start and run the server`
			`// otherwise the main thread will complete`
			`time.Sleep(5 * time.Millisecond)`

router.Run() can be called without parameters. #405 2015-08-16 17:19:51 +03:00			`assert.Error(t, router.Run(":8080"))`
			`testRequest(t, "http://localhost:8080/example")`
			`}`
Completes integration test 2015-06-03 06:25:50 +03:00
Fix LoadHTML* tests (#1559) Digging into the test code base I've found out that some of the tests for `LoadHTML*` methods are not reliable and efficient. They use timeouts to be sure that goroutine with the server has started. And even more, in old implementation, the server started only once – all the new instances silently failed due to the occupied network port. Here is a short overview of the proposed changes: - it's not necessary to rely on timeouts, the server starts listening synchronously and returns control when it is ready - once the server is run, it's stopped after a test passes - dry out http server setup - magic with empty closure return is eliminated - preserve router.RunTLS coverage with integration tests 2018-10-16 03:48:41 +03:00			`func TestRunTLS(t *testing.T) {`
			`router := New()`
			`go func() {`
			`router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })`

			`assert.NoError(t, router.RunTLS(":8443", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))`
			`}()`

			`// have to wait for the goroutine to start and run the server`
			`// otherwise the main thread will complete`
			`time.Sleep(5 * time.Millisecond)`

			`assert.Error(t, router.RunTLS(":8443", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))`
			`testRequest(t, "https://localhost:8443/example")`
			`}`

v1.4.0 + #1631 (remove go1.6/go1,7 support) (#1851) * remove go1.6 support * remove build tag * remove todo * remove go1.6 support: https://github.com/gin-gonic/gin/pull/1383/commits * update readme * remove go1.7 support * fix embedmd error * test * revert it * revert it * remove context_17 * add pusher test * v1.4.0 rc1 2019-05-07 13:32:32 +03:00			`func TestPusher(t *testing.T) {`
			var html = template.Must(template.New("https").Parse(`
			`<html>`
			`<head>`
			`<title>Https Test</title>`
			`<script src="/assets/app.js"></script>`
			`</head>`
			`<body>`
			`<h1 style="color:red;">Welcome, Ginner!</h1>`
			`</body>`
			`</html>`
			`))

			`router := New()`
			`router.Static("./assets", "./assets")`
			`router.SetHTMLTemplate(html)`

			`go func() {`
			`router.GET("/pusher", func(c *Context) {`
			`if pusher := c.Writer.Pusher(); pusher != nil {`
			`pusher.Push("/assets/app.js", nil)`
			`}`
			`c.String(http.StatusOK, "it worked")`
			`})`

			`assert.NoError(t, router.RunTLS(":8449", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))`
			`}()`

			`// have to wait for the goroutine to start and run the server`
			`// otherwise the main thread will complete`
			`time.Sleep(5 * time.Millisecond)`

			`assert.Error(t, router.RunTLS(":8449", "./testdata/certificate/cert.pem", "./testdata/certificate/key.pem"))`
			`testRequest(t, "https://localhost:8449/pusher")`
			`}`

router.Run() can be called without parameters. #405 2015-08-16 17:19:51 +03:00			`func TestRunEmptyWithEnv(t *testing.T) {`
			`os.Setenv("PORT", "3123")`
			`router := New()`
			`go func() {`
			`router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })`
			`assert.NoError(t, router.Run())`
			`}()`
			`// have to wait for the goroutine to start and run the server`
			`// otherwise the main thread will complete`
			`time.Sleep(5 * time.Millisecond)`
Completes integration test 2015-06-03 06:25:50 +03:00
router.Run() can be called without parameters. #405 2015-08-16 17:19:51 +03:00			`assert.Error(t, router.Run(":3123"))`
			`testRequest(t, "http://localhost:3123/example")`
			`}`

			`func TestRunTooMuchParams(t *testing.T) {`
			`router := New()`
			`assert.Panics(t, func() {`
fix errcheck warnings (#1739) 2019-01-18 04:32:53 +03:00			`assert.NoError(t, router.Run("2", "2"))`
router.Run() can be called without parameters. #405 2015-08-16 17:19:51 +03:00			`})`
			`}`

			`func TestRunWithPort(t *testing.T) {`
			`router := New()`
			`go func() {`
			`router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })`
			`assert.NoError(t, router.Run(":5150"))`
			`}()`
			`// have to wait for the goroutine to start and run the server`
			`// otherwise the main thread will complete`
			`time.Sleep(5 * time.Millisecond)`

			`assert.Error(t, router.Run(":5150"))`
			`testRequest(t, "http://localhost:5150/example")`
test standard router 2015-05-29 14:29:33 +03:00			`}`

unix socket integration test 2015-05-29 04:28:24 +03:00			`func TestUnixSocket(t *testing.T) {`
			`router := New()`
Completes integration test 2015-06-03 06:25:50 +03:00
unix socket integration test 2015-05-29 04:28:24 +03:00			`go func() {`
			`router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })`
router.Run() can be called without parameters. #405 2015-08-16 17:19:51 +03:00			`assert.NoError(t, router.RunUnix("/tmp/unix_unit_test"))`
unix socket integration test 2015-05-29 04:28:24 +03:00			`}()`
			`// have to wait for the goroutine to start and run the server`
			`// otherwise the main thread will complete`
			`time.Sleep(5 * time.Millisecond)`

			`c, err := net.Dial("unix", "/tmp/unix_unit_test")`
Completes integration test 2015-06-03 06:25:50 +03:00			`assert.NoError(t, err)`

Linting and optimizing struct memory signature. (#1184) * fix cleanPath spell (#969) * linter and optimize structs 2017-11-29 05:50:14 +03:00			`fmt.Fprint(c, "GET /example HTTP/1.0\r\n\r\n")`
unix socket integration test 2015-05-29 04:28:24 +03:00			`scanner := bufio.NewScanner(c)`
			`var response string`
			`for scanner.Scan() {`
			`response += scanner.Text()`
			`}`
			`assert.Contains(t, response, "HTTP/1.0 200", "should get a 200")`
			`assert.Contains(t, response, "it worked", "resp body should match")`
			`}`
Completes integration test 2015-06-03 06:25:50 +03:00
			`func TestBadUnixSocket(t *testing.T) {`
			`router := New()`
			`assert.Error(t, router.RunUnix("#/tmp/unix_unit_test"))`
			`}`
Add integration test using httptest 2016-02-23 20:44:52 +03:00
feat(server): Implements RunFd method (#1609) 2018-11-06 05:28:51 +03:00			`func TestFileDescriptor(t *testing.T) {`
			`router := New()`

fix test - auto choose port number (#1719) 2018-12-28 05:26:29 +03:00			`addr, err := net.ResolveTCPAddr("tcp", "localhost:0")`
feat(server): Implements RunFd method (#1609) 2018-11-06 05:28:51 +03:00			`assert.NoError(t, err)`
			`listener, err := net.ListenTCP("tcp", addr)`
			`assert.NoError(t, err)`
			`socketFile, err := listener.File()`
			`assert.NoError(t, err)`

			`go func() {`
			`router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })`
			`assert.NoError(t, router.RunFd(int(socketFile.Fd())))`
			`}()`
			`// have to wait for the goroutine to start and run the server`
			`// otherwise the main thread will complete`
			`time.Sleep(5 * time.Millisecond)`

fix test - auto choose port number (#1719) 2018-12-28 05:26:29 +03:00			`c, err := net.Dial("tcp", listener.Addr().String())`
feat(server): Implements RunFd method (#1609) 2018-11-06 05:28:51 +03:00			`assert.NoError(t, err)`

			`fmt.Fprintf(c, "GET /example HTTP/1.0\r\n\r\n")`
			`scanner := bufio.NewScanner(c)`
			`var response string`
			`for scanner.Scan() {`
			`response += scanner.Text()`
			`}`
			`assert.Contains(t, response, "HTTP/1.0 200", "should get a 200")`
			`assert.Contains(t, response, "it worked", "resp body should match")`
			`}`

			`func TestBadFileDescriptor(t *testing.T) {`
			`router := New()`
			`assert.Error(t, router.RunFd(0))`
			`}`

Add integration test using httptest 2016-02-23 20:44:52 +03:00			`func TestWithHttptestWithAutoSelectedPort(t *testing.T) {`
			`router := New()`
			`router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })`

			`ts := httptest.NewServer(router)`
			`defer ts.Close()`

			`testRequest(t, ts.URL+"/example")`
			`}`

removed use of sync.pool from HandleContext and added test coverage (#1565) As per #1230 there is an issue when using HandleContext where the context of the request is returned to the context sync.Pool before the parent request has finished, causing context to be used in a non-thread safe manner. I've removed the bug by not entering the context back in the pool and leaving that to ServeHTTP. There was no test coverage for this function so I've also added the test to cover it. As the bug only happens when there are concurrent requests, the tests issues hundreds of concurrent requests. Without the bug fixed the tests do consistently recreate the error. 2018-10-01 05:49:39 +03:00			`func TestConcurrentHandleContext(t *testing.T) {`
			`router := New()`
			`router.GET("/", func(c *Context) {`
			`c.Request.URL.Path = "/example"`
			`router.HandleContext(c)`
			`})`
			`router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })`

			`var wg sync.WaitGroup`
			`iterations := 200`
			`wg.Add(iterations)`
			`for i := 0; i < iterations; i++ {`
			`go func() {`
fix travis freeze on concurrent test (#1761) 2019-02-04 04:27:00 +03:00			`testGetRequestHandler(t, router, "/")`
removed use of sync.pool from HandleContext and added test coverage (#1565) As per #1230 there is an issue when using HandleContext where the context of the request is returned to the context sync.Pool before the parent request has finished, causing context to be used in a non-thread safe manner. I've removed the bug by not entering the context back in the pool and leaving that to ServeHTTP. There was no test coverage for this function so I've also added the test to cover it. As the bug only happens when there are concurrent requests, the tests issues hundreds of concurrent requests. Without the bug fixed the tests do consistently recreate the error. 2018-10-01 05:49:39 +03:00			`wg.Done()`
			`}()`
			`}`
			`wg.Wait()`
			`}`

docs: add graceful-shutdown example for go 1.8 (#835) * docs: add graceful-shutdown example for go 1.8 * fix testing Signed-off-by: Bo-Yi Wu <appleboy.tw@gmail.com> 2017-03-16 18:38:30 +03:00			`// func TestWithHttptestWithSpecifiedPort(t *testing.T) {`
			`// router := New()`
			`// router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })`

			`// l, _ := net.Listen("tcp", ":8033")`
			`// ts := httptest.Server{`
			`// Listener: l,`
			`// Config: &http.Server{Handler: router},`
			`// }`
			`// ts.Start()`
			`// defer ts.Close()`

			`// testRequest(t, "http://localhost:8033/example")`
			`// }`
fix travis freeze on concurrent test (#1761) 2019-02-04 04:27:00 +03:00
			`func testGetRequestHandler(t *testing.T, h http.Handler, url string) {`
			`req, err := http.NewRequest("GET", url, nil)`
			`assert.NoError(t, err)`

			`w := httptest.NewRecorder()`
			`h.ServeHTTP(w, req)`

			`assert.Equal(t, "it worked", w.Body.String(), "resp body should match")`
			`assert.Equal(t, 200, w.Code, "should get a 200")`
			`}`