// RegisterTypes registers all types that have been defined in the file "types.yml"
//
// DO NOT EDIT THIS FILE: it has been generated by goldigen v0.9.9.
// It is however good practice to put this file under version control.
// See https://github.com/fgrosse/goldi for what is going on here.
func RegisterTypes(types goldi.TypeRegistry) {
types.RegisterAll(map[string]goldi.TypeFactory{
"kernel.http_handler": goldi.NewAliasType("servo.routing.router::ServeHTTP"),
"servo.routing.loader": goldi.NewStructType(new(Loader)),
"servo.routing.router": goldi.NewType(NewRouter, "@servo.routing.loader", "@container"),
})
}
// RegisterTypes registers all types that have been defined in the file "config/types.yml"
//
// DO NOT EDIT THIS FILE: it has been generated by goldigen v0.9.9.
// It is however good practice to put this file under version control.
// See https://github.com/fgrosse/goldi for what is going on here.
func RegisterTypes(types goldi.TypeRegistry) {
types.RegisterAll(map[string]goldi.TypeFactory{
"composed_endpoint": goldi.NewType(handler.Composed, "@my_controller::OuterHandlerAction", "@my_controller::SecondHandlerAction", "@my_controller::FancyAction"),
"container_aware_endpoint": goldi.NewFuncReferenceType("my_container_aware_controller", "SomeAction"),
"controller_endpoint": goldi.NewFuncReferenceType("my_controller", "FancyAction"),
"custom_error_handler": goldi.NewStructType(new(lib.MyErrorHandler)),
"error_endpoint": goldi.NewFuncReferenceType("my_controller", "ErrorAction"),
"greet_user_endpoint": goldi.NewFuncType(endpoints.GreetUserEndpoint),
"homepage_endpoint": goldi.NewFuncType(endpoints.HomepageEndpoint),
"kernel.http_handler": goldi.NewType(handler.MiddleWareAdapter, "@servo.routing.router", "@my_app.error_handler", "@my_app.logging_adapter"),
"my_app.error_handler": goldi.NewType(middleware.ErrorHandlingAdapter, "@custom_error_handler::HandleEndpointError"),
"my_app.logging_adapter": goldi.NewType(middleware.LoggingAdapter, "@my_logger"),
"my_container_aware_controller": goldi.NewStructType(new(endpoints.ContainerAwareController), "@container"),
"my_controller": goldi.NewStructType(new(endpoints.FancyController), "@my_service_client"),
"my_logger": goldi.NewProxyType("logger_provider", "GetLogger", "my_app"),
"my_service_client": goldi.NewType(lib.NewMockServiceClient, "%my_app.some_parameter%"),
})
}
// RegisterTypes registers all types that have been defined in the file "types.yml"
//
// DO NOT EDIT THIS FILE: it has been generated by goldigen v0.9.9.
// It is however good practice to put this file under version control.
// See https://github.com/fgrosse/goldi for what is going on here.
func RegisterTypes(types goldi.TypeRegistry) {
types.RegisterAll(map[string]goldi.TypeFactory{
"logger_provider": goldi.NewAliasType("logxi.logger_provider"),
"logxi.configurator": goldi.NewType(NewLoggerConfigurator, "%logxi.level%"),
"logxi.logger_provider": goldi.NewConfiguredType(
goldi.NewStructType(new(LoggerProvider)),
"logxi.configurator", "Configure",
),
})
}
func ExampleNewType() {
container := goldi.NewContainer(goldi.NewTypeRegistry(), map[string]interface{}{})
// register the type using the factory function NewMockTypeWithArgs and pass two arguments
container.Register("my_type", goldi.NewType(NewMockTypeWithArgs, "Hello World", true))
t := container.MustGet("my_type").(*MockType)
fmt.Printf("%#v", t)
// Output:
// &goldi_test.MockType{StringParameter:"Hello World", BoolParameter:true}
}
func ExampleContainer() {
registry := goldi.NewTypeRegistry()
config := map[string]interface{}{}
container := goldi.NewContainer(registry, config)
container.Register("logger", goldi.NewType(NewNullLogger))
l := container.MustGet("logger")
fmt.Printf("%T", l)
// Output:
// *goldi_test.NullLogger
}
func ExampleContainer_Get() {
registry := goldi.NewTypeRegistry()
config := map[string]interface{}{}
container := goldi.NewContainer(registry, config)
container.Register("logger", goldi.NewType(NewNullLogger))
l, err := container.Get("logger")
if err != nil {
fmt.Println(err.Error())
return
}
// do stuff with the logger. usually you need a type assertion
fmt.Printf("%T", l.(*NullLogger))
// Output:
// *goldi_test.NullLogger
}
// register the type using the factory function NewMockTypeWithArgs and pass two arguments
container.Register("my_type", goldi.NewType(NewMockTypeWithArgs, "Hello World", true))
t := container.MustGet("my_type").(*MockType)
fmt.Printf("%#v", t)
// Output:
// &goldi_test.MockType{StringParameter:"Hello World", BoolParameter:true}
}
// ExampleNewType_ prevents godoc from printing the whole content of this file as example
func ExampleNewType_() {}
var _ = Describe("type", func() {
It("should implement the TypeFactory interface", func() {
var factory goldi.TypeFactory
factory = goldi.NewType(NewFoo)
// if this compiles the test passes (next expectation only to make compiler happy)
Expect(factory).NotTo(BeNil())
})
Describe("goldi.NewType()", func() {
Context("with invalid factory function", func() {
It("should return an invalid type if the generator is no function", func() {
Expect(goldi.IsValid(goldi.NewType(42))).To(BeFalse())
})
It("should return an invalid type if the generator has no output parameters", func() {
Expect(goldi.IsValid(goldi.NewType(func() {}))).To(BeFalse())
})
It("should return an invalid type if the generator has more than one output parameter", func() {
})
})
})
Context("when the type has not been registered", func() {
It("should return an error", func() {
parameter := reflect.ValueOf("@foo")
expectedType := reflect.TypeOf(&Foo{})
result, err := resolver.Resolve(parameter, expectedType)
Expect(err).To(HaveOccurred())
Expect(result.IsValid()).To(BeFalse())
Expect(err).To(MatchError(`the referenced type "@foo" has not been defined`))
Expect(err.(goldi.UnknownTypeReferenceError).TypeID).To(Equal("foo"))
})
})
Context("when the type has is invalid", func() {
It("should return an error", func() {
parameter := reflect.ValueOf("@foo")
expectedType := reflect.TypeOf(&Foo{})
container.Register("foo", goldi.NewType(nil)) // foo will be invalid
result, err := resolver.Resolve(parameter, expectedType)
Expect(result).To(Equal(reflect.Zero(expectedType)))
Expect(err).To(MatchError(`goldi: error while generating type "foo": the given factoryFunction is nil`))
})
})
})
})
BeforeEach(func() {
registry = goldi.NewTypeRegistry()
config = map[string]interface{}{}
container = goldi.NewContainer(registry, config)
validator = validation.NewContainerValidator()
})
It("should return an error if an invalid type was registered", func() {
registry.Register("main_type", goldi.NewFuncReferenceType("not_existent", "type"))
Expect(validator.Validate(container)).NotTo(Succeed())
})
It("should return an error when parameter has not been set", func() {
typeDef := goldi.NewType(NewMockTypeWithArgs, "hello world", "%param%")
registry.Register("main_type", typeDef)
Expect(validator.Validate(container)).NotTo(Succeed())
})
It("should return an error when a dependend type has not been registered", func() {
typeDef := goldi.NewType(NewTypeForServiceInjection, "@injected_type")
registry.Register("main_type", typeDef)
Expect(validator.Validate(container)).NotTo(Succeed())
})
It("should return an error when a direct circular type dependency exists", func() {
injectedTypeID := "type_1"
typeDef1 := goldi.NewType(NewTypeForServiceInjection, "@type_2")
registry.RegisterType(typeID, generator.NewMockType)
generatorWrapper, typeIsRegistered := registry[typeID]
Expect(typeIsRegistered).To(BeTrue())
Expect(generatorWrapper).NotTo(BeNil())
firstResult := container.MustGet(typeID)
secondResult := container.MustGet(typeID)
thirdResult := container.MustGet(typeID)
Expect(firstResult == secondResult).To(BeTrue())
Expect(firstResult == thirdResult).To(BeTrue())
})
It("should pass static parameters as arguments when generating types", func() {
typeID := "test_type"
typeDef := goldi.NewType(NewMockTypeWithArgs, "parameter1", true)
registry.Register(typeID, typeDef)
generatedType := container.MustGet("test_type")
Expect(generatedType).NotTo(BeNil())
Expect(generatedType).To(BeAssignableToTypeOf(&MockType{}))
generatedMock := generatedType.(*MockType)
Expect(generatedMock.StringParameter).To(Equal("parameter1"))
Expect(generatedMock.BoolParameter).To(Equal(true))
})
It("should be able to use parameters as arguments when generating types", func() {
typeID := "test_type"
typeDef := goldi.NewType(NewMockTypeWithArgs, "%parameter1%", "%parameter2%")
registry.Register(typeID, typeDef)
factory, typeIsRegistered := registry[typeID]
Expect(typeIsRegistered).To(BeTrue())
Expect(factory).NotTo(BeNil())
generateResult, err := factory.Generate(resolver)
Expect(err).NotTo(HaveOccurred())
Expect(generateResult == fooInstance).To(BeTrue(),
fmt.Sprintf("generateResult (%p) should point to the same instance as fooInstance (%p)", generateResult, fooInstance),
)
})
})
Describe("RegisterAll", func() {
It("should register all factories", func() {
registry.RegisterAll(map[string]goldi.TypeFactory{
"test_type_1": goldi.NewType(NewFoo),
"test_type_2": goldi.NewType(NewBar),
"test_type_3": goldi.NewStructType(MockType{}),
})
var typeIsRegistered bool
_, typeIsRegistered = registry["test_type_1"]
Expect(typeIsRegistered).To(BeTrue())
_, typeIsRegistered = registry["test_type_2"]
Expect(typeIsRegistered).To(BeTrue())
_, typeIsRegistered = registry["test_type_3"]
Expect(typeIsRegistered).To(BeTrue())
})
})
})
