vinchent/gin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
07a6818d24
gin/gin_integration_test.go

303 lines
8.1 KiB
Go
Raw Normal View History

Add license for some files (#940)
2017-06-12 06:04:52 +00: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 01:28:24 +00: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 00:48:41 +00:00
"crypto/tls"
unix socket integration test
2015-05-29 01:28:24 +00: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 10:32:32 +00:00
"html/template"
test standard router
2015-05-29 11:29:33 +00:00
"io/ioutil"
unix socket integration test
2015-05-29 01:28:24 +00:00
"net"
"net/http"
lint code for import (#939)
2017-06-12 02:40:15 +00:00
"net/http/httptest"
router.Run() can be called without parameters. #405
2015-08-16 14:19:51 +00: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 02:49:39 +00:00
"sync"
unix socket integration test
2015-05-29 01:28:24 +00:00
"testing"
"time"
"github.com/stretchr/testify/assert"
)
router.Run() can be called without parameters. #405
2015-08-16 14:19:51 +00: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 00:48:41 +00: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 14:19:51 +00: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 02:50:42 +00:00
defer resp.Body.Close()
router.Run() can be called without parameters. #405
2015-08-16 14:19:51 +00: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 11:29:33 +00: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 14:19:51 +00:00
assert.NoError(t, router.Run())
test standard router
2015-05-29 11:29:33 +00: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 14:19:51 +00:00
assert.Error(t, router.Run(":8080"))
testRequest(t, "http://localhost:8080/example")
}
Completes integration test
2015-06-03 03:25:50 +00: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 00:48:41 +00: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 10:32:32 +00: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 05:58:59 +00: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 10:32:32 +00: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 14:19:51 +00: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 03:25:50 +00:00
router.Run() can be called without parameters. #405
2015-08-16 14:19:51 +00: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 01:32:53 +00:00
assert.NoError(t, router.Run("2", "2"))
router.Run() can be called without parameters. #405
2015-08-16 14:19:51 +00: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 11:29:33 +00:00
}
unix socket integration test
2015-05-29 01:28:24 +00:00
func TestUnixSocket(t *testing.T) {
router := New()
Completes integration test
2015-06-03 03:25:50 +00:00
unix socket integration test
2015-05-29 01:28:24 +00: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 14:19:51 +00:00
assert.NoError(t, router.RunUnix("/tmp/unix_unit_test"))
unix socket integration test
2015-05-29 01:28:24 +00: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 03:25:50 +00:00
assert.NoError(t, err)
Linting and optimizing struct memory signature. (#1184) * fix cleanPath spell (#969) * linter and optimize structs
2017-11-29 02:50:14 +00:00
fmt.Fprint(c, "GET /example HTTP/1.0\r\n\r\n")
unix socket integration test
2015-05-29 01:28:24 +00: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 03:25:50 +00: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 17:44:52 +00:00
feat(server): Implements RunFd method (#1609)
2018-11-06 02:28:51 +00:00
func TestFileDescriptor(t *testing.T) {
router := New()
fix test - auto choose port number (#1719)
2018-12-28 02:26:29 +00:00
addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
feat(server): Implements RunFd method (#1609)
2018-11-06 02:28:51 +00: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 02:26:29 +00:00
c, err := net.Dial("tcp", listener.Addr().String())
feat(server): Implements RunFd method (#1609)
2018-11-06 02:28:51 +00: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 01:12:22 +00: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 05:58:59 +00:00
assert.NoError(t, err)
support run HTTP server with specific net.Listener (#2023)
2019-09-30 01:12:22 +00:00
listener.Close()
assert.Error(t, router.RunListener(listener))
}
Add integration test using httptest
2016-02-23 17:44:52 +00: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 02:49:39 +00: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 01:27:00 +00: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 02:49:39 +00: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 15:38:30 +00: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 01:27:00 +00:00
func testGetRequestHandler(t *testing.T, h http.Handler, url string) {
use http method constant (#2155) * use http method constant * fix typo
2019-11-28 23:50:49 +00:00
req, err := http.NewRequest(http.MethodGet, url, nil)
fix travis freeze on concurrent test (#1761)
2019-02-04 01:27:00 +00: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")
}
Reference in New Issue Copy Permalink