gofight

README

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
• HttpRouter
• Pat
• beego

Usage

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"
)

func BasicHelloHandler(w http.ResponseWriter, r *http.Request) {
	io.WriteString(w, "Hello World")
}

func BasicEngine() http.Handler {
	mux := http.NewServeMux()
	mux.HandleFunc("/", BasicHelloHandler)

	return mux
}

Testing:

package main

import (
	"net/http"
	"testing"

	"github.com/appleboy/gofight/v2"
	"github.com/stretchr/testify/assert"
)

func TestBasicHelloWorld(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.

func TestBasicHelloWorld(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.

func TestPostFormData(t *testing.T) {
	r := gofight.New()

	r.POST("/form").
		SetForm(gofight.H{
			"a": "1",
			"b": "2",
		}).
		Run(BasicEngine(), func(r HTTPResponse, rq HTTPRequest) {
			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.

func TestPostJSONData(t *testing.T) {
	r := gofight.New()

	r.POST("/json").
		SetJSON(gofight.D{
			"a": 1,
			"b": 2,
		}).
		Run(BasicEngine, func(r HTTPResponse, rq HTTPRequest) {
			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.

func TestPostRawData(t *testing.T) {
	r := gofight.New()

	r.POST("/raw").
		SetBody("a=1&b=1").
		Run(BasicEngine, func(r HTTPResponse, rq HTTPRequest) {
			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.

func TestQueryString(t *testing.T) {
	r := gofight.New()

	r.GET("/hello").
		SetQuery(gofight.H{
			"a": "1",
			"b": "2",
		}).
		Run(BasicEngine, func(r HTTPResponse, rq HTTPRequest) {
			assert.Equal(t, http.StatusOK, r.Code)
		})
}

or append exist query parameter.

func TestQueryString(t *testing.T) {
	r := gofight.New()

	r.GET("/hello?foo=bar").
		SetQuery(gofight.H{
			"a": "1",
			"b": "2",
		}).
		Run(BasicEngine, func(r HTTPResponse, rq HTTPRequest) {
			assert.Equal(t, http.StatusOK, r.Code)
		})
}

Set Cookie String

Using SetCookie to generate raw data.

func TestQueryString(t *testing.T) {
	r := gofight.New()

	r.GET("/hello").
		SetCookie(gofight.H{
			"foo": "bar",
		}).
		Run(BasicEngine, func(r HTTPResponse, rq HTTPRequest) {
			assert.Equal(t, http.StatusOK, r.Code)
			assert.Equal(t, "foo=bar", rq.Header.Get("cookie"))
		})
}

Set JSON Struct

type User struct {
	// Username user name
	Username string `json:"username"`
	// Password account password
	Password string `json:"password"`
}

func TestSetJSONInterface(t *testing.T) {
	r := New()

	r.POST("/user").
		SetJSONInterface(User{
			Username: "foo",
			Password: "bar",
		}).
		Run(framework.GinEngine(), func(r HTTPResponse, rq HTTPRequest) {
			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

func gintFileUploadHandler(c *gin.Context) {
	ip := c.ClientIP()
	hello, err := c.FormFile("hello")
	if err != 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")
	if err != 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:

func TestUploadFile(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(r HTTPResponse, rq HTTPRequest) {
			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

func TestUploadFileByContent(t *testing.T) {
	r := New()

	helloContent, err := ioutil.ReadFile("./testdata/hello.txt")
	if err != nil {
		log.Fatal(err)
	}

	worldContent, err := ioutil.ReadFile("./testdata/world.txt")
	if err != 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(r HTTPResponse, rq HTTPRequest) {
			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: basic.go, basic_test.go
• Gin Framework: gin.go, gin_test.go
• Echo Framework: echo.go, echo_test.go
• Mux Framework: mux.go, mux_test.go
• HttpRouter Framework: httprouter.go, httprouter_test.go
• Beego Framework: beego.go, beego_test.go

License

Copyright 2019 Bo-Yi Wu @appleboy.

Licensed under the MIT License.

Documentation

Overview

Package gofight offers simple API http handler testing for Golang framework.

Details about the gofight project are found in github page:

https://github.com/appleboy/gofight

Installation:

$ go get -u github.com/appleboy/gofight

Set Header: You can add custom header via SetHeader func.

SetHeader(gofight.H{
  "X-Version": version,
})

Set Cookie: You can add custom cookie via SetCookie func.

SetCookie(gofight.H{
  "foo": "bar",
})

Set query string: Using SetQuery to generate query string data.

SetQuery(gofight.H{
  "a": "1",
  "b": "2",
})

POST FORM Data: Using SetForm to generate form data.

SetForm(gofight.H{
  "a": "1",
  "b": "2",
})

POST JSON Data: Using SetJSON to generate json data.

SetJSON(gofight.H{
  "a": "1",
  "b": "2",
})

POST RAW Data: Using SetBody to generate raw data.

SetBody("a=1&b=1")

For more details, see the documentation and example.

Index

• Constants
• Variables
• type D
• type H
• type HTTPRequest
• type HTTPResponse
• type RequestConfig
  • func New() *RequestConfig
  • func (rc *RequestConfig) DELETE(path string) *RequestConfig
  • func (rc *RequestConfig) GET(path string) *RequestConfig
  • func (rc *RequestConfig) HEAD(path string) *RequestConfig
  • func (rc *RequestConfig) OPTIONS(path string) *RequestConfig
  • func (rc *RequestConfig) PATCH(path string) *RequestConfig
  • func (rc *RequestConfig) POST(path string) *RequestConfig
  • func (rc *RequestConfig) PUT(path string) *RequestConfig
  • func (rc *RequestConfig) Run(r http.Handler, response ResponseFunc)
  • func (rc *RequestConfig) SetBody(body string) *RequestConfig
  • func (rc *RequestConfig) SetCookie(cookies H) *RequestConfig
  • func (rc *RequestConfig) SetDebug(enable bool) *RequestConfig
  • func (rc *RequestConfig) SetFileFromPath(uploads []UploadFile, params ...H) *RequestConfig
  • func (rc *RequestConfig) SetForm(body H) *RequestConfig
  • func (rc *RequestConfig) SetHeader(headers H) *RequestConfig
  • func (rc *RequestConfig) SetJSON(body D) *RequestConfig
  • func (rc *RequestConfig) SetJSONInterface(body interface{}) *RequestConfig
  • func (rc *RequestConfig) SetQuery(query H) *RequestConfig
• type ResponseFunc
• type UploadFile

Constants

const (
	Version         = "1.0"
	UserAgent       = "User-Agent"
	ContentType     = "Content-Type"
	ApplicationJSON = "application/json"
	ApplicationForm = "application/x-www-form-urlencoded"
)

Media types

Variables

var Timeout = time.Second * 10

Timeout for http client see https://medium.com/@nate510/don-t-use-go-s-default-http-client-4804cb19f779

Types

type D

type D map[string]interface{}

D is HTTP Data Type

type H

type H map[string]string

H is HTTP Header Type

type HTTPRequest

type HTTPRequest *http.Request

HTTPRequest is basic HTTP request type

type HTTPResponse

type HTTPResponse *httptest.ResponseRecorder

HTTPResponse is basic HTTP response type

type RequestConfig

type RequestConfig struct {
	Method      string
	Path        string
	Body        string
	Headers     H
	Cookies     H
	Debug       bool
	ContentType string
}

RequestConfig provide user input request structure

func New

func New() *RequestConfig

New supply initial structure

func (*RequestConfig) DELETE

func (rc *RequestConfig) DELETE(path string) *RequestConfig

DELETE is request method.

func (*RequestConfig) GET

func (rc *RequestConfig) GET(path string) *RequestConfig

GET is request method.

func (*RequestConfig) HEAD

func (rc *RequestConfig) HEAD(path string) *RequestConfig

HEAD is request method.

func (*RequestConfig) OPTIONS

func (rc *RequestConfig) OPTIONS(path string) *RequestConfig

OPTIONS is request method.

func (*RequestConfig) PATCH

func (rc *RequestConfig) PATCH(path string) *RequestConfig

PATCH is request method.

func (*RequestConfig) POST

func (rc *RequestConfig) POST(path string) *RequestConfig

POST is request method.

func (*RequestConfig) PUT

func (rc *RequestConfig) PUT(path string) *RequestConfig

PUT is request method.

func (*RequestConfig) Run

func (rc *RequestConfig) Run(r http.Handler, response ResponseFunc)

Run execute http request

func (*RequestConfig) SetBody

func (rc *RequestConfig) SetBody(body string) *RequestConfig

SetBody supply raw body.

func (*RequestConfig) SetCookie

func (rc *RequestConfig) SetCookie(cookies H) *RequestConfig

SetCookie supply cookies what you defined.

func (*RequestConfig) SetDebug

func (rc *RequestConfig) SetDebug(enable bool) *RequestConfig

SetDebug supply enable debug mode.

func (*RequestConfig) SetFileFromPath

func (rc *RequestConfig) SetFileFromPath(uploads []UploadFile, params ...H) *RequestConfig

SetFileFromPath upload new file.

func (*RequestConfig) SetForm

func (rc *RequestConfig) SetForm(body H) *RequestConfig

SetForm supply form body.

func (*RequestConfig) SetHeader

func (rc *RequestConfig) SetHeader(headers H) *RequestConfig

SetHeader supply http header what you defined.

func (*RequestConfig) SetJSON

func (rc *RequestConfig) SetJSON(body D) *RequestConfig

SetJSON supply JSON body.

func (*RequestConfig) SetJSONInterface

func (rc *RequestConfig) SetJSONInterface(body interface{}) *RequestConfig

SetJSONInterface supply JSON body

func (*RequestConfig) SetQuery

func (rc *RequestConfig) SetQuery(query H) *RequestConfig

SetQuery supply query string.

type ResponseFunc

type ResponseFunc func(HTTPResponse, HTTPRequest)

ResponseFunc response handling func type

type UploadFile

type UploadFile struct {
	Path    string
	Name    string
	Content []byte
}

UploadFile for upload file struct