Added tests for atesting

ok  	github.com/go-autowire/autowire/atesting	0.504s	coverage: 100.0% of statements

Signed-off-by: Filip Petrov <[email protected]>

Author: FilipVPetrov

README.md

@@ -7,4 +7,16 @@
 [release]: https://github.com/go-autowire/autowire
 
 [report-card-img]: https://goreportcard.com/badge/github.com/go-autowire/autowire
-[report-card]: https://goreportcard.com/report/github.com/go-autowire/autowire
+[report-card]: https://goreportcard.com/report/github.com/go-autowire/autowire
+
+Reflection based dependency injection toolkit for Golang.
+
+This README is in working in progress state.
+
+## Installation
+
+The whole project is based on go modules. 
+To get the latest version, use go1.16+ and fetch it using the go get command. For example:
+```bash
+go get github.com/go-autowire/autowire
+```

atesting/testing.go

@@ -3,50 +3,27 @@ package atesting
 
 import (
 	"container/list"
+	. "github.com/go-autowire/autowire"
+	"github.com/go-autowire/autowire/internal"
 	"log"
 	"reflect"
-	"unicode"
-
-	"github.com/go-autowire/autowire"
 )
 
-// Spy Function is replacing object field with the one provided in the function as a second argument.
-// Spy Function detects automatically which field could be replaced with the provided one.
-// Important note: In order to traverse fields of the unexported fields we need to implement Getters.
-// As shown inside example package, we are replacing AuditClient with our mock implementation and in order to reach this
-// field we need Getter.
+// Spy Function is replacing object field with the one provided in the function as a variadic arguments.
+// Spy Function will detect fully automatically which field could be replaced
+// with the provided one as variadic arguments.
+// As shown inside example package, we are replacing AuditClient with our mock implementation.
 // Example:
-//   atesting.Spy(application, &TestAuditClient{})
-// Or this is equivalent of
+//   Spy(application, &TestAuditClient{})
+// Or this is equivalent of doing it manually
 //   application.UserSvc().SetAuditClient(&TestAuditClient{})
-// Getter UserSvc() is used to access userSvc field, which is unexported.
-// For more information take a look at example package.
+// When we don't use Spy function, we need to provide Getter method UserSvc() in order to
+// access unexported userSvc field.
+// For more information take a look at test file in example package.
 // Parameters of Spy function:
