Move mock to mock directory

client/httplib/mock/mock.go

@@ -0,0 +1,80 @@
+// Copyright 2020 beego
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mock
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/beego/beego/v2/client/httplib"
+	"github.com/beego/beego/v2/core/logs"
+)
+
+const mockCtxKey = "beego-httplib-mock"
+
+func init() {
+	InitMockSetting()
+}
+
+type Stub interface {
+	Mock(cond RequestCondition, resp *http.Response, err error)
+	Clear()
+	MockByPath(path string, resp *http.Response, err error)
+}
+
+var mockFilter = &MockResponseFilter{}
+
+func InitMockSetting() {
+	httplib.AddDefaultFilter(mockFilter.FilterChain)
+}
+
+func StartMock() Stub {
+	return mockFilter
+}
+
+func CtxWithMock(ctx context.Context, mock... *Mock) context.Context {
+	return context.WithValue(ctx, mockCtxKey, mock)
+}
+
+func mockFromCtx(ctx context.Context) []*Mock {
+	ms := ctx.Value(mockCtxKey)
+	if ms != nil {
+		if res, ok := ms.([]*Mock); ok {
+			return res
+		}
+		logs.Error("mockCtxKey found in context, but value is not type []*Mock")
+	}
+	return nil
+}
+
+type Mock struct {
+	cond RequestCondition
+	resp *http.Response
+	err  error
+}
+
+func NewMockByPath(path string, resp *http.Response, err error) *Mock {
+	return NewMock(NewSimpleCondition(path), resp, err)
+}
+
+func NewMock(con RequestCondition, resp *http.Response, err error) *Mock {
+	return &Mock{
+		cond: con,
+		resp: resp,
+		err: err,
+	}
+}
+
+

client/httplib/mock/mock_condition.go

@@ -0,0 +1,177 @@
+// Copyright 2020 beego
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mock
+
+import (
+	"context"
+	"encoding/json"
+	"net/textproto"
+	"regexp"
+
+	"github.com/beego/beego/v2/client/httplib"
+)
+
+type RequestCondition interface {
+	Match(ctx context.Context, req *httplib.BeegoHTTPRequest) bool
+}
+
+// reqCondition create condition
+// - path: same path
+// - pathReg: request path match pathReg
+// - method: same method
+// - Query parameters (key, value)
+// - header (key, value)
+// - Body json format, contains specific (key, value).
+type SimpleCondition struct {
+	pathReg string
+	path    string
+	method  string
+	query   map[string]string
+	header  map[string]string
+	body    map[string]interface{}
+}
+
+func NewSimpleCondition(path string, opts ...simpleConditionOption) *SimpleCondition {
+	sc := &SimpleCondition{
+		path:   path,
+		query:  make(map[string]string),
+		header: make(map[string]string),
+		body:   map[string]interface{}{},
+	}
+	for _, o := range opts {
+		o(sc)
+	}
+	return sc
+}
+
+func (sc *SimpleCondition) Match(ctx context.Context, req *httplib.BeegoHTTPRequest) bool {
+	res := true
+	if len(sc.path) > 0 {
+		res = sc.matchPath(ctx, req)
+	} else if len(sc.pathReg) > 0 {
+		res = sc.matchPathReg(ctx, req)
+	} else {
+		return false
+	}
+	return res &&
+		sc.matchMethod(ctx, req) &&
+		sc.matchQuery(ctx, req) &&
+		sc.matchHeader(ctx, req) &&
+		sc.matchBodyFields(ctx, req)
+}
+
+func (sc *SimpleCondition) matchPath(ctx context.Context, req *httplib.BeegoHTTPRequest) bool {
+	path := req.GetRequest().URL.Path
+	return path == sc.path
+}
+
+func (sc *SimpleCondition) matchPathReg(ctx context.Context, req *httplib.BeegoHTTPRequest) bool {
+	path := req.GetRequest().URL.Path
+	if b, err := regexp.Match(sc.pathReg, []byte(path)); err == nil {
+		return b
+	}
+	return false
+}
+
+func (sc *SimpleCondition) matchQuery(ctx context.Context, req *httplib.BeegoHTTPRequest) bool {
+	qs := req.GetRequest().URL.Query()
+	for k, v := range sc.query {
+		if uv, ok := qs[k]; !ok || uv[0] != v {
+			return false
+		}
+	}
+	return true
+}
+
+func (sc *SimpleCondition) matchHeader(ctx context.Context, req *httplib.BeegoHTTPRequest) bool {
+	headers := req.GetRequest().Header
+	for k, v := range sc.header {
+		if uv, ok := headers[k]; !ok || uv[0] != v {
+			return false
+		}
+	}
+	return true
+}
+
+func (sc *SimpleCondition) matchBodyFields(ctx context.Context, req *httplib.BeegoHTTPRequest) bool {
+	if len(sc.body) == 0 {
+		return true
+	}
+	getBody := req.GetRequest().GetBody
+	body, err := getBody()
+	if err != nil {
+		return false
+	}
+	bytes := make([]byte, req.GetRequest().ContentLength)
+	_, err = body.Read(bytes)
+	if err != nil {
+		return false
+	}
+
+
+	m := make(map[string]interface{})
+
+	err = json.Unmarshal(bytes, &m)
+
+	if err != nil {
+		return false
+	}
+
+	for k, v := range sc.body {
+		if uv, ok := m[k]; !ok || uv != v {
+			return false
+		}
+	}
+	return true
+}
+
+func (sc *SimpleCondition) matchMethod(ctx context.Context, req *httplib.BeegoHTTPRequest) bool {
+	if len(sc.method) > 0 {
+		return sc.method == req.GetRequest().Method
+	}
+	return true
+}
+
+type simpleConditionOption func(sc *SimpleCondition)
+
+func WithPathReg(pathReg string) simpleConditionOption {
+	return func(sc *SimpleCondition) {
+		sc.pathReg = pathReg
+	}
+}
+
+func WithQuery(key, value string) simpleConditionOption {
+	return func(sc *SimpleCondition) {
+		sc.query[key] = value
+	}
+}
+
+func WithHeader(key, value string) simpleConditionOption {
+	return func(sc *SimpleCondition) {
+		sc.header[textproto.CanonicalMIMEHeaderKey(key)] = value
+	}
+}
+
+func WithJsonBodyFields(field string, value interface{}) simpleConditionOption {
+	return func(sc *SimpleCondition) {
+		sc.body[field] = value
+	}
+}
+
+func WithMethod(method string) simpleConditionOption {
+	return func(sc *SimpleCondition) {
+		sc.method = method
+	}
+}

