}) 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"))