-//   - `v`          : pointer to structure inside which spy object will be applied
-//   - `dependency` : pointer to structure which will be injected
-func Spy(v interface{}, dependency interface{}) {
-	slice := []interface{}{dependency}
-	Spies(v, slice)
-}
-
-// Spies Function is replacing object fields with the list of provided dependencies
-// in the function as a second argument. Spy Function detects automatically which field
-// could be replaced with the provided one in the list of dependencies.
-// Important note: In order to traverse fields of the unexported fields we need to implement Getters.
-// As shown inside example package, we are replacing AuditClient with our mock implementation and in order to reach this
-// field we need Getter.
-// Example:
-//   	atesting.Spies(application, []interface{}{&TestPaymentServiceTest{}, &TestAuditClient{}})
-// Or this is equivalent of
-//   application.UserSvc().SetAuditClient(&TestAuditClient{})
-//   application.UserSvc().PaymentSvc = &TestPaymentServiceTest{}
-// Getter UserSvc() is used to access userSvc field, which is unexported. In case of PaymentSvc it is not required
-// as field PaymentSvc is exported.
-// Parameters of Spies function:
-//   - `v`            : structure inside which spy objects will be applied
-//   - `dependencies` : list of dependencies which will be injected
-// For more information take a look at example package.
-func Spies(v interface{}, dependencies []interface{}) {
+//   - `v`          : pointer to structure inside which spy object will be injected
+//   - `dependencies` : this is variadic argument, pointer to mocked structures which are gonna be injected
+func Spy(v interface{}, dependencies ...interface{}) {
 	queue := list.New()
 	queue.PushBack(v)
 	for queue.Len() > 0 {
@@ -57,56 +34,37 @@ func Spies(v interface{}, dependencies []interface{}) {
 		switch value.Kind() {
 		case reflect.Ptr:
 			elem = value.Elem()
-		case reflect.Struct:
-			elem = value
 		}
 		for i := 0; i < elem.NumField(); i++ {
 			field := elem.Type().Field(i)
-			tag, ok := field.Tag.Lookup(autowire.Tag)
+			tag, ok := field.Tag.Lookup(Tag)
 			if ok {
 				if tag != "" {
-					for _, dependency := range dependencies {
-						dependValue := reflect.ValueOf(dependency)
+					for _, currentDependency := range dependencies {
+						dependValue := reflect.ValueOf(currentDependency)
 						if dependValue.Type().Implements(field.Type) {
 							t := reflect.New(dependValue.Type())
-							log.Println("Injecting Spy on dependency by tag " + tag + " will be used " + t.Type().String())
-							autowire.Autowire(dependency)
-							setFieldValue(value, elem, i, dependency)
+							log.Println("Injecting Spy on currentDependency by tag " + tag + " will be used " + t.Type().String())
+							Autowire(currentDependency)
+							internal.SetFieldValue(elem, i, currentDependency)
+						}
+					}
+				} else {
+					for _, currentDependency := range dependencies {
+						log.Printf("Checking compatability between %s & %s", reflect.TypeOf(currentDependency), elem.Field(i).Type())
+						if reflect.TypeOf(currentDependency) == elem.Field(i).Type() {
+							internal.SetFieldValue(elem, i, currentDependency)
 						}
 					}
 				}
 				if !elem.Field(i).IsNil() {
 					if elem.Field(i).Elem().CanInterface() {
-						queue.PushBack(autowire.Autowired(elem.Field(i).Elem().Interface()))
+						queue.PushBack(Autowired(elem.Field(i).Elem().Interface()))
 					} else {
-						runeName := []rune(elem.Type().Field(i).Name)
-						runeName[0] = unicode.ToUpper(runeName[0])
-						methodName := string(runeName)
-						method := value.MethodByName(methodName)
-						if method.IsValid() {
-							result := method.Call([]reflect.Value{})[0]
-							queue.PushBack(autowire.Autowired(result.Interface()))
-						}
+						queue.PushBack(Autowired(internal.GetUnexportedField(elem.Field(i))))
 					}
 				}
 			}
 		}
 	}
 }
-
-func setFieldValue(value reflect.Value, elem reflect.Value, i int, dependency interface{}) bool {
-	runeName := []rune(elem.Type().Field(i).Name)
-	exported := unicode.IsUpper(runeName[0])
-	if exported {
-		elem.Field(i).Set(reflect.ValueOf(dependency))
-	} else {
-		runeName[0] = unicode.ToUpper(runeName[0])
-		methodName := "Set" + string(runeName)
-		method := value.MethodByName(methodName)
-		if method.IsValid() {
-			method.Call([]reflect.Value{reflect.ValueOf(dependency)})
-			return true
-		}
-	}
-	return false
-}

atesting/testing_test.go

@@ -0,0 +1,105 @@
+package atesting_test
+
+import (
+	. "github.com/go-autowire/autowire"
+	. "github.com/go-autowire/autowire/atesting"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+type FooEr interface {
+	Foo()
+}
+
+// A Foo represent named struct
+type Foo struct {
+	Name       string
+	CloseCalls int
+}
+
+// Pass method
+func (f Foo) Foo() {
+}
+
+type BarEr interface {
+	Baz()
+}
+
+// Foo represent named struct
+type Bar struct {
+	Name       string
+	CloseCalls int
+}
+
+// Pass method
+func (b Bar) Baz() {
+}
+
+// A FooBarUnexported represent named struct
+type FooBarUnexported struct {
+	foo *Foo `autowire:""`
+	bar *Bar `autowire:""`
+}
+
+// A FooBar represent named struct
+type FooBar struct {
+	Foo *Foo `autowire:""`
+	Bar *Bar `autowire:""`
+}
+
+// Baz represent named struct
+type Baz struct {
+	MyFoo FooEr `autowire:"Foo"`
+	MyBaz BarEr `autowire:"Bar"`
+}
+
+func TestSpyUnexportedStructPtr(t *testing.T) {
+	fooName := "foo"
+	Autowire(&Foo{Name: fooName})
+	barName := "bar"
+	Autowire(&Bar{Name: barName})
+	tmpFooBar := &FooBarUnexported{}
+	Autowire(tmpFooBar)
+	assert.Equal(t, tmpFooBar.foo.Name, fooName)
+	assert.Equal(t, tmpFooBar.bar.Name, barName)
+	testFooName := "testFoo"
+	testBarName := "testBar"
+	Spy(tmpFooBar, &Foo{Name: testFooName}, &Bar{Name: testBarName})
+	assert.Equal(t, tmpFooBar.foo.Name, testFooName)
+	assert.Equal(t, tmpFooBar.bar.Name, testBarName)
+	assert.Equal(t, 0, len(Close()))
+}
+
+func TestSpyExportedStructPtr(t *testing.T) {
+	fooName := "foo"
+	Autowire(&Foo{Name: fooName})
+	barName := "bar"
+	Autowire(&Bar{Name: barName})
+	tmpFooBar := &FooBar{}
+	Autowire(tmpFooBar)
+	assert.Equal(t, tmpFooBar.Foo.Name, fooName)
+	assert.Equal(t, tmpFooBar.Bar.Name, barName)
+	testFooName := "testFoo"
+	testBarName := "testBar"
+	Spy(tmpFooBar, &Foo{Name: testFooName}, &Bar{Name: testBarName})
+	assert.Equal(t, tmpFooBar.Foo.Name, testFooName)
+	assert.Equal(t, tmpFooBar.Bar.Name, testBarName)
+	assert.Equal(t, 0, len(Close()))
+}
+
+func TestSpyInterface(t *testing.T) {
+	fooName := "foo"
+	Autowire(&Foo{Name: fooName})
+	barName := "bar"
+	Autowire(&Bar{Name: barName})
+	tmpBaz := &Baz{}
+	Autowire(tmpBaz)
+	assert.Equal(t, tmpBaz.MyFoo.(*Foo).Name, fooName)
+	assert.Equal(t, tmpBaz.MyBaz.(*Bar).Name, barName)
+	testFooName := "testFoo"
+	testBarName := "testBar"
+	Spy(tmpBaz, &Foo{Name: testFooName}, &Bar{Name: testBarName})
+	assert.Equal(t, tmpBaz.MyFoo.(*Foo).Name, testFooName)
+	assert.Equal(t, tmpBaz.MyBaz.(*Bar).Name, testBarName)
+	assert.Equal(t, 0, len(Close()))
+}