client/httplib/mock/mock_condition_test.go

@@ -0,0 +1,124 @@
+// Copyright 2020 beego
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mock
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/beego/beego/v2/client/httplib"
+)
+
+func init() {
+
+}
+
+func TestSimpleCondition_MatchPath(t *testing.T) {
+	sc := NewSimpleCondition("/abc/s")
+	res := sc.Match(context.Background(), httplib.Get("http://localhost:8080/abc/s"))
+	assert.True(t, res)
+}
+
+func TestSimpleCondition_MatchQuery(t *testing.T) {
+	k, v := "my-key", "my-value"
+	sc := NewSimpleCondition("/abc/s")
+	res := sc.Match(context.Background(), httplib.Get("http://localhost:8080/abc/s?my-key=my-value"))
+	assert.True(t, res)
+
+	sc = NewSimpleCondition("/abc/s", WithQuery(k, v))
+	res = sc.Match(context.Background(), httplib.Get("http://localhost:8080/abc/s?my-key=my-value"))
+	assert.True(t, res)
+
+	res = sc.Match(context.Background(), httplib.Get("http://localhost:8080/abc/s?my-key=my-valuesss"))
+	assert.False(t, res)
+
+	res = sc.Match(context.Background(), httplib.Get("http://localhost:8080/abc/s?my-key-a=my-value"))
+	assert.False(t, res)
+
+	res = sc.Match(context.Background(), httplib.Get("http://localhost:8080/abc/s?my-key=my-value&abc=hello"))
+	assert.True(t, res)
+}
+
+func TestSimpleCondition_MatchHeader(t *testing.T) {
+	k, v := "my-header", "my-header-value"
+	sc := NewSimpleCondition("/abc/s")
+	req := httplib.Get("http://localhost:8080/abc/s")
+	assert.True(t, sc.Match(context.Background(), req))
+
+	req = httplib.Get("http://localhost:8080/abc/s")
+	req.Header(k, v)
+	assert.True(t, sc.Match(context.Background(), req))
+
+	sc = NewSimpleCondition("/abc/s", WithHeader(k, v))
+	req.Header(k, v)
+	assert.True(t, sc.Match(context.Background(), req))
+
+	req.Header(k, "invalid")
+	assert.False(t, sc.Match(context.Background(), req))
+}
+
+func TestSimpleCondition_MatchBodyField(t *testing.T) {
+
+	sc := NewSimpleCondition("/abc/s")
+	req := httplib.Post("http://localhost:8080/abc/s")
+
+	assert.True(t, sc.Match(context.Background(), req))
+
+	req.Body(`{
+    "body-field": 123
+}`)
+	assert.True(t, sc.Match(context.Background(), req))
+
+	k := "body-field"
+	v := float64(123)
+	sc = NewSimpleCondition("/abc/s", WithJsonBodyFields(k, v))
+	assert.True(t, sc.Match(context.Background(), req))
+
+	sc = NewSimpleCondition("/abc/s", WithJsonBodyFields(k, v))
+	req.Body(`{
+    "body-field": abc
+}`)
+	assert.False(t, sc.Match(context.Background(), req))
+
+	sc = NewSimpleCondition("/abc/s", WithJsonBodyFields("body-field", "abc"))
+	req.Body(`{
+    "body-field": "abc"
+}`)
+	assert.True(t, sc.Match(context.Background(), req))
+}
+
+func TestSimpleCondition_Match(t *testing.T) {
+	sc := NewSimpleCondition("/abc/s")
+	req := httplib.Post("http://localhost:8080/abc/s")
+
+	assert.True(t, sc.Match(context.Background(), req))
+
+	sc = NewSimpleCondition("/abc/s", WithMethod("POST"))
+	assert.True(t, sc.Match(context.Background(), req))
+
+	sc = NewSimpleCondition("/abc/s", WithMethod("GET"))
+	assert.False(t, sc.Match(context.Background(), req))
+}
+
+func TestSimpleCondition_MatchPathReg(t *testing.T) {
+	sc := NewSimpleCondition("", WithPathReg(`\/abc\/.*`))
+	req := httplib.Post("http://localhost:8080/abc/s")
+	assert.True(t, sc.Match(context.Background(), req))
+
+	req = httplib.Post("http://localhost:8080/abcd/s")
+	assert.False(t, sc.Match(context.Background(), req))
+}

