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())
}
}
func TestInjectOnPrivateInterfaceField(t *testing.T) {
var a TypeWithInjectOnPrivateField
err := inject.Populate(&a)
if err == nil {
t.Fatal("did not find expected error")
}
const msg = "inject requested on unexported field a in type *inject_test.TypeWithInjectOnPrivateField"
if err.Error() != msg {
t.Fatalf("expected:\n%s\nactual:\n%s", msg, err.Error())
}
}
func TestInjectMapWithoutPrivate(t *testing.T) {
var v TypeInjectWithMapWithoutPrivate
err := inject.Populate(&v)
if err == nil {
t.Fatalf("expected error for %+v", v)
}
const msg = "inject on map field A in type *inject_test.TypeInjectWithMapWithoutPrivate must be named or private"
if err.Error() != msg {
t.Fatalf("expected:\n%s\nactual:\n%s", msg, err.Error())
}
}
func TestInjectInlinePrivate(t *testing.T) {
var v TypeWithInlineStructWithPrivate
err := inject.Populate(&v)
if err == nil {
t.Fatal("was expecting an error")
}
const msg = "cannot use private inject on inline struct on field Inline in type *inject_test.TypeWithInlineStructWithPrivate"
if err.Error() != msg {
t.Fatalf("expected:\n%s\nactual:\n%s", msg, err.Error())
}
}
func TestTagWithMissingNamed(t *testing.T) {
var a TypeWithMissingNamed
err := inject.Populate(&a)
if err == nil {
t.Fatalf("expected error for %+v", a)
}
const msg = "did not find object named foo required by field A in type *inject_test.TypeWithMissingNamed"
if err.Error() != msg {
t.Fatalf("expected:\n%s\nactual:\n%s", msg, err.Error())
}
}
func TestTagWithOpenQuote(t *testing.T) {
var a TypeWithOpenQuote
err := inject.Populate(&a)
if err == nil {
t.Fatalf("expected error for %+v", a)
}
const msg = "unexpected tag format `inject:\"` for field A in type *inject_test.TypeWithOpenQuote"
if err.Error() != msg {
t.Fatalf("expected:\n%s\nactual:\n%s", msg, err.Error())
}
}
func ErrorOnNonPointerInject() {
var a TypeWithNonPointerInject
err := inject.Populate(&a)
if err == nil {
fmt.Println(a)
} else {
fmt.Println(err.Error())
const msg = "found inject tag on unsupported field A in type *main.TypeWithNonPointerInject"
if err.Error() != msg {
fmt.Errorf("expected:\n%s\nactual:\n%s", msg, err.Error())
}
}
}
func TestInjectInterface() {
var v TypeInjectInterface
if err := inject.Populate(&v); err != nil {
fmt.Println(err)
}
fmt.Println(v.Answerable)
fmt.Println(v.A)
if v.Answerable == nil || v.Answerable != v.A {
fmt.Println(
v.Answerable,
v.A,
)
}
}
func main() {
application := new(libraryApplication)
if error := inject.Populate(
application,
new(bookservice.BookService),
new(borrowservice.BorrowService),
new(loggerservice.LoggerService),
new(userservice.UserService),
); nil != error {
log.Fatalf("Error occured while populating graph: %v", error)
}
application.run()
}
func TestInjectInterface(t *testing.T) {
var v TypeInjectInterface
if err := inject.Populate(&v); err != nil {
t.Fatal(err)
}
if v.Answerable == nil || v.Answerable != v.A {
t.Fatalf(
"expected the same but got Answerable = %T %+v / A = %T %+v",
v.Answerable,
v.Answerable,
v.A,
v.A,
)
}
}
func TestInjectInvalidInline(t *testing.T) {
var v struct {
A *TypeAnswerStruct `inject:"inline"`
}
err := inject.Populate(&v)
if err == nil {
t.Fatal("was expecting an error")
}
const msg = `inline requested on non inlined field A in type *struct { A *inject_test.TypeAnswerStruct "inject:\"inline\"" }`
if err.Error() != msg {
t.Fatalf("expected:\n%s\nactual:\n%s", msg, err.Error())
}
}
func TestRequireTag(t *testing.T) {
var v struct {
A *TypeAnswerStruct
B *TypeNestedStruct `inject:""`
}
if err := inject.Populate(&v); err != nil {
t.Fatal(err)
}
if v.A != nil {
t.Fatal("v.A is not nil")
}
if v.B == nil {
t.Fatal("v.B is nil")
}
}
func Private() {
var v struct {
A *TypeAnswerStruct `inject:""`
B *TypeNestedStruct `inject:"private"`
}
if err := inject.Populate(&v); err != nil {
fmt.Println(err)
}
fmt.Printf("%#v", v)
fmt.Println(v)
fmt.Println(v.A)
fmt.Println(v.B)
fmt.Println(v.B.A == v.A)
}
func RequireTag() {
var v struct {
A *TypeAnswerStruct
B *TypeNestedStruct `inject:""`
}
if err := inject.Populate(&v); err != nil {
fmt.Println(err)
}
fmt.Println(v)
if v.A != nil {
glog.Fatal("v.A is not nil")
}
if v.B == nil {
glog.Fatal("v.B is nil")
}
}
func TestDoesNotOverwriteInterface(t *testing.T) {
a := &TypeAnswerStruct{}
var v struct {
A Answerable `inject:""`
B *TypeNestedStruct `inject:""`
}
v.A = a
if err := inject.Populate(&v); err != nil {
t.Fatal(err)
}
if v.A != a {
t.Fatal("original A was lost")
}
if v.B == nil {
t.Fatal("v.B is nil")
}
}
func InjectSimple() {
var v struct {
A *TypeAnswerStruct `inject:""`
B *TypeNestedStruct `inject:""`
}
if err := inject.Populate(&v); err != nil {
fmt.Println(err)
}
fmt.Println(v)
fmt.Println(v.A)
fmt.Println(v.B)
fmt.Println(v.B.A)
if v.A == v.B.A {
fmt.Println("wwwwwwww")
}
}
