Golang Container.Register方法代码示例

	})

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