client/httplib/mock/mock_filter.go

@@ -0,0 +1,61 @@
+// Copyright 2020 beego
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mock
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/beego/beego/v2/client/httplib"
+)
+
+// MockResponse will return mock response if find any suitable mock data
+// if you want to test your code using httplib, you need this.
+type MockResponseFilter struct {
+	ms []*Mock
+}
+
+func NewMockResponseFilter() *MockResponseFilter {
+	return &MockResponseFilter{
+		ms: make([]*Mock, 0, 1),
+	}
+}
+
+func (m *MockResponseFilter) FilterChain(next httplib.Filter) httplib.Filter {
+	return func(ctx context.Context, req *httplib.BeegoHTTPRequest) (*http.Response, error) {
+		ms := mockFromCtx(ctx)
+		ms = append(ms, m.ms...)
+		for _, mock := range ms {
+			if mock.cond.Match(ctx, req) {
+				return mock.resp, mock.err
+			}
+		}
+		return next(ctx, req)
+	}
+}
+
+func (m *MockResponseFilter) MockByPath(path string, resp *http.Response, err error) {
+	m.Mock(NewSimpleCondition(path), resp, err)
+}
+
+func (m *MockResponseFilter) Clear() {
+	m.ms = make([]*Mock, 0, 1)
+}
+
+// Mock add mock data
+// If the cond.Match(...) = true, the resp and err will be returned
+func (m *MockResponseFilter) Mock(cond RequestCondition, resp *http.Response, err error) {
+	m.ms = append(m.ms, NewMock(cond, resp, err))
+}

client/httplib/mock/mock_filter_test.go

