Gofight

API Handler Testing for Golang Web framework.

Support Framework

• Http Handler Golang package http provides HTTP client and server implementations.
• Gin
• Echo support v3.0.0 up
• Mux

Install

Download this package.

go get github.com/appleboy/gofight/v2

To import this package, add the following line to your code:

import"github.com/appleboy/gofight/v2"

Usage

The following is basic testing example.

Main Program:

package main
import (
"io""net/http"
)
funcBasicHelloHandler(w http.ResponseWriter, r*http.Request) {
io.WriteString(w, "Hello World")
}
funcBasicEngine() http.Handler {
mux:=http.NewServeMux()
mux.HandleFunc("/", BasicHelloHandler)
returnmux
}

Testing:

package main
import (
"net/http""testing""github.com/appleboy/gofight/v2""github.com/stretchr/testify/assert"
)
funcTestBasicHelloWorld(t*testing.T) {
r:=gofight.New()
r.GET("/").
// turn on the debug mode.SetDebug(true).
Run(BasicEngine(), func(r gofight.HTTPResponse, rq gofight.HTTPRequest) {
assert.Equal(t, "Hello World", r.Body.String())
assert.Equal(t, http.StatusOK, r.Code)
})
}

Set Header

You can add custom header via SetHeader func.

funcTestBasicHelloWorld(t*testing.T) {
r:=gofight.New()
version:="0.0.1"r.GET("/").
// turn on the debug mode.SetDebug(true).
SetHeader(gofight.H{
"X-Version": version,
}).
Run(BasicEngine(), func(r gofight.HTTPResponse, rq gofight.HTTPRequest) {
assert.Equal(t, version, rq.Header.Get("X-Version"))
assert.Equal(t, "Hello World", r.Body.String())
assert.Equal(t, http.StatusOK, r.Code)
})
}

POST FORM Data

Using SetForm to generate form data.

funcTestPostFormData(t*testing.T) {
r:=gofight.New()
r.POST("/form").
SetForm(gofight.H{
"a": "1",
"b": "2",
}).
Run(BasicEngine(), func(rHTTPResponse, rqHTTPRequest) {
data:= []byte(r.Body.String())
a, _:=jsonparser.GetString(data, "a")
b, _:=jsonparser.GetString(data, "b")
assert.Equal(t, "1", a)
assert.Equal(t, "2", b)
assert.Equal(t, http.StatusOK, r.Code)
})
}

POST JSON Data

Using SetJSON to generate JSON data.

funcTestPostJSONData(t*testing.T) {
r:=gofight.New()
r.POST("/json").
SetJSON(gofight.D{
"a": 1,
"b": 2,
}).
Run(BasicEngine, func(rHTTPResponse, rqHTTPRequest) {
data:= []byte(r.Body.String())
a, _:=jsonparser.GetInt(data, "a")
b, _:=jsonparser.GetInt(data, "b")
assert.Equal(t, 1, int(a))
assert.Equal(t, 2, int(b))
assert.Equal(t, http.StatusOK, r.Code)
assert.Equal(t, "application/json; charset=utf-8", r.HeaderMap.Get("Content-Type"))
})
}

POST RAW Data

Using SetBody to generate raw data.

funcTestPostRawData(t*testing.T) {
r:=gofight.New()
r.POST("/raw").
SetBody("a=1&b=1").
Run(BasicEngine, func(rHTTPResponse, rqHTTPRequest) {
data:= []byte(r.Body.String())
a, _:=jsonparser.GetString(data, "a")
b, _:=jsonparser.GetString(data, "b")
assert.Equal(t, "1", a)
assert.Equal(t, "2", b)
assert.Equal(t, http.StatusOK, r.Code)
})
}

Set Query String

Using SetQuery to generate raw data.

funcTestQueryString(t*testing.T) {
r:=gofight.New()
r.GET("/hello").
SetQuery(gofight.H{
"a": "1",
"b": "2",
}).
Run(BasicEngine, func(rHTTPResponse, rqHTTPRequest) {
assert.Equal(t, http.StatusOK, r.Code)
})
}

or append exist query parameter.

funcTestQueryString(t*testing.T) {
r:=gofight.New()
r.GET("/hello?foo=bar").
SetQuery(gofight.H{
"a": "1",
"b": "2",
}).
Run(BasicEngine, func(rHTTPResponse, rqHTTPRequest) {
assert.Equal(t, http.StatusOK, r.Code)
})
}

Set Cookie String

Using SetCookie to generate raw data.

funcTestQueryString(t*testing.T) {
r:=gofight.New()
r.GET("/hello").
SetCookie(gofight.H{
"foo": "bar",
}).
Run(BasicEngine, func(rHTTPResponse, rqHTTPRequest) {
assert.Equal(t, http.StatusOK, r.Code)
assert.Equal(t, "foo=bar", rq.Header.Get("cookie"))
})
}

Set JSON Struct

