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