import (
	"fmt"

	remote "github.com/shima-park/agollo/viper-remote"
	"github.com/spf13/viper"
)

var configType = "prop"

func fetchApollo(ip, namespace string, conf *common.Config) error {
	v := viper.New()
	v.SetConfigType(configType)
	err := v.AddRemoteProvider("apollo", ip, namespace)
	if err != nil {  
		log.Error(fmt.Sprintf("AddRemoteProvider err : %s", err.Error()))
		return err
	}
	err = v.ReadRemoteConfig()
	if err != nil {
		log.Error(fmt.Sprintf("ReadRemoteConfig err : %s", err.Error()))
		return err
	}
	err = v.Unmarshal(conf)
	if err != nil {
		log.Error(fmt.Sprintf("unmarshal Config err : %s", err.Error()))
		return err
	}
	return nil
}

import (
	"errors"
	"testing"

	"github.com/agiledragon/gomonkey"
	. "github.com/smartystreets/goconvey/convey"
	"github.com/spf13/viper"
)


func Test_fetchApollo(t *testing.T) {

	var viperpt *viper.Viper
	var conf = &common.Config{}

	Convey(casenameprefix, t, func() {
		Convey(casenameprefix+"error[fetchApollo][Unmarshal]", func() {
			patch := gomonkey.ApplyMethod(reflect.TypeOf(viperpt), "AddRemoteProvider", func(_ *viper.Viper, provider, endpoint, path string) error {
				log.Debug("ApplyMethod viper.Viper.AddRemoteProvider success")
				return nil
			})
			patch.ApplyMethod(reflect.TypeOf(viperpt), "ReadRemoteConfig", func(_ *viper.Viper) error {
				log.Debug("ApplyMethod viper.Viper.ReadRemoteConfig success")
				return nil
			})
			patch.ApplyMethod(reflect.TypeOf(viperpt), "Unmarshal", func(_ *viper.Viper, rawVal interface{}, opts ...viper.DecoderConfigOption) error {
				log.Debug("ApplyMethod viper.Viper.Unmarshal success")
				return errors.New("custom errors")
			})
			defer patch.Reset()

			fetchApollo(conf)
		})
	})
}

		
import (
	"errors"
	"testing"

	"github.com/agiledragon/gomonkey"
	. "github.com/smartystreets/goconvey/convey"
	"github.com/spf13/viper"
)


func Test_fetchApollo(t *testing.T) {

	var viperpt *viper.Viper
	var conf = &common.Config{}

	Convey(casenameprefix, t, func() {
		Convey(casenameprefix+"error[fetchApollo][Unmarshal]", func() {
			//patch := gomonkey.ApplyMethod(reflect.TypeOf(viperpt), "AddRemoteProvider", func(_ *viper.Viper, provider, endpoint, path string) error {
			//	log.Debug("ApplyMethod viper.Viper.AddRemoteProvider success")
			//	return nil
			//})
			patch := gomonkey.ApplyMethod(reflect.TypeOf(viperpt), "ReadRemoteConfig", func(_ *viper.Viper) error {
				log.Debug("ApplyMethod viper.Viper.ReadRemoteConfig success")
				return nil
			})
			patch.ApplyMethod(reflect.TypeOf(viperpt), "Unmarshal", func(_ *viper.Viper, rawVal interface{}, opts ...viper.DecoderConfigOption) error {
				log.Debug("ApplyMethod viper.Viper.Unmarshal success")
				return errors.New("custom errors")
			})
			defer patch.Reset()

			fetchApollo(conf)
		})
	})
}

// http请求打桩
		var c *http.Client
		patches := gomonkey.ApplyMethod(reflect.TypeOf(c), "Do",func(c *http.Client, req *http.Request) (*http.Response, error){
			rsp := &http.Response{}
			if strings.HasPrefix(req.URL.Path, "/fcgi-bin/zx_get_seqno.fcgi") {
				rsp.Body = ioutil.NopCloser(bytes.NewBuffer([]byte(`{"retcode":"0","retmsg`)))
			} else if strings.HasPrefix(req.URL.Path, "/fcgi-bin/zx_put_file.fcgi") {
				rsp.Body = ioutil.NopCloser(bytes.NewBuffer([]byte(`{"retcode":"0","r`)))
			} else if strings.HasPrefix(req.URL.Path, "/fcgi-bin/zx_sm_recognition.fcgi") {
				rsp.Body = ioutil.NopCloser(bytes.NewBuffer([]byte(`{"retcode":"0","r`)))
			} else {
				return nil, nil
			}
			return rsp, nil
		})
		defer patches.Reset()

