dig/dig2/request_di_test.go at master · RelicOfTesla/dig · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
package dig2

import (
	"github.com/stretchr/testify/require"
	"reflect"
	"testing"
)

func TestRequestDi(t *testing.T) {
	must := require.New(t)

	di := New()
	di.AppendProvider(NewEmbedProvider(_vtIRequest, true, fProv))
	var err error

	builder := di.NewInvokeBuilder()
	err = builder.AddPlaceholderFuncProvider(func(*httpReq) {})
	must.NoError(err)
	called := 0
	var ret []reflect.Value

	type requestHello struct {
		iRequestDataParser

		Hello1 string
		Hello2 string
	}
	onGetHello := func(reqParam *requestHello) {
		must.Equal(reqParam.Hello1, "hello")
		must.Equal(reqParam.Hello2, "world")
		called++
	}
	caller_onGetHello, err := builder.Build(onGetHello)
	must.NoError(err)

	ret, err = caller_onGetHello.CastedCall(&httpReq{
		Url: "github.com",
		postData: map[string]string{
			"Hello1": "hello",
			"Hello2": "world",
		},
	})
	must.NoError(err)
	must.Equal(len(ret), 0)
	must.Equal(called, 1)

	////

	type requestGetIndex struct {
		iRequestDataParser

		NewUrl string
		Page   string
		Hello2 string
	}
	onGetIndex := func(reqParam *requestGetIndex) {
		switch called {
		case 1:
			must.Equal(reqParam.NewUrl, "baidu.com###")
			must.Equal(reqParam.Page, "aa")
			must.Equal(reqParam.Hello2, "22")
		case 2:
			must.Equal(reqParam.NewUrl, "qq.com###")
			must.Equal(reqParam.Page, "bb")
			must.Equal(reqParam.Hello2, "33")
		default:
			must.FailNow("invalid call count")
		}
		called++
	}
	caller_onGetIndex, err := builder.Build(onGetIndex)
	must.NoError(err)

	ret, err = caller_onGetIndex.CastedCall(&httpReq{
		Url:      "baidu.com",
		postData: map[string]string{"Page": "aa", "Hello2": "22"},
	})
	must.NoError(err)
	must.Equal(len(ret), 0)

	ret, err = caller_onGetIndex.CastedCall(&httpReq{
		Url:      "qq.com",
		postData: map[string]string{"Page": "bb", "Hello2": "33"},
	})
	must.NoError(err)
	must.Equal(len(ret), 0)

	must.Equal(called, 3)
}

type iRequestDataParser interface {
	_iRequestBase()
}

var _vtIRequest = (reflect.TypeOf((*iRequestDataParser)(nil))).Elem()

type httpReq struct {
	Url      string
	postData map[string]string
}

func fProv(req *httpReq, t TargetKey) (value reflect.Value, e error) {
	elementTp := t.GetType()
	var mustPtr bool
	if elementTp.Kind() == reflect.Ptr {
		elementTp = elementTp.Elem()
		mustPtr = true
	}
	ret := reflect.New(elementTp).Elem()

	for k, v := range req.postData {
		f := ret.FieldByName(k)
		if f.IsValid() {
			f.SetString(v)
		}
	}
	f := ret.FieldByName("NewUrl")
	if f.IsValid() {
		f.SetString(req.Url + "###")
	}

	if mustPtr {
		ret = ret.Addr()
	}
	return ret, nil
}

///