})
Describe("Generate()", func() {
var (
container *goldi.Container
resolver *goldi.ParameterResolver
)
BeforeEach(func() {
config := map[string]interface{}{}
container = goldi.NewContainer(goldi.NewTypeRegistry(), config)
resolver = goldi.NewParameterResolver(container)
})
It("should act as alias for the actual type", func() {
container.Register("foo", goldi.NewStructType(Foo{}, "I was created by @foo"))
alias := goldi.NewAliasType("foo")
generated, err := alias.Generate(resolver)
Expect(err).NotTo(HaveOccurred())
Expect(generated).To(BeAssignableToTypeOf(&Foo{}))
Expect(generated.(*Foo).Value).To(Equal("I was created by @foo"))
})
It("should work with func reference types", func() {
container.Register("foo", goldi.NewStructType(Foo{}, "I was created by @foo"))
alias := goldi.NewAliasType("foo::ReturnString")
generated, err := alias.Generate(resolver)
Expect(err).NotTo(HaveOccurred())
Expect(generated).To(BeAssignableToTypeOf(func(string) string { return "" }))
Describe("Generate()", func() {
var (
config = map[string]interface{}{}
container *goldi.Container
resolver *goldi.ParameterResolver
)
BeforeEach(func() {
container = goldi.NewContainer(goldi.NewTypeRegistry(), config)
resolver = goldi.NewParameterResolver(container)
})
It("should get the embedded type and configurator and configure it", func() {
typeDef := goldi.NewConfiguredType(embeddedType, "configurator_type", "Configure")
configurator := &MyConfigurator{ConfiguredValue: "success!"}
container.Register("configurator_type", goldi.NewInstanceType(configurator))
generatedType, err := typeDef.Generate(resolver)
Expect(err).NotTo(HaveOccurred())
Expect(generatedType).NotTo(BeNil())
Expect(generatedType).To(BeAssignableToTypeOf(&Foo{}))
Expect(generatedType.(*Foo).Value).To(Equal("success!"))
})
It("should return an error if the embedded type can not be generated", func() {
invalidType := goldi.NewStructType(nil)
typeDef := goldi.NewConfiguredType(invalidType, "configurator_type", "Configure")
configurator := &MyConfigurator{ConfiguredValue: "should not happen"}
container.Register("configurator_type", goldi.NewInstanceType(configurator))
generatedType, err := typeDef.Generate(resolver)
})
})
})
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`))
})
})
})
})
})
Describe("Generate()", func() {
var (
container *goldi.Container
resolver *goldi.ParameterResolver
)
BeforeEach(func() {
config := map[string]interface{}{}
container = goldi.NewContainer(goldi.NewTypeRegistry(), config)
resolver = goldi.NewParameterResolver(container)
})
It("should get the correct method of the referenced type", func() {
container.Register("logger_provider", goldi.NewStructType(LoggerProvider{}))
typeDef := goldi.NewProxyType("logger_provider", "GetLogger", "My logger")
generated, err := typeDef.Generate(resolver)
Expect(err).NotTo(HaveOccurred())
Expect(generated).To(BeAssignableToTypeOf(&SimpleLogger{}))
Expect(generated.(*SimpleLogger).Name).To(Equal("My logger"))
})
It("should return an error if the referenced type has no such method", func() {
typeDef := goldi.NewProxyType("foobar", "DoStuff")
_, err := typeDef.Generate(resolver)
Expect(err).To(MatchError("could not generate proxy type @foobar::DoStuff : type foobar does not exist"))
})
config map[string]interface{}
container *goldi.Container
)
BeforeEach(func() {
registry = goldi.NewTypeRegistry()
config = map[string]interface{}{}
container = goldi.NewContainer(registry, config)
})
It("should panic if a type can not be resolved", func() {
Expect(func() { container.MustGet("foo.bar") }).To(Panic())
})
It("should return an error if there was an issue generating the type", func() {
container.Register("foo", goldi.NewStructType(nil))
_, err := container.Get("foo")
Expect(err).To(MatchError(`goldi: error while generating type "foo": the given struct is nil`))
})
It("should resolve simple types", func() {
registry.RegisterType("test_type", NewMockType)
Expect(container.MustGet("test_type")).To(BeAssignableToTypeOf(&MockType{}))
})
It("should build the types lazily", func() {
typeID := "test_type"
generator := &MockTypeFactory{}
registry.RegisterType(typeID, generator.NewMockType)
generatorWrapper, typeIsRegistered := registry[typeID]
})
Context("when the type configurator is no struct or pointer to struct", func() {
It("should return an error", func() {
container.InjectInstance("configurator", 42)
someType := new(Foo)
configurator := goldi.NewTypeConfigurator("configurator", "Configure")
Expect(configurator.Configure(someType, container)).To(MatchError("the configurator instance is no struct or pointer to struct but a int"))
})
})
Context("when the type configurator method does not exist", func() {
It("should return an error", func() {
someType := new(Foo)
configurator := goldi.NewTypeConfigurator("configurator", "Fooobar")
container.Register("configurator", goldi.NewInstanceType(&MyConfigurator{}))
Expect(configurator.Configure(someType, container)).To(MatchError(`the configurator does not have a method "Fooobar"`))
})
})
Context("when the type configurator has been defined properly", func() {
var configurator *MyConfigurator
BeforeEach(func() {
configurator = &MyConfigurator{ConfiguredValue: "success!"}
container.Register("configurator", goldi.NewInstanceType(configurator))
})
It("should return an error if the first argument is nil", func() {
configuratorType := goldi.NewTypeConfigurator("configurator", "Configure")
Expect(configuratorType.Configure(nil, container)).To(MatchError("can not configure nil"))