func FuncDo(str string) (string, error) {
	if err := ToBeMock(str); err != nil {
		return "", err
	}
	return fmt.Sprintf("hello, %s", str), nil
}

func ToBeMock(str string) error {
	return nil
}

func TestFuncDo(t *testing.T) {
	patches := gomonkey.NewPatches()
	defer patches.Reset()
	patchesBuilder := dsl.NewPatchBuilder(patches)

	// the 1st way
	/*patchesBuilder.Func(ToBeMock).
		Stubs().
		With(dsl.Any()).
		Will(dsl.Return(nil)).
		Then(dsl.Repeat(dsl.Return(fmt.Errorf("error")), 1)).
		End()*/

	tests := []struct{
		name string
		mock func()
		wantErr bool
	} {
		{
			name: "success",
			mock: func() {
				
				// the 2nd way
				patchesBuilder.Func(ToBeMock).
					Stubs().
					With(dsl.Any()).
					Will(dsl.Repeat(dsl.Return(nil), 1)).
					End()
			},
			wantErr: false,
		},
		{
			name: "error",
			mock: func() {
				patchesBuilder.Func(ToBeMock).
					Stubs().
					With(dsl.Any()).
					Will(dsl.Return(fmt.Errorf("error"))).
					End()
			},
			wantErr: true,
		},
	}

	for _, obj := range tests {
		obj.mock()
		t.Logf("===RUN\tTestDo3/%s", obj.name)
		_, err := FuncDo("str")
		if (err != nil) != obj.wantErr {
			t.Errorf("wantErr %v, actual: %v", obj.wantErr, err)
		}
	}
}

package model

import (
	"strings"
)

/*
 @Author: zhijian
 @Date: 2021/3/29 18:54
 @Description:
*/

//单例变量
var One = &Persion{Name: "test"}

//类型为公开的没有任何问题  
//可是如果这里为私有 persion 那么 ApplyMethod 最后一个参数 double interface{} 因为不在同一个包里面 就会取不到方法的 receiver 的类型 
//但是为私有 persion 的时候 ApplyMethodSeq  因为不需要显式的填这个取不到的类型 编译可以通过，可以正常使用
//这个地方有比较优雅的解决方案吗？还是我使用的姿势不对？
type Persion struct {
	Name string
}

func (p *Persion) Echo(age int) (string,error) {
	var sb strings.Builder
	sb.WriteString(p.Name)
	sb.WriteString(string(rune(age)))
	return sb.String(), nil
}

func (p *Persion) EchoMaybeDiff(age int) (string,error) {
	var sb strings.Builder
	sb.WriteString(p.Name)
	sb.WriteString(string(rune(age)))
	return sb.String(), nil
}

package svc

import "dtstack.com/dtstack/easymatrix/matrix/mock/model"

/*
 @Author: zhijian
 @Date: 2021/3/29 19:08
 @Description:
*/

func BizEcho() string  {
	echo, err := model.One.Echo(3)
	if err != nil {
		panic(err)
	}
	return echo
}


func BizEchoMaybeDiff() string  {
	echo, err := model.One.EchoMaybeDiff(3)
	if err != nil {
		panic(err)
	}
	return echo
}

package svc

import (
	"dtstack.com/dtstack/easymatrix/matrix/mock/model"
	"fmt"
	. "github.com/agiledragon/gomonkey"
	. "github.com/smartystreets/goconvey/convey"
	"reflect"
	"testing"
)

/*
 @Author: zhijian
 @Date: 2021/3/29 19:18
 @Description:
*/