@@ -0,0 +1,63 @@
+// Copyright 2020 beego
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mock
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/beego/beego/v2/client/httplib"
+)
+
+func TestMockResponseFilter_FilterChain(t *testing.T) {
+	req := httplib.Get("http://localhost:8080/abc/s")
+	ft := NewMockResponseFilter()
+
+	expectedResp := httplib.NewHttpResponseWithJsonBody(`{}`)
+	expectedErr := errors.New("expected error")
+	ft.Mock(NewSimpleCondition("/abc/s"), expectedResp, expectedErr)
+
+	req.AddFilters(ft.FilterChain)
+
+	resp, err := req.DoRequest()
+	assert.Equal(t, expectedErr, err)
+	assert.Equal(t, expectedResp, resp)
+
+	req = httplib.Get("http://localhost:8080/abcd/s")
+	req.AddFilters(ft.FilterChain)
+
+	resp, err = req.DoRequest()
+	assert.NotEqual(t, expectedErr, err)
+	assert.NotEqual(t, expectedResp, resp)
+
+	req = httplib.Get("http://localhost:8080/abc/s")
+	req.AddFilters(ft.FilterChain)
+	expectedResp1 := httplib.NewHttpResponseWithJsonBody(map[string]string{})
+	expectedErr1 := errors.New("expected error")
+	ft.Mock(NewSimpleCondition("/abc/abs/bbc"), expectedResp1, expectedErr1)
+
+	resp, err = req.DoRequest()
+	assert.Equal(t, expectedErr, err)
+	assert.Equal(t, expectedResp, resp)
+
+	req = httplib.Get("http://localhost:8080/abc/abs/bbc")
+	req.AddFilters(ft.FilterChain)
+	ft.Mock(NewSimpleCondition("/abc/abs/bbc"), expectedResp1, expectedErr1)
+	resp, err = req.DoRequest()
+	assert.Equal(t, expectedErr1, err)
+	assert.Equal(t, expectedResp1, resp)
+}

client/httplib/mock/mock_test.go

@@ -0,0 +1,77 @@
+// Copyright 2020 beego
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mock
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/beego/beego/v2/client/httplib"
+)
+
+func TestStartMock(t *testing.T) {
+
+	// httplib.defaultSetting.FilterChains = []httplib.FilterChain{mockFilter.FilterChain}
+
+	stub := StartMock()
+	// defer stub.Clear()
+
+	expectedResp := httplib.NewHttpResponseWithJsonBody([]byte(`{}`))
+	expectedErr := errors.New("expected err")
+
+	stub.Mock(NewSimpleCondition("/abc"), expectedResp, expectedErr)
+
+	resp, err := OriginalCodeUsingHttplib()
+
+	assert.Equal(t, expectedErr, err)
+	assert.Equal(t, expectedResp, resp)
+
+}
+
+// TestStartMock_Isolation Test StartMock that
+// mock only work for this request
+func TestStartMock_Isolation(t *testing.T) {
+	// httplib.defaultSetting.FilterChains = []httplib.FilterChain{mockFilter.FilterChain}
+	// setup global stub
+	stub := StartMock()
+	globalMockResp := httplib.NewHttpResponseWithJsonBody([]byte(`{}`))
+	globalMockErr := errors.New("expected err")
+	stub.Mock(NewSimpleCondition("/abc"), globalMockResp, globalMockErr)
+
+	expectedResp := httplib.NewHttpResponseWithJsonBody(struct {
+		A string `json:"a"`
+	}{
+		A: "aaa",
+	})
+	expectedErr := errors.New("expected err aa")
+	m := NewMockByPath("/abc", expectedResp, expectedErr)
+	ctx := CtxWithMock(context.Background(), m)
+
+	resp, err := OriginnalCodeUsingHttplibPassCtx(ctx)
+	assert.Equal(t, expectedErr, err)
+	assert.Equal(t, expectedResp, resp)
+}
+
+func OriginnalCodeUsingHttplibPassCtx(ctx context.Context) (*http.Response, error) {
+	return httplib.Get("http://localhost:7777/abc").DoRequestWithCtx(ctx)
+}
+
+func OriginalCodeUsingHttplib() (*http.Response, error){
+	return httplib.Get("http://localhost:7777/abc").DoRequest()
+}