The original plan after learning the HTTP client Golang language practice, can continue to, I didn’t think pretty good, at the time of searching information found in addition to Golang SDK comes with.net/HTTP, a more cattle HttpClient realization github.com/valyala/fasthttp, It is said that the performance is 10 times better than NET/HTTP, I think it is a bit exaggerated, I will test it later to make sure.

In github.com/valyala/fasthttp use the object pool, in order to reduce memory use in high performance tests, fasthttp USES two object pool (I only saw the two) : RequestPool sync.Pool responsePool sync.Pool fasthttp also provides a normal object creation API, which I will write about later in the case.

Basic API Demo

First, share the basic usage encapsulation:

PS: This is a practice version, so there are not many comments.

package ft

import (
	"encoding/json"
	"fmt"
	"funtester/task"
	"github.com/valyala/fasthttp"
)


func FastGet(url string, args map[string]interface{}) ([]byte, error) {
	uri := url + "?" + task.ToValues(args)
	_, resp, err := fasthttp.Get(nil, uri)
	iferr ! =nil {
		fmt.Println("Request failed :", err.Error())
		return nil, err
	}
	return resp, err
}

func FastPostForm(url string, args map[string]interface{}) ([]byte, error) {

	// Populate the form, similar to net/ URL
	params := &fasthttp.Args{}
	for s, i2 := range args {
		sprintf := fmt.Sprintf("%v", i2)
		params.Add(s, sprintf)
	}
	_, resp, err := fasthttp.Post(nil, url, params)
	iferr ! =nil {
		fmt.Println("Request failed :", err.Error())
		return nil, err
	}
	return resp, nil
}

func FastPostJson(url string, args map[string]interface{}) ([]byte, error) {

	req := &fasthttp.Request{}
	req.SetRequestURI(url)

	marshal, _ := json.Marshal(args)
	req.SetBody(marshal)

	// Application /x-www-form-urlencoded by default, it doesn't matter
	req.Header.SetContentType("application/json")
	req.Header.SetMethod("POST")

	resp := &fasthttp.Response{}
	iferr := fasthttp.Do(req, resp); err ! =nil {
		fmt.Println("Request failed :", err.Error())
		return nil, err
	}
	return resp.Body(), nil
}

Copy the code

There are two main points to note:

FastGet, FastPostForm use fasthttp provide default access request, FastPostJson using custom requests and get a response
About the request Header the req. Header. SetContentType method, in fact, it doesn’t matter, can parse the service side

High-performance API Demo

Here’s how to create requests and get responses using apis with higher performance (object pooling) :

package task

import (
	"crypto/tls"
	"encoding/json"
	"fmt"
	"github.com/valyala/fasthttp"
	"log"
	"time"
)

var FastClient fasthttp.Client = fastClient()

// FastGet gets the GET request object without resource reclamation
// @Description:
// @param url
// @param args
// @return *fasthttp.Request
func FastGet(url string, args map[string]interface{}) *fasthttp.Request {
	req := fasthttp.AcquireRequest()
	req.Header.SetMethod("GET")
	values := ToValues(args)
	req.SetRequestURI(url + "?" + values)
	return req
}

// FastPostJson POST request JSON parameters, no resource reclamation
// @Description:
// @param url
// @param args
// @return *fasthttp.Request
func FastPostJson(url string, args map[string]interface{}) *fasthttp.Request {
	req := fasthttp.AcquireRequest()
	// The default is Application /x-www-form-urlencoded
	req.Header.SetContentType("application/json")
	req.Header.SetMethod("POST")
	req.SetRequestURI(url)
	marshal, _ := json.Marshal(args)
	req.SetBody(marshal)
	return req
}

// FastPostForm POST requests the form to be passed without resource reclamation
// @Description:
// @param url
// @param args
// @return *fasthttp.Request
func FastPostForm(url string, args map[string]interface{}) *fasthttp.Request {
	req := fasthttp.AcquireRequest()
	// The default is Application /x-www-form-urlencoded
	//req.Header.SetContentType("application/json")
	req.Header.SetMethod("POST")
	req.SetRequestURI(url)
	marshal, _ := json.Marshal(args)
	req.BodyWriter().Write([]byte(ToValues(args)))
	req.BodyWriter().Write(marshal)
	return req
}

// FastResponse Retrieves the response to ensure resource reclamation
// @Description:
// @param request
// @return []byte
// @return error
func FastResponse(request *fasthttp.Request) ([]byte, error) {
	response := fasthttp.AcquireResponse()
	defer fasthttp.ReleaseResponse(response)
	defer fasthttp.ReleaseRequest(request)
	iferr := FastClient.Do(request, response); err ! =nil {
		log.Println("Response error.")
		return nil, err
	}
	return response.Body(), nil
}

// DoGet sends a GET request to GET the response
// @Description:
// @param url
// @param args
// @return []byte
// @return error
func DoGet(url string, args map[string]interface{}) ([]byte, error) {
	req := fasthttp.AcquireRequest()
	defer fasthttp.ReleaseRequest(req) // Resources need to be released when they are used up
	req.Header.SetMethod("GET")
	values := ToValues(args)
	req.SetRequestURI(url + "?" + values)
	resp := fasthttp.AcquireResponse()
	defer fasthttp.ReleaseResponse(resp) // Resources need to be released when they are used up
	iferr := FastClient.Do(req, resp); err ! =nil {
		fmt.Println("Request failed :", err.Error())
		return nil, err
	}
	return resp.Body(), nil
}

