x

Author: xushiwei

README.md

@@ -1,7 +1,7 @@
 httptest
 =============
 
-[![Build Status](https://travis-ci.org/qiniu/httptest.svg?branch=master)](https://travis-ci.org/qiniu/httptest) [![GoDoc](https://godoc.org/github.com/qiniu/httptest?status.svg)](https://godoc.org/github.com/qiniu/httptest)
+[![Build Status](https://travis-ci.org/qiniu/httptest.svg?branch=master)](https://travis-ci.org/qiniu/httptest) [![GoDoc](https://godoc.org/github.com/qiniu/httptest?status.svg)](https://godoc.org/github.com/qiniu/httptest) [![Go Report Card](https://goreportcard.com/badge/github.com/qiniu/httptest)](https://goreportcard.com/report/github.com/qiniu/httptest)
 
 [![Qiniu Logo](http://open.qiniudn.com/logo.png)](http://www.qiniu.com/)
 

assert_test.go

@@ -22,4 +22,3 @@ func TestVar(t *testing.T) {
 }
 
 // ---------------------------------------------------------------------------
-

context.go

@@ -50,9 +50,9 @@ func NewRequest(ctx *Context, method, url string) *Request {
 	ctx.DeleteVar("resp")
 
 	p := &Request{
-		ctx: ctx,
+		ctx:    ctx,
 		method: method,
-		url: url,
+		url:    url,
 		header: make(http.Header),
 	}
 	ctx.Log(" ====>", method, url)
@@ -145,9 +145,9 @@ func (p *Request) Ret(code int) (resp *Response) {
 	resp1, err := p.send()
 	resp = newResponse(p, resp1, err)
 	p.ctx.MatchVar("resp", map[string]interface{}{
-		"body": resp.BodyObj,
+		"body":   resp.BodyObj,
 		"header": resp.Header,
-		"code": float64(resp.StatusCode),
+		"code":   float64(resp.StatusCode),
 	})
 	return resp.matchCode(code)
 }
@@ -159,10 +159,10 @@ type TestingT interface {
 	Log(args ...interface{})
 }
 
-type NilTestingT struct {}
+type NilTestingT struct{}
 
 func (p NilTestingT) Fatal(args ...interface{}) {}
-func (p NilTestingT) Log(args ...interface{}) {}
+func (p NilTestingT) Log(args ...interface{})   {}
 
 // ---------------------------------------------------------------------------
 
@@ -180,10 +180,10 @@ func New(t TestingT) *Context {
 
 	auths := make(map[string]TransportComposer)
 	p := &Context{
-		TestingT: t,
-		auths: auths,
-		transport: http.DefaultTransport,
-		DefaultHeader: make(http.Header),
+		TestingT:           t,
+		auths:              auths,
+		transport:          http.DefaultTransport,
+		DefaultHeader:      make(http.Header),
 		MatchResponseError: matchRespError,
 	}
 	p.initHostsMgr()
@@ -219,4 +219,3 @@ func (p *Context) Requestf(method, format string, v ...interface{}) *Request {
 }
 
 // ---------------------------------------------------------------------------
-

exec/multicase_test.go

@@ -69,4 +69,3 @@ func TestParseCases(t *testing.T) {
 }
 
 // ---------------------------------------------------------------------------
-

host.go

@@ -35,7 +35,7 @@ func (p *hostsMgr) hostOf(url string) (host string, url2 string, ok bool) {
 		return
 	}
 
-	host = url[istart:istart+n]
+	host = url[istart : istart+n]
 	portal, ok := p.hostToPortals[host]
 	if ok {
 		url2 = url[:istart] + portal + url[istart+n:]
@@ -59,4 +59,3 @@ func (p *hostsMgr) SetHost(host string, portal string) {
 }
 
 // ---------------------------------------------------------------------------
-

response_test.go

@@ -2,8 +2,8 @@ package httptest
 
 import (
 	"encoding/json"
-	"testing"
 	"net/http"
+	"testing"
 )
 
 // ---------------------------------------------------------------------------
@@ -30,23 +30,23 @@ func TestMatchHeader(t *testing.T) {
 	cases := []caseMatchHeader{
 		{
 			expected: http.Header{"a": {"a1"}, "b": {"b1", "b2"}},
-			real: http.Header{"c": {"c1"}, "a": {"a1"}, "b": {"b1", "b2"}, "d": {"d1"}},
-			ok: true,
+			real:     http.Header{"c": {"c1"}, "a": {"a1"}, "b": {"b1", "b2"}, "d": {"d1"}},
+			ok:       true,
 		},
 		{
 			expected: http.Header{"a": {"a1"}, "b": {"b1", "b2"}},
-			real: http.Header{"c": {"c1"}, "a": {"a1"}, "b": {"b1"}, "d": {"d1"}},
-			message: "unmatched response header: b",
+			real:     http.Header{"c": {"c1"}, "a": {"a1"}, "b": {"b1"}, "d": {"d1"}},
+			message:  "unmatched response header: b",
 		},
 		{
 			expected: http.Header{"a": {"a1"}, "b": {"b1", "b2"}},
-			real: http.Header{"c": {"c1"}, "a": {"a1"}, "d": {"d1"}},
-			message: "unmatched response header: b",
+			real:     http.Header{"c": {"c1"}, "a": {"a1"}, "d": {"d1"}},
+			message:  "unmatched response header: b",
 		},
 		{
 			expected: http.Header{},
-			real: http.Header{"c": {"c1"}, "a": {"a1"}, "d": {"d1"}},
-			ok: true,
+			real:     http.Header{"c": {"c1"}, "a": {"a1"}, "d": {"d1"}},
+			ok:       true,
 		},
 	}
 	for _, c := range cases {
@@ -72,73 +72,73 @@ func TestMatchBody(t *testing.T) {
 
 	cases := []caseMatchBody{
 		{
-			expBody: ``,
-			expBodyType: "application/json",
-			respBody: ``,
+			expBody:      ``,
+			expBodyType:  "application/json",
+			respBody:     ``,
 			respBodyType: "application/json",
-			ok: true,
+			ok:           true,
 		},
 		{
-			expBody: `abc`,
-			expBodyType: "",
-			respBody: `abc`,
+			expBody:      `abc`,
+			expBodyType:  "",
+			respBody:     `abc`,
 			respBodyType: "application/json",
-			ok: true,
+			ok:           true,
 		},
 		{
-			expBody: `abc`,
-			expBodyType: "application/text",
-			respBody: `abc`,
+			expBody:      `abc`,
+			expBodyType:  "application/text",
+			respBody:     `abc`,
 			respBodyType: "application/text",
-			ok: true,
+			ok:           true,
 		},
 		{
-			expBody: `abc`,
-			expBodyType: "application/text",
-			respBody: `abc`,
+			expBody:      `abc`,
+			expBodyType:  "application/text",
+			respBody:     `abc`,
 			respBodyType: "application/json",
-			message: "unmatched Content-Type",
+			message:      "unmatched Content-Type",
 		},
 		{
-			expBody: `{}`,
-			expBodyType: "application/json",
-			respBody: `{    }`,
+			expBody:      `{}`,
+			expBodyType:  "application/json",
+			respBody:     `{    }`,
 			respBodyType: "application/json",
-			ok: true,
+			ok:           true,
 		},
 		{
-			expBody: `{}`,
-			expBodyType: "application/json",
-			respBody: `{"aaa": "123"}`,
+			expBody:      `{}`,
+			expBodyType:  "application/json",
+			respBody:     `{"aaa": "123"}`,
 			respBodyType: "application/json",
-			ok: true,
+			ok:           true,
 		},
 		{
-			expBody: `{"a": "a1", "b": ["b1", "b2"]}`,
-			expBodyType: "application/json",
-			respBody: `{"c": 1, "a": "a1", "b": ["b1", "b2"], "d": 2.0}`,
+			expBody:      `{"a": "a1", "b": ["b1", "b2"]}`,
+			expBodyType:  "application/json",
+			respBody:     `{"c": 1, "a": "a1", "b": ["b1", "b2"], "d": 2.0}`,
 			respBodyType: "application/json",
-			ok: true,
+			ok:           true,
 		},
 		{
-			expBody: `{"a": "a1", "b": ["b1", "b2"]}`,
-			expBodyType: "application/json",
-			respBody: `{"c": 1, "a": "a1", "d": 2.0}`,
+			expBody:      `{"a": "a1", "b": ["b1", "b2"]}`,
+			expBodyType:  "application/json",
+			respBody:     `{"c": 1, "a": "a1", "d": 2.0}`,
 			respBodyType: "application/json",
-			message: "unmatched json response body - field b",
+			message:      "unmatched json response body - field b",
 		},
 		{
-			expBody: `{"a": "a1", "b": ["b1", "b2"]}`,
-			expBodyType: "application/json",
-			respBody: `{"c": 1, "a": "a1", "b": [1], "d": 2.0}`,
+			expBody:      `{"a": "a1", "b": ["b1", "b2"]}`,
+			expBodyType:  "application/json",
+			respBody:     `{"c": 1, "a": "a1", "b": [1], "d": 2.0}`,
 			respBodyType: "application/json",
-			message: "unmatched json response body - field b",
+			message:      "unmatched json response body - field b",
 		},
 	}
 	for _, c := range cases {
 		resp := &Response{
 			RawBody: []byte(c.respBody),
-			Header: make(http.Header),
+			Header:  make(http.Header),
 		}
 		if c.respBodyType != "" {
 			resp.BodyType = c.respBodyType
@@ -157,4 +157,3 @@ func TestMatchBody(t *testing.T) {
 }
 
 // ---------------------------------------------------------------------------
-