Example #1
0
		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]
		Expect(typeIsRegistered).To(BeTrue())
		Expect(generatorWrapper).NotTo(BeNil())

		Expect(generator.HasBeenUsed).To(BeFalse())
		container.MustGet(typeID)
		Expect(generator.HasBeenUsed).To(BeTrue())
Example #2
0
		registry goldi.TypeRegistry
		resolver *goldi.ParameterResolver
	)

	BeforeEach(func() {
		registry = goldi.NewTypeRegistry()
		container := goldi.NewContainer(registry, map[string]interface{}{})
		resolver = goldi.NewParameterResolver(container)
	})

	Describe("RegisterType", func() {
		Context("with factory function type", func() {
			It("should store the type", func() {
				typeID := "test_type"
				factory := &MockTypeFactory{}
				registry.RegisterType(typeID, factory.NewMockType)

				factoryWrapper, typeIsRegistered := registry[typeID]
				Expect(typeIsRegistered).To(BeTrue())
				Expect(factoryWrapper).NotTo(BeNil())

				factoryWrapper.Generate(resolver)
				Expect(factory.HasBeenUsed).To(BeTrue())
			})

			It("should pass parameters to the new type", func() {
				typeID := "test_type"
				registry.RegisterType(typeID, NewMockTypeWithArgs, "foo", true)
				Expect(registry).To(HaveKey(typeID))

				result, err := registry["test_type"].Generate(resolver)