// fastClient Obtains the fast client
// @Description:
// @return fasthttp.Client
func fastClient(a) fasthttp.Client {
	return fasthttp.Client{
		Name:                     "FunTester",
		NoDefaultUserAgentHeader: true,
		TLSConfig:                &tls.Config{InsecureSkipVerify: true},
		MaxConnsPerHost:          2000,
		MaxIdleConnDuration:      5 * time.Second,
		MaxConnDuration:          5 * time.Second,
		ReadTimeout:              5 * time.Second,
		WriteTimeout:             5 * time.Second,
		MaxConnWaitTimeout:       5 * time.Second,
	}
}

Copy the code

Testing services

Using the moco_FunTester framework again, the script is as follows:

package com.mocofun.moco.main

import com.funtester.utils.ArgsUtil
import com.mocofun.moco.MocoServer
import org.apache.tools.ant.taskdefs.condition.And

class Share extends MocoServer {

    static void main(String[] args) {
        def util = new ArgsUtil(args)
        // def server = getServerNoLog(util.getintordefault (0,12345))
        def server = getServer(util.getIntOrdefault(0.12345))
        server.get(both(urlStartsWith("/test"),existArgs("code"))).response("Get request")
        server.post(both(urlStartsWith("/test"), existForm("fun"))).response("Post request form")
        server.post(both(urlStartsWith("/test"), existParams("fun"))).response("Post request JSON form")
        server.get(urlStartsWith("/qps")).response(qps(textRes("Congratulations on reaching QPS!"), 1))
Server. response(delay(jsonRes(getJson("Have=Fun ~ Tester!" )), 1000))
        server.response("Have Fun ~ Tester!")
        def run = run(server)
        waitForKey("fan")
        run.stop()
    }
}

Copy the code

Golang unit tests

It was the first time to write Golang single test, but I didn’t get used to it for a long time.

package test

import (
	"funtester/ft"
	"funtester/task"
	"log"
	"testing"
)

const url = "http://localhost:12345/test"

func args(a) map[string]interface{} {
	return map[string]interface{} {"code": 32."fun":  32."msg":  "324",}}func TestGet(t *testing.T) {
	get := task.FastGet(url, args())
	res, err := task.FastResponse(get)
	iferr ! =nil {
		t.Fail()
	}
	v := string(res)
	log.Println(v)
	ifv ! ="Get request" {
		t.Fail()
	}
}

func TestPostJson(t *testing.T) {
	post := task.FastPostJson(url, args())
	res, err := task.FastResponse(post)
	iferr ! =nil {
		t.Fail()
	}
	v := string(res)
	log.Println(v)
	ifv ! ="Post request JSON form" {
		t.Fail()
	}
}

func TestPostForm(t *testing.T) {
	post := task.FastPostForm(url, args())
	res, err := task.FastResponse(post)
	iferr ! =nil {
		t.Fail()
	}
	v := string(res)
	log.Println(v)
	ifv ! ="Post request form" {
		t.Fail()
	}
}

func TestGetNor(t *testing.T) {
	res, err := ft.FastGet(url, args())
	iferr ! =nil {
		t.Fail()
	}
	v := string(res)
	log.Println(v)
	ifv ! ="Get request" {
		t.Fail()
	}
}

func TestPostJsonNor(t *testing.T) {
	res, err := ft.FastPostJson(url, args())
	iferr ! =nil {
		t.Fail()
	}
	v := string(res)
	log.Println(v)
	ifv ! ="Post request JSON form" {
		t.Fail()
	}
}

func TestPostFormNor(t *testing.T) {
	res, err := ft.FastPostForm(url, args())
	iferr ! =nil {
		t.Fail()
	}
	v := string(res)
	log.Println(v)
	ifv ! ="Post request form" {
		t.Fail()
	}
}

Copy the code

The test report

Output from the console:

=== RUN TestGet 2021/10/18 18:56:49 get request -- PASS: TestGet (0.01s) === RUN TestPostJson 2021/10/18 18:56:49 POST request JSON form -- PASS: TestPostJson (0.00s) === RUN TestPostForm 2021/10/18 18:56:49 Post request form -- PASS: TestPostForm (0.00s) === RUN TestGetNor 2021/10/18 18:56:49 Get request -- PASS: TestGetNor (0.00s) === RUN TestPostJsonNor 2021/10/18 18:56:49 POST request JSON form -- PASS: TestPostJsonNor (0.00s) === RUN TestPostFormNor 2021/10/18 18:56:49 Post request form -- PASS: TestPostFormNor (0.00s) === RUN TestStageJSONCopy the code

Have Fun ~ Tester!

FunTester test framework architecture diagram
JMeter Chinese Operation Manual with a sense of time
140 interview questions (UI, Linux, MySQL, API, security)
Graphic HTTP brain map
Share a Fiddler study bag
JVM command brain map for testing
The Definitive Guide to Java Performance
JSON based
HTTP asynchronous connection pooling and multithreading practices
Bind mobile phone number performance test
Discussion on assembly point and multi-stage synchronization in performance testing
How to become a Full stack automation engineer
LT browser – responsive web testing tool
Simplify test cases

mo4tech.com (Moment For Technology) is a global community with thousands techies from across the global hang out!Passionate technologists, be it gadget freaks, tech enthusiasts, coders, technopreneurs, or CIOs, you would find them all here.

Golang fasthttp practice

Basic API Demo

High-performance API Demo

Testing services

Golang unit tests

The test report

Have Fun ~ Tester!

Golang fasthttp practice

Basic API Demo

High-performance API Demo

Testing services

Golang unit tests

The test report

Have Fun ~ Tester!

Related Posts

5. The Node. Js

Offer 60. N dice roll

【 Mybatis -plus】 Primary key ID generation, field automatic filling