func TestEchoMaybeDiff(t *testing.T) {
	Convey("test",t,
		func() {
			outputs := []OutputCell{
				{Values: Params{`test1`, nil}},// 模拟函数的第1次输出

				{Values: Params{`test2`, nil}},// 模拟函数的第2次输出

				{Values: Params{`test3`, nil}},// 模拟函数的第3次输出
			}
			patches := ApplyMethodSeq(reflect.TypeOf(model.One), "EchoMaybeDiff", outputs)
			defer patches.Reset()
			echo1 := BizEchoMaybeDiff()
			echo2 :=BizEchoMaybeDiff()
			echo3 :=BizEchoMaybeDiff()
			fmt.Println(echo1)
			fmt.Println(echo2)
			fmt.Println(echo3)
			ShouldNotBeNil(echo3)
		})
}

func TestBizEcho(t *testing.T) {
	Convey("test",t,
		func() {
			patches := ApplyMethod(reflect.TypeOf(model.One), "Echo", func(_ *model.Persion, i int) (string, error) {
				return "test", nil
			})
			defer patches.Reset()
			bizEcho := BizEcho()
			fmt.Println(bizEcho)
			ShouldEqual(bizEcho, "test")
		})
}

func (c *Controller) ServeJSON(encoding ...bool) {
	var (
		hasIndent   = BConfig.RunMode != PROD
		hasEncoding = len(encoding) > 0 && encoding[0]
	)

	c.Ctx.Output.JSON(c.Data["json"], hasIndent, hasEncoding)
}

var c *myController
patches := ApplyMethod(reflect.TypeOf(c), "ServeJSON",func(*myController, ...bool) {
    //do nothing
})
defer patches.Reset()

package main

import (
	"fmt"
	"reflect"

	"github.com/agiledragon/gomonkey"
)
type B struct {
	a string
}
func (b *B) Get(s string) string {
	return ""
}
func (b *B) Put(s string) string {
	var i int
	for ; i < 100; i++ {
		b.a = "iiiii"
	}
	return ""
}
func main(){
	var b *B
	gomonkey.ApplyMethod(reflect.TypeOf(b), "Get",
		func(_ *B, subPath string) string {
			return subPath
		})
	fmt.Println("get:", ws.Get("get")) // want "get"

	gomonkey.ApplyMethod(reflect.TypeOf(b), "Put",
		func(_ *B, subPath string) string {
			return subPath
		})
	fmt.Println("put:", ws.Put("put")) 
}

import (
	"reflect"
	"testing"

	"github.com/agiledragon/gomonkey"
	"github.com/gin-gonic/gin"
	"github.com/golang/mock/gomock"
)

func TestSeq_GIN(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	ginCtx := &gin.Context{
		Params: gin.Params{
			gin.Param{
				Key:   "ns",
				Value: "aaaa",
			},
		},
	}

	patches := gomonkey.ApplyMethod(reflect.TypeOf(ginCtx), "Param", func(_ *gin.Context, _ string) string {
		return "bbbb"
	})

	defer patches.Reset()

	println("===1", ginCtx.Param("ns"))
	t.Log("===2", ginCtx.Param("ns"))
}

func testGoroutine() {
	go PrintNum()
	time.Sleep(time.Second * 1)
}

// PrintNum printnum
func PrintNum() {
	for i := 0; i < 5; i++ {
		fmt.Print(i)
	}
}

func Test_testGoroutine(t *testing.T) {
	Convey("test function", t, func() {
		patches1 := ApplyFunc(PrintNum, func() {
			fmt.Print("mock")
		})

		defer patches1.Reset()
		testGoroutine()
	})
}

//test/func_test.go
package test

import (
	. "github.com/agiledragon/gomonkey"
	. "github.com/smartystreets/goconvey/convey"
	"testing"
)

func TestGetGroupLastSend(t *testing.T) {
	Convey("Comparing two variables", t, func() {
		num := 333
		ApplyFunc(GetB, func() int {
			return num
		})
		result := GetA()
		So(num, ShouldEqual, result)
	})
}

//test/func.go
package test

func GetA() int {
	return GetB()
}

func GetB() int {
	return 1
}

  Expected: '1'
  Actual:   '333'
  (Should be equal)