alice/reflect_test.go at master · magic003/alice · 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
129
130
131
132
133
134
135
136
137
138
139
package alice

import (
	"reflect"
	"testing"
)

type reflectTestModule struct {
	BaseModule
	dep1   D1 `alice:""`
	dep2   D2 `alice:"Dep2"`
	nonDep string
}

func (m *reflectTestModule) Dep1() D1 {
	return &D1Impl{}
}

func (m *reflectTestModule) Dep2() D2 {
	return &D2Impl{}
}

type nonPointerModule struct{}

func (m nonPointerModule) IsModule() bool {
	return true
}

type nonStructModule string

func (m *nonStructModule) IsModule() bool {
	return true
}

type invalidMethodModule1 struct {
	BaseModule
}

func (m *invalidMethodModule1) Dep1(str string) D1 {
	return &D1Impl{}
}

type invalidMethodModule2 struct {
	BaseModule
}

func (m *invalidMethodModule2) Dep2() (D2, error) {
	return &D2Impl{}, nil
}

func TestReflectModule(t *testing.T) {
	m := &reflectTestModule{}

	rmodule, err := reflectModule(m)

	if err != nil {
		t.Errorf("unexpected error after reflectModule(): %s", err.Error())
	}
	if rmodule.m != m {
		t.Errorf("bad m in reflectedModule: got %v, expected %v", rmodule.m, m)
	}
	expectedName := "reflectTestModule"
	if rmodule.name != expectedName {
		t.Errorf("bad name in reflectedModule: got %s, expected %s", rmodule.name, expectedName)
	}

	expectedInstances := []*instanceMethod{
		{
			name:   "Dep1",
			tp:     reflect.TypeOf((*D1)(nil)).Elem(),
			method: reflect.ValueOf(m).MethodByName("Dep1"),
		},
		{
			name:   "Dep2",
			tp:     reflect.TypeOf((*D2)(nil)).Elem(),
			method: reflect.ValueOf(m).MethodByName("Dep2"),
		},
	}
	if !reflect.DeepEqual(rmodule.instances, expectedInstances) {
		t.Errorf("bad instances in reflectedModule: got %v, expected %v",
			rmodule.instances, expectedInstances)
	}

	expectedNamedDepends := []*namedField{
		{
			name:  "Dep2",
			field: reflect.ValueOf(m).Elem().FieldByName("dep2"),
		},
	}
	if !reflect.DeepEqual(rmodule.namedDepends, expectedNamedDepends) {
		t.Errorf("bad namedDepends in reflectedModule: got %v, expected %v",
			rmodule.namedDepends, expectedNamedDepends)
	}

	expectedTypedDpends := []*typedField{
		{
			tp:    reflect.TypeOf((*D1)(nil)).Elem(),
			field: reflect.ValueOf(m).Elem().FieldByName("dep1"),
		},
	}
	if !reflect.DeepEqual(rmodule.typedDepends, expectedTypedDpends) {
		t.Errorf("bad typedDepends in reflectedModule: got %v, expected %v",
			rmodule.typedDepends, expectedTypedDpends)
	}
}

func TestReflectModule_InvalidModuleType(t *testing.T) {
	nonPtrModule := nonPointerModule{}

	_, err := reflectModule(nonPtrModule)
	if err == nil {
		t.Error("expect error after reflectModule() on non-pointer module")
	}
	t.Log(err.Error())

	nonStructModule := nonStructModule("module")
	_, err = reflectModule(&nonStructModule)
	if err == nil {
		t.Error("expect error after reflectModule() on non-struct module")
	}
	t.Log(err.Error())
}

func TestReflectModule_InvalidMethod(t *testing.T) {
	m1 := &invalidMethodModule1{}

	_, err := reflectModule(m1)
	if err == nil {
		t.Error("expect error after reflectModule() on module with 1 parameter method")
	}
	t.Log(err.Error())

	m2 := &invalidMethodModule2{}
	_, err = reflectModule(m2)
	if err == nil {
		t.Error("expect error after reflectModule() on module with 2 return values method")
	}
	t.Log(err.Error())
}