x

Author: xushiwei

assert.go

@@ -0,0 +1,129 @@
+package httptest
+
+import (
+	"reflect"
+
+	"github.com/qiniu/x/jsonutil"
+)
+
+// ---------------------------------------------------------------------------
+
+func castFloat(v interface{}) (float64, bool) {
+
+	t := reflect.ValueOf(v)
+
+	kind := t.Kind()
+	if kind < reflect.Int || kind > reflect.Float64 {
+		return 0, false
+	}
+
+	if kind <= reflect.Int64 {
+		return float64(t.Int()), true
+	}
+	if kind <= reflect.Uintptr {
+		return float64(t.Uint()), true
+	}
+	return t.Float(), true
+}
+
+func Equal(v1, v2 interface{}) bool {
+
+	f1, ok1 := castFloat(v1)
+	f2, ok2 := castFloat(v2)
+	if ok1 != ok2 {
+		return false
+	}
+	if ok1 && f1 == f2 {
+		return true
+	}
+	return reflect.DeepEqual(v1, v2)
+}
+
+func EqualSet(obj1, obj2 interface{}) bool {
+
+	var v interface{}
+	if text, ok := obj1.(string); ok {
+		err := jsonutil.Unmarshal(text, &v)
+		if err != nil {
+			return false
+		}
+		obj1 = v
+	}
+
+	v1 := reflect.ValueOf(obj1)
+	if v1.Kind() != reflect.Slice {
+		return false
+	}
+
+	if text, ok := obj2.(string); ok {
+		err := jsonutil.Unmarshal(text, &v)
+		if err != nil {
+			return false
+		}
+		obj2 = v
+	}
+
+	v2 := reflect.ValueOf(obj2)
+	if v2.Kind() != reflect.Slice {
+		return false
+	}
+
+	if v1.Len() != v2.Len() {
+		return false
+	}
+	for i := 0; i < v1.Len(); i++ {
+		item1 := v1.Index(i)
+		if !hasElem(item1.Interface(), v2) {
+			return false
+		}
+	}
+	return true
+}
+
+func hasElem(item1 interface{}, v2 reflect.Value) bool {
+
+	for j := 0; j < v2.Len(); j++ {
+		item2 := v2.Index(j)
+		if Equal(item1, item2.Interface()) {
+			return true
+		}
+	}
+	return false
+}
+
+// ---------------------------------------------------------------------------
+
+type Var struct {
+	Data interface{}
+	Ok   bool
+}
+
+func (p Var) Equal(v interface{}) bool {
+
+	return p.Ok && Equal(p.Data, v)
+}
+
+func (p Var) EqualObject(obj string) bool {
+
+	if !p.Ok {
+		return false
+	}
+
+	var v interface{}
+	err := jsonutil.Unmarshal(obj, &v)
+	if err != nil {
+		return false
+	}
+
+	return Equal(p.Data, v)
+}
+
+func (p Var) EqualSet(obj interface{}) bool {
+
+	if !p.Ok {
+		return false
+	}
+	return EqualSet(p.Data, obj)
+}
+
+// ---------------------------------------------------------------------------

assert_test.go

@@ -0,0 +1,25 @@
+package httptest
+
+import (
+	"testing"
+)
+
+// ---------------------------------------------------------------------------
+
+func TestVar(t *testing.T) {
+
+	if !(Var{1, true}.EqualObject("1")) {
+		t.Fatal("EqualObject failed")
+	}
+
+	if !(Var{[]float64{1, 2}, true}.EqualSet("[2, 1]")) {
+		t.Fatal("EqualSet failed")
+	}
+
+	if (Var{[]float64{1, 2, 3}, true}.EqualSet("[2, 1]")) {
+		t.Fatal("EqualSet failed")
+	}
+}
+
+// ---------------------------------------------------------------------------
+

context.go

