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"
	"path/filepath"
	"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 {
				err := pusher.Push("/assets/app.js", nil)
				assert.NoError(t, err)
			}
			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()

	unixTestSocket := filepath.Join(os.TempDir(), "unix_unit_test")

	defer os.Remove(unixTestSocket)

	go func() {
		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
		assert.NoError(t, router.RunUnix(unixTestSocket))
	}()
	// 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", unixTestSocket)
	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 TestListener(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)
	go func() {
		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
		assert.NoError(t, router.RunListener(listener))
	}()
	// 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 TestBadListener(t *testing.T) {
	router := New()
	addr, err := net.ResolveTCPAddr("tcp", "localhost:10086")
	assert.NoError(t, err)
	listener, err := net.ListenTCP("tcp", addr)
	assert.NoError(t, err)
	listener.Close()
	assert.Error(t, router.RunListener(listener))
}

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(http.MethodGet, 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"`
test: fixed the TestUnixSocket test on windows (#2595) Co-authored-by: thinkerou <thinkerou@gmail.com> 2021-01-11 04:07:45 +03:00			`"path/filepath"`
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 {`
Fix 'errcheck' linter warnings (#2093) 2019-10-27 08:58:59 +03:00			`err := pusher.Push("/assets/app.js", nil)`
			`assert.NoError(t, err)`
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			`}`
			`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
test: fixed the TestUnixSocket test on windows (#2595) Co-authored-by: thinkerou <thinkerou@gmail.com> 2021-01-11 04:07:45 +03:00			`unixTestSocket := filepath.Join(os.TempDir(), "unix_unit_test")`
Update gin_integration_test.go (#2341) * Update gin_integration_test.go TestUnixSocket fails if you run it twice in a row. This is due to the unix socket file persisting. Added defer to clean up. Whats unclear is the following test TestBadUnixSocket I suspect is just looking for cruft maybe from a prior test or defaults not working, I have not enough background to say. * Update gin_integration_test.go I believe there is some tab issue here, tried to manual overwrite it now. * Update gin_integration_test.go squash you dang spaces!!! 2020-04-28 04:36:04 +03:00
			`defer os.Remove(unixTestSocket)`

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") })`
Update gin_integration_test.go (#2341) * Update gin_integration_test.go TestUnixSocket fails if you run it twice in a row. This is due to the unix socket file persisting. Added defer to clean up. Whats unclear is the following test TestBadUnixSocket I suspect is just looking for cruft maybe from a prior test or defaults not working, I have not enough background to say. * Update gin_integration_test.go I believe there is some tab issue here, tried to manual overwrite it now. * Update gin_integration_test.go squash you dang spaces!!! 2020-04-28 04:36:04 +03:00			`assert.NoError(t, router.RunUnix(unixTestSocket))`
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)`

Update gin_integration_test.go (#2341) * Update gin_integration_test.go TestUnixSocket fails if you run it twice in a row. This is due to the unix socket file persisting. Added defer to clean up. Whats unclear is the following test TestBadUnixSocket I suspect is just looking for cruft maybe from a prior test or defaults not working, I have not enough background to say. * Update gin_integration_test.go I believe there is some tab issue here, tried to manual overwrite it now. * Update gin_integration_test.go squash you dang spaces!!! 2020-04-28 04:36:04 +03:00			`c, err := net.Dial("unix", unixTestSocket)`
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))`
			`}`

support run HTTP server with specific net.Listener (#2023) 2019-09-30 04:12:22 +03:00			`func TestListener(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)`
			`go func() {`
			`router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })`
			`assert.NoError(t, router.RunListener(listener))`
			`}()`
			`// 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 TestBadListener(t *testing.T) {`
			`router := New()`
			`addr, err := net.ResolveTCPAddr("tcp", "localhost:10086")`
			`assert.NoError(t, err)`
			`listener, err := net.ListenTCP("tcp", addr)`
Fix 'errcheck' linter warnings (#2093) 2019-10-27 08:58:59 +03:00			`assert.NoError(t, err)`
support run HTTP server with specific net.Listener (#2023) 2019-09-30 04:12:22 +03:00			`listener.Close()`
			`assert.Error(t, router.RunListener(listener))`
			`}`

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) {`
use http method constant (#2155) * use http method constant * fix typo 2019-11-29 02:50:49 +03:00			`req, err := http.NewRequest(http.MethodGet, url, nil)`
fix travis freeze on concurrent test (#1761) 2019-02-04 04:27:00 +03:00			`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")`
			`}`