Golang inject.Populate函数代码示例

func TestDoesNotOverwriteInterface() {
	i := 100
	a := &TypeAnswerStruct{}
	var v struct {
		K *int              `inject:""`
		A Answerable        `inject:""`
		B *TypeNestedStruct `inject:""`
	}
	fmt.Println(v)
	v.A = a
	v.K = &i
	/*
		var g inject.Graph
		if err := g.Provide(&inject.Object{Name: "inttest", Value: &i}); err != nil {
			fmt.Println(err)
		}
	*/
	if err := inject.Populate(&v); err != nil {
		fmt.Println(err)
	}
	a.answer = 1
	i = 99
	fmt.Println(v.A)
	fmt.Println(v.B)
	fmt.Println(*v.K)
	if v.A != a {
		fmt.Println("original A was lost")
	}
	if v.B == nil {
		fmt.Println("v.B is nil")
	}
}

func init() {
	// Filters is the default set of global filters.
	revel.Filters = []revel.Filter{
		CorsFilter,
		revel.PanicFilter,             // Recover from panics and display an error page instead.
		revel.RouterFilter,            // Use the routing table to select the right Action
		revel.FilterConfiguringFilter, // A hook for adding or removing per-Action filters.
		revel.ParamsFilter,            // Parse parameters into Controller.Params.
		//		revel.SessionFilter,           // Restore and write the session cookie.
		//		revel.FlashFilter,             // Restore and write the flash cookie.
		revel.ValidationFilter,  // Restore kept validation errors and save new ones from cookie.
		revel.I18nFilter,        // Resolve the requested language
		HeaderFilter,            // Add some security based headers
		revel.InterceptorFilter, // Run interceptors around the action.
		revel.CompressFilter,    // Compress the result.
		revel.ActionInvoker,     // Invoke the action.
	}

	persistence.InitDb()

	var app controllers.AccountController

	if err := inject.Populate(&app); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

func TestInjectWithStructValue() {
	var v TypeWithStructValue
	if err := inject.Populate(&v); err != nil {
		fmt.Println(err)
	}
	fmt.Println(v)
}

func TestInterfaceIncludingPrivate(t *testing.T) {
	var v struct {
		A Answerable        `inject:""`
		B *TypeNestedStruct `inject:"private"`
		C *TypeAnswerStruct `inject:""`
	}
	if err := inject.Populate(&v); err != nil {
		t.Fatal(err)
	}
	if v.A == nil {
		t.Fatal("v.A is nil")
	}
	if v.B == nil {
		t.Fatal("v.B is nil")
	}
	if v.C == nil {
		t.Fatal("v.C is nil")
	}
	if v.A != v.C {
		t.Fatal("v.A != v.C")
	}
	if v.A == v.B {
		t.Fatal("v.A == v.B")
	}
}

func TestInterfaceIncludingPrivate() {
	var v struct {
		A Answerable        `inject:""`
		B *TypeNestedStruct `inject:"private"`
		C *TypeAnswerStruct `inject:""`
	}
	if err := inject.Populate(&v); err != nil {
		fmt.Println(err)
	}
	fmt.Println(v)

	if v.A == nil {
		fmt.Println("v.A is nil")
	}
	if v.B == nil {
		fmt.Println("v.B is nil")
	}
	if v.C == nil {
		fmt.Println("v.C is nil")
	}
	if v.A != v.C {
		fmt.Println("v.A != v.C")
	}
	if v.A == v.B {
		fmt.Println("v.A == v.B")
	}
}

func TestInjectWithStructValue(t *testing.T) {
	var v TypeWithStructValue
	if err := inject.Populate(&v); err != nil {
		t.Fatal(err)
	}
	if v.Inline.A == nil {
		t.Fatal("v.Inline.A is nil")
	}
}

func TagWithJustColon() {
	var a TypeWithJustColon
	err := inject.Populate(&a)
	if err == nil {
		fmt.Println(a)
	} else {
		fmt.Println(err)
	}
}

func initApp() HomomorphicEncryptionBackendApp {

	var app HomomorphicEncryptionBackendApp

	inject.Populate(&app)

	app.Router.init()

	return app
}

func TestInjectMap(t *testing.T) {
	var v struct {
		A map[string]int `inject:"private"`
	}
	if err := inject.Populate(&v); err != nil {
		t.Fatal(err)
	}
	if v.A == nil {
		t.Fatal("v.A is nil")
	}
}

func TestErrorOnNonPointerStructInject(t *testing.T) {
	var a TypeWithNonPointerStructInject
	err := inject.Populate(&a)
	if err == nil {
		t.Fatalf("expected error for %+v", a)
	}

	const msg = "found inject tag on unsupported field A in type *inject_test.TypeWithNonPointerStructInject"
	if err.Error() != msg {
		t.Fatalf("expected:\n%s\nactual:\n%s", msg, err.Error())
	}
}

func TestProvideTwoOfTheSameWithPopulate(t *testing.T) {
	a := TypeAnswerStruct{}
	err := inject.Populate(&a, &a)
	if err == nil {
		t.Fatal("expected error")
	}

	const msg = "provided two unnamed instances of type *github.com/facebookgo/inject_test.TypeAnswerStruct"
	if err.Error() != msg {
		t.Fatalf("expected:\n%s\nactual:\n%s", msg, err.Error())
	}
}

func TestPrivateIsFollowed(t *testing.T) {
	var v struct {
		A *TypeNestedStruct `inject:"private"`
	}

	if err := inject.Populate(&v); err != nil {
		t.Fatal(err)
	}
	if v.A.A == nil {
		t.Fatal("v.A.A is nil")
	}
}

func TestInjectInterfaceMissing(t *testing.T) {
	var v TypeInjectInterfaceMissing
	err := inject.Populate(&v)
	if err == nil {
		t.Fatal("did not find expected error")
	}

	const msg = "found no assignable value for field Answerable in type *inject_test.TypeInjectInterfaceMissing"
	if err.Error() != msg {
		t.Fatalf("expected:\n%s\nactual:\n%s", msg, err.Error())
	}
}

func TestInjectTwoSatisfyInterface(t *testing.T) {
	var v TypeInjectTwoSatisfyInterface
	err := inject.Populate(&v)
	if err == nil {
		t.Fatal("did not find expected error")
	}

	const msg = "found two assignable values for field Answerable in type *inject_test.TypeInjectTwoSatisfyInterface. one type *inject_test.TypeAnswerStruct with value &{0 0} and another type *inject_test.TypeNestedStruct with value <*inject_test.TypeNestedStruct Value>"
	if err.Error() != msg {
		t.Fatalf("expected:\n%s\nactual:\n%s", msg, err.Error())
	}
}

func TestInjectPrivateInterface(t *testing.T) {
	var v TypeInjectPrivateInterface
	err := inject.Populate(&v)
	if err == nil {
		t.Fatal("did not find expected error")
	}

	const msg = "found private inject tag on interface field Answerable in type *inject_test.TypeInjectPrivateInterface"
	if err.Error() != msg {
		t.Fatalf("expected:\n%s\nactual:\n%s", msg, err.Error())
	}
}