@@ -0,0 +1,222 @@
+package httptest
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+)
+
+// ---------------------------------------------------------------------------
+
+type TransportComposer interface {
+	Compose(base http.RoundTripper) http.RoundTripper
+}
+
+type Executor interface {
+	Exec(ctx *Context, code string)
+}
+
+// ---------------------------------------------------------------------------
+
+func mimeType(ct string) string {
+
+	if ct == "form" {
+		return "application/x-www-form-urlencoded"
+	}
+	if ct == "binary" {
+		return "application/octet-stream"
+	}
+	if strings.Index(ct, "/") < 0 {
+		return "application/" + ct
+	}
+	return ct
+}
+
+// ---------------------------------------------------------------------------
+
+type Request struct {
+	method   string
+	url      string
+	auth     TransportComposer
+	ctx      *Context
+	header   http.Header
+	bodyType string
+	body     string
+}
+
+func NewRequest(ctx *Context, method, url string) *Request {
+
+	ctx.DeleteVar("resp")
+
+	p := &Request{
+		ctx: ctx,
+		method: method,
+		url: url,
+		header: make(http.Header),
+	}
+	ctx.Log(" ====>", method, url)
+	return p
+}
+
+func (p *Request) WithAuth(v interface{}) *Request {
+
+	if v == nil {
+		p.auth = nil
+		return p
+	}
+	if name, ok := v.(string); ok {
+		auth, ok := p.ctx.auths[name]
+		if !ok {
+			p.ctx.Fatal("WithAuth failed: auth not found -", name)
+		}
+		p.auth = auth
+		return p
+	}
+	if auth, ok := v.(TransportComposer); ok {
+		p.auth = auth
+		return p
+	}
+	p.ctx.Fatal("WithAuth failed: invalid auth -", v)
+	return p
+}
+
+func (p *Request) WithHeader(key string, values ...string) *Request {
+
+	p.header[key] = values
+	return p
+}
+
+func (p *Request) WithBody(bodyType, body string) *Request {
+
+	p.bodyType = mimeType(bodyType)
+	p.body = body
+	return p
+}
+
+func (p *Request) WithBodyf(bodyType, format string, v ...interface{}) *Request {
+
+	p.bodyType = mimeType(bodyType)
+	p.body = fmt.Sprintf(format, v...)
+	return p
+}
+
+func mergeHeader(to, from http.Header) {
+
+	for k, v := range from {
+		to[k] = v
+	}
+}
+
+func (p *Request) send() (resp *http.Response, err error) {
+
+	var body io.Reader
+	if len(p.body) > 0 {
+		body = strings.NewReader(p.body)
+	}
+	req, err := p.ctx.newRequest(p.method, p.url, body)
+	if err != nil {
+		p.ctx.Fatal("http.NewRequest failed:", p.method, p.url, p.body, err)
+		return
+	}
+
+	mergeHeader(req.Header, p.ctx.DefaultHeader)
+
+	if body != nil {
+		if p.bodyType != "" {
+			req.Header.Set("Content-Type", p.bodyType)
+		}
+		req.ContentLength = int64(len(p.body))
+	}
+
+	mergeHeader(req.Header, p.header)
+
+	t := p.ctx.transport
+	if p.auth != nil {
+		t = p.auth.Compose(t)
+	}
+
+	c := &http.Client{Transport: t}
+	return c.Do(req)
+}
+
+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,
+		"header": resp.Header,
+		"code": float64(resp.StatusCode),
+	})
+	return resp.matchCode(code)
+}
+
+// ---------------------------------------------------------------------------
+
+type TestingT interface {
+	Fatal(args ...interface{})
+	Log(args ...interface{})
+}
+
+type NilTestingT struct {}
+
+func (p NilTestingT) Fatal(args ...interface{}) {}
+func (p NilTestingT) Log(args ...interface{}) {}
+
+// ---------------------------------------------------------------------------
+
+type Context struct {
+	TestingT
+	varsMgr
+	hostsMgr
+	transport          http.RoundTripper
+	auths              map[string]TransportComposer
+	DefaultHeader      http.Header
+	MatchResponseError func(message string, req *Request, resp *Response)
+}
+
+func New(t TestingT) *Context {
+
+	auths := make(map[string]TransportComposer)
+	p := &Context{
+		TestingT: t,
+		auths: auths,
+		transport: http.DefaultTransport,
+		DefaultHeader: make(http.Header),
+		MatchResponseError: matchRespError,
+	}
+	p.initHostsMgr()
+	p.initVarsMgr()
+	return p
+}
+
+func (p *Context) SetTransport(transport http.RoundTripper) {
+
+	p.transport = transport
+}
+
+func (p *Context) SetAuth(name string, auth TransportComposer) {
+
+	p.auths[name] = auth
+}
+
+func (p *Context) Exec(executor Executor, code string) *Context {
+
+	executor.Exec(p, code)
+	return p
+}
+
+func (p *Context) Request(method, url string) *Request {
+
+	return NewRequest(p, method, url)
+}
+
+func (p *Context) Requestf(method, format string, v ...interface{}) *Request {
+
+	url := fmt.Sprintf(format, v...)
+	return NewRequest(p, method, url)
+}
+
+// ---------------------------------------------------------------------------
+