typeUserstruct {
// Username user nameUsernamestring`json:"username"`// Password account passwordPasswordstring`json:"password"`
}
funcTestSetJSONInterface(t*testing.T) {
r:=New()
r.POST("/user").
SetJSONInterface(User{
Username: "foo",
Password: "bar",
}).
Run(framework.GinEngine(), func(rHTTPResponse, rqHTTPRequest) {
data:= []byte(r.Body.String())
username:=gjson.GetBytes(data, "username")
password:=gjson.GetBytes(data, "password")
assert.Equal(t, "foo", username.String())
assert.Equal(t, "bar", password.String())
assert.Equal(t, http.StatusOK, r.Code)
assert.Equal(t, "application/json; charset=utf-8", r.HeaderMap.Get("Content-Type"))
})
}

Upload multiple file with absolute path and parameter

The following is route using gin

funcgintFileUploadHandler(c*gin.Context) {
ip:=c.ClientIP()
hello, err:=c.FormFile("hello")
iferr!=nil {
c.JSON(http.StatusBadRequest, gin.H{
"error": err.Error(),
})
return
}
helloFile, _:=hello.Open()
helloBytes:=make([]byte, 6)
helloFile.Read(helloBytes)
world, err:=c.FormFile("world")
iferr!=nil {
c.JSON(http.StatusBadRequest, gin.H{
"error": err.Error(),
})
return
}
worldFile, _:=world.Open()
worldBytes:=make([]byte, 6)
worldFile.Read(worldBytes)
foo:=c.PostForm("foo")
bar:=c.PostForm("bar")
c.JSON(http.StatusOK, gin.H{
"hello": hello.Filename,
"world": world.Filename,
"foo": foo,
"bar": bar,
"ip": ip,
"helloSize": string(helloBytes),
"worldSize": string(worldBytes),
})
}

Write the testing:

funcTestUploadFile(t*testing.T) {
r:=New()
r.POST("/upload").
SetDebug(true).
SetFileFromPath([]UploadFile{
{
Path: "./testdata/hello.txt",
Name: "hello",
},
{
Path: "./testdata/world.txt",
Name: "world",
},
}, H{
"foo": "bar",
"bar": "foo",
}).
Run(framework.GinEngine(), func(rHTTPResponse, rqHTTPRequest) {
data:= []byte(r.Body.String())
hello:=gjson.GetBytes(data, "hello")
world:=gjson.GetBytes(data, "world")
foo:=gjson.GetBytes(data, "foo")
bar:=gjson.GetBytes(data, "bar")
ip:=gjson.GetBytes(data, "ip")
helloSize:=gjson.GetBytes(data, "helloSize")
worldSize:=gjson.GetBytes(data, "worldSize")
assert.Equal(t, "world\n", helloSize.String())
assert.Equal(t, "hello\n", worldSize.String())
assert.Equal(t, "hello.txt", hello.String())
assert.Equal(t, "world.txt", world.String())
assert.Equal(t, "bar", foo.String())
assert.Equal(t, "foo", bar.String())
assert.Equal(t, "", ip.String())
assert.Equal(t, http.StatusOK, r.Code)
assert.Equal(t, "application/json; charset=utf-8", r.HeaderMap.Get("Content-Type"))
})
}

Upload multiple file with content []byte path and parameter

funcTestUploadFileByContent(t*testing.T) {
r:=New()
helloContent, err:=ioutil.ReadFile("./testdata/hello.txt")
iferr!=nil {
log.Fatal(err)
}
worldContent, err:=ioutil.ReadFile("./testdata/world.txt")
iferr!=nil {
log.Fatal(err)
}
r.POST("/upload").
SetDebug(true).
SetFileFromPath([]UploadFile{
{
Path: "hello.txt",
Name: "hello",
Content: helloContent,
},
{
Path: "world.txt",
Name: "world",
Content: worldContent,
},
}, H{
"foo": "bar",
"bar": "foo",
}).
Run(framework.GinEngine(), func(rHTTPResponse, rqHTTPRequest) {
data:= []byte(r.Body.String())
hello:=gjson.GetBytes(data, "hello")
world:=gjson.GetBytes(data, "world")
foo:=gjson.GetBytes(data, "foo")
bar:=gjson.GetBytes(data, "bar")
ip:=gjson.GetBytes(data, "ip")
helloSize:=gjson.GetBytes(data, "helloSize")
worldSize:=gjson.GetBytes(data, "worldSize")
assert.Equal(t, "world\n", helloSize.String())
assert.Equal(t, "hello\n", worldSize.String())
assert.Equal(t, "hello.txt", hello.String())
assert.Equal(t, "world.txt", world.String())
assert.Equal(t, "bar", foo.String())
assert.Equal(t, "foo", bar.String())
assert.Equal(t, "", ip.String())
assert.Equal(t, http.StatusOK, r.Code)
assert.Equal(t, "application/json; charset=utf-8", r.HeaderMap.Get("Content-Type"))
})
}

Example

• Basic HTTP Router: example
• Gin Framework: example
• Echo Framework: example
• Mux Framework: example

License

Copyright 2019 Bo-Yi Wu @appleboy.

Licensed under the MIT License.