decorator-dependency-injection 1.0.1 → 1.0.3

package/test/injection.test.js

@@ -1,4 +1,4 @@
-import {Factory, Inject, Singleton} from '../index.js'
+import {Factory, Inject, resetMocks, Singleton} from '../index.js'
 
 describe('Injection via fields', () => {
   @Singleton()
@@ -46,6 +46,12 @@ describe('Injection via fields', () => {
     }
   }
 
+  afterEach(() => {
+    TestFactory.calls = 0
+    TestSingleton.calls = 0
+    resetMocks()
+  })
+
   it('should inject factory', () => {
     class TestInjectionFactory {
       @Inject(TestFactory) testFactory
@@ -83,7 +89,53 @@ describe('Injection via fields', () => {
     new TestInjectionFactoryParams()
   })
 
-  @Singleton("named")
+  it('should cache factory instance on repeated accesses', () => {
+    class TestRepeatedFactoryAccess {
+      @Inject(TestFactory) testFactory
+
+      constructor() {
+        const instance1 = this.testFactory
+        const instance2 = this.testFactory
+        expect(instance1).toBe(instance2)
+      }
+    }
+
+    new TestRepeatedFactoryAccess()
+  })
+
+  it('should create distinct factory instances for different fields in the same object', () => {
+    class TestMultipleFactoryInjection {
+      @Inject(TestFactory) testFactory1
+      @Inject(TestFactory) testFactory2
+
+      constructor() {
+        // Access both properties to trigger initialization.
+        const one = this.testFactory1
+        const two = this.testFactory2
+        expect(one).not.toBe(two)
+      }
+    }
+
+    new TestMultipleFactoryInjection()
+  })
+
+  it('should inject the same singleton instance for different fields in the same object', () => {
+    class TestMultipleSingletonInjection {
+      @Inject(TestSingleton) testSingleton1
+      @Inject(TestSingleton) testSingleton2
+
+      constructor() {
+        // Access both properties to trigger initialization.
+        const one = this.testSingleton1
+        const two = this.testSingleton2
+        expect(one).toBe(two)
+      }
+    }
+
+    new TestMultipleSingletonInjection()
+  })
+
+  @Singleton('named')
   class NamedSingleton {
     static calls = 0
 
@@ -94,7 +146,7 @@ describe('Injection via fields', () => {
 
   it('should inject named singleton', () => {
     class TestInjectionNamedSingleton {
-      @Inject("named") namedSingleton
+      @Inject('named') namedSingleton
 
       constructor() {
         expect(this.namedSingleton).toBeInstanceOf(NamedSingleton)
@@ -103,7 +155,7 @@ describe('Injection via fields', () => {
     }
 
     class TestInjectionNamedSingleton2 {
-      @Inject("named") namedSingleton
+      @Inject('named') namedSingleton
 
       constructor() {
         expect(this.namedSingleton).toBeInstanceOf(NamedSingleton)
@@ -115,7 +167,7 @@ describe('Injection via fields', () => {
     new TestInjectionNamedSingleton2()
   })
 
-  @Factory("named2")
+  @Factory('named2')
   class NamedFactory {
     static calls = 0
     params
@@ -128,7 +180,7 @@ describe('Injection via fields', () => {
 
   it('should inject named factory', () => {
     class TestInjectionNamedFactory {
-      @Inject("named2") namedFactory
+      @Inject('named2') namedFactory
 
       constructor() {
         expect(this.namedFactory).toBeInstanceOf(NamedFactory)
@@ -137,7 +189,7 @@ describe('Injection via fields', () => {
     }
 
     class TestInjectionNamedFactory2 {
-      @Inject("named2") namedFactory
+      @Inject('named2') namedFactory
 
       constructor() {
         expect(this.namedFactory).toBeInstanceOf(NamedFactory)
@@ -149,4 +201,109 @@ describe('Injection via fields', () => {
     new TestInjectionNamedFactory2()
     expect(result.namedFactory.params).toEqual([])
   })
+
+  it('should cache named factory instance on repeated accesses', () => {
+    class TestRepeatedNamedFactoryAccess {
+      @Inject('named2') namedFactory
+
+      constructor() {
+        const instance1 = this.namedFactory
+        const instance2 = this.namedFactory
+        expect(instance1).toBe(instance2)
+      }
+    }
+
+    new TestRepeatedNamedFactoryAccess()
+  })
+
+  it('should throw if @Inject is applied to a method', () => {
+    expect(() => {
+      // noinspection JSUnusedLocalSymbols
+      class BadInjection {
+        @Inject('something')
+        someMethod() {
+        }
+      }
+    }).toThrow()
+  })
+
+  it('should handle circular dependencies gracefully', () => {
+    @Singleton()
+    class A {
+      @Inject('B') b
+    }
+
+    @Singleton('B')
+    class B {
+      @Inject(A) a
+    }
+
+    expect(() => new A()).toThrow(/Circular dependency detected.*@InjectLazy/)
+  })
+
+  it('should throw if decorator is used on non-class object', () => {
+    expect(() => {
+      const obj = {}
+      Inject('something')(obj, 'field')
+    }).toThrow()
+  })
+
+  it('should throw a helpful error for eager circular dependencies', () => {
+    @Factory()
+    class A2 {
+      @Inject('B2') b
+    }
+
+    @Singleton('B2')
+    class B2 {
+      @Inject(A2) a
+    }
+
+    expect(() => new A2()).toThrow(/Circular dependency detected.*@InjectLazy/)
+  })
+
+  it('should inject into symbol-named fields', () => {
+    const sym = Symbol('sym')
+
+    @Singleton()
+    class S {
+    }
+
+    class Test {
+      @Inject(S) [sym]
+    }
+
+    const t = new Test()
+    expect(t[sym]).toBeInstanceOf(S)
+  })
+
+  it('should not leak injected properties to prototype', () => {
+    @Singleton()
+    class S {
+    }
+
+    class Test {
+      @Inject(S) dep
+    }
+
+    // noinspection JSUnusedLocalSymbols
+    const t = new Test()
+    expect(Object.prototype.hasOwnProperty.call(Test.prototype, 'dep')).toBe(false)
+  })
+
+  it('should handle undefined/null/complex params in factory', () => {
+    @Factory()
+    class F {
+      constructor(...params) {
+        this.params = params
+      }
+    }
+
+    class Test {
+      @Inject(F, undefined, null, {a: 1}) dep
+    }
+
+    const t = new Test()
+    expect(t.dep.params).toEqual([undefined, null, {a: 1}])
+  })
 })

package/test/injectionLazy.test.js

@@ -0,0 +1,249 @@
+import {Factory, InjectLazy, resetMocks, Singleton} from '../index.js'
+
+describe('Lazy Injection via fields', () => {
+  @Singleton()
+  class TestLazySingleton {
+    static calls = 0
+
+    constructor() {
+      TestLazySingleton.calls++
+    }
+  }
+
+  it('should lazily inject singleton', () => {
+    class TestLazySingletonInjection {
+      @InjectLazy(TestLazySingleton) testSingleton
+
+      constructor() {
+      }
+    }
+
+    const instance = new TestLazySingletonInjection()
+    expect(TestLazySingleton.calls).toBe(0) // Not constructed until access
+    const first = instance.testSingleton
+    expect(first).toBeInstanceOf(TestLazySingleton)
+    expect(TestLazySingleton.calls).toBe(1)
+    // Repeated access returns the same instance.
+    const second = instance.testSingleton
+    expect(first).toBe(second)
+  })
+
+  @Factory()
+  class TestLazyFactory {
+    static calls = 0
+    params
+
+    constructor(...params) {
+      TestLazyFactory.calls++
+      this.params = params
+    }
+  }
+
+  afterEach(() => {
+    TestLazyFactory.calls = 0
+    TestLazySingleton.calls = 0
+    resetMocks()
+  })
+
+  it('should lazily inject factory with caching on first access per field', () => {
+    class TestLazyFactoryInjection {
+      @InjectLazy(TestLazyFactory) testFactory
+
+      constructor() {
+      }
+    }
+
+    const inst = new TestLazyFactoryInjection()
+    expect(TestLazyFactory.calls).toBe(0)
+    const first = inst.testFactory
+    expect(first).toBeInstanceOf(TestLazyFactory)
+    expect(TestLazyFactory.calls).toBe(1)
+    expect(inst.testFactory).toBe(first)
+  })
+
+  it('should create distinct factory instances for different fields', () => {
+    class TestMultipleLazyFactoryInjection {
+      @InjectLazy(TestLazyFactory) testFactory1
+      @InjectLazy(TestLazyFactory) testFactory2
+
+      constructor() {
+      }
+    }
+
+    const instance = new TestMultipleLazyFactoryInjection()
+    expect(TestLazyFactory.calls).toBe(0)
+    const one = instance.testFactory1
+    const two = instance.testFactory2
+    expect(one).toBeInstanceOf(TestLazyFactory)
+    expect(two).toBeInstanceOf(TestLazyFactory)
+    expect(one).not.toBe(two)
+  })
+
+  it('should pass constructor parameters when using lazy injection', () => {
+    class TestLazyFactoryParamsInjection {
+      @InjectLazy(TestLazyFactory, 'param1', 'param2') testFactory
+
+      constructor() {
+      }
+    }
+
+    TestLazyFactory.calls = 0
+    const instance = new TestLazyFactoryParamsInjection()
+    expect(TestLazyFactory.calls).toBe(0)
+    const factoryInst = instance.testFactory
+    expect(factoryInst).toBeInstanceOf(TestLazyFactory)
+    expect(factoryInst.params).toEqual(['param1', 'param2'])
+  })
+
+  it('should not initialize dependency if property is never accessed', () => {
+    class TestNeverAccess {
+      @InjectLazy(TestLazySingleton) testSingleton
+
+      constructor() {
+      }
+    }
+
+    TestLazySingleton.calls = 0
+    new TestNeverAccess() // Do not access testSingleton.
+    expect(TestLazySingleton.calls).toBe(0)
+  })
+
+  @Singleton('lazyNamedSingleton')
+  class NamedLazySingleton {
+    static calls = 0
+
+    constructor() {
+      NamedLazySingleton.calls++
+    }
+  }
+
+  it('should lazily inject named singleton', () => {
+    class TestLazyNamedSingletonInjection {
+      @InjectLazy('lazyNamedSingleton') namedSingleton
+
+      constructor() {
+      }
+    }
+
+    const instance = new TestLazyNamedSingletonInjection()
+    expect(NamedLazySingleton.calls).toBe(0)
+    const first = instance.namedSingleton
+    expect(first).toBeInstanceOf(NamedLazySingleton)
+    expect(NamedLazySingleton.calls).toBe(1)
+    expect(instance.namedSingleton).toBe(first)
+  })
+
+  @Factory('lazyNamedFactory')
+  class NamedLazyFactory {
+    static calls = 0
+    params
+
+    constructor(...params) {
+      NamedLazyFactory.calls++
+      this.params = params
+    }
+  }
+
+  it('should lazily inject named factory', () => {
+    class TestLazyNamedFactoryInjection {
+      @InjectLazy('lazyNamedFactory') namedFactory
+
+      constructor() {
+      }
+    }
+
+    NamedLazyFactory.calls = 0
+    const instance = new TestLazyNamedFactoryInjection()
+    expect(NamedLazyFactory.calls).toBe(0)
+    const first = instance.namedFactory
+    expect(first).toBeInstanceOf(NamedLazyFactory)
+    expect(NamedLazyFactory.calls).toBe(1)
+    expect(instance.namedFactory).toBe(first)
+  })
+
+  it('should not expose any internal caching artifacts', () => {
+    class TestLazyEnum {
+      @InjectLazy(TestLazySingleton) lazyProp
+
+      constructor() {
+      }
+    }
+
+    const inst = new TestLazyEnum()
+    // noinspection JSUnusedLocalSymbols: Force lazy initialization.
+    const _ = inst.lazyProp
+    const keys = Object.keys(inst)
+    expect(keys).toContain('lazyProp')
+    expect(keys.length).toBe(1)
+    const symbols = Object.getOwnPropertySymbols(inst)
+    expect(symbols.length).toBe(0)
+  })
+
+  it('should throw if @InjectLazy is applied to a method', () => {
+    expect(() => {
+      // noinspection JSUnusedLocalSymbols
+      class BadLazy {
+        @InjectLazy('something')
+        someMethod() {
+        }
+      }
+    }).toThrow()
+  })
+
+  it('should handle circular dependencies (lazy)', () => {
+    @Singleton()
+    class A {
+      @InjectLazy('B') b
+    }
+
+    @Singleton('B')
+    class B {
+      @InjectLazy(A) a
+    }
+
+    expect(() => new A()).not.toThrow()
+  })
+
+  it('should inject into symbol-named fields (lazy)', () => {
+    const sym = Symbol('sym')
+
+    @Singleton()
+    class S {
+    }
+
+    class Test {
+      @InjectLazy(S) [sym]
+    }
+
+    const t = new Test()
+    expect(t[sym]).toBeInstanceOf(S)
+  })
+
+  it('should not leak lazy injected properties to prototype', () => {
+    @Singleton()
+    class S {
+    }
+
+    class Test {
+      @InjectLazy(S) dep
+    }
+
+    // noinspection JSUnusedLocalSymbols
+    const t = new Test()
+    expect(Object.prototype.hasOwnProperty.call(Test.prototype, 'dep')).toBe(false)
+  })
+
+  it('should allow circular dependencies with lazy injection', () => {
+    @Singleton()
+    class A1 {
+      @InjectLazy('B1') b
+    }
+
+    @Factory('B1')
+    class B1 {
+      @InjectLazy(A1) a
+    }
+
+    expect(() => new A1()).not.toThrow()
+  })
+})