decorator-dependency-injection 1.0.3 → 1.0.4

package/test/injection.test.js

@@ -1,309 +0,0 @@
-import {Factory, Inject, resetMocks, Singleton} from '../index.js'
-
-describe('Injection via fields', () => {
-  @Singleton()
-  class TestSingleton {
-    static calls = 0
-
-    constructor() {
-      TestSingleton.calls++
-    }
-  }
-
-  it('should inject singleton', () => {
-    class TestInjection {
-      @Inject(TestSingleton) testSingleton
-
-      constructor() {
-        expect(this.testSingleton).toBeInstanceOf(TestSingleton)
-        expect(TestSingleton.calls).toBe(1)
-      }
-    }
-
-    class TestInjection2 {
-      @Inject(TestSingleton) testSingleton
-
-      constructor() {
-        expect(this.testSingleton).toBeInstanceOf(TestSingleton)
-        expect(TestSingleton.calls).toBe(1)
-      }
-    }
-
-    new TestInjection()
-    new TestInjection2()
-  })
-
-  @Factory()
-  class TestFactory {
-    static calls = 0
-    params
-
-    @Inject(TestSingleton) testSingleton
-
-    constructor(...params) {
-      TestFactory.calls++
-      this.params = params
-    }
-  }
-
-  afterEach(() => {
-    TestFactory.calls = 0
-    TestSingleton.calls = 0
-    resetMocks()
-  })
-
-  it('should inject factory', () => {
-    class TestInjectionFactory {
-      @Inject(TestFactory) testFactory
-
-      constructor() {
-        expect(this.testFactory).toBeInstanceOf(TestFactory)
-        expect(TestFactory.calls).toBe(1)
-      }
-    }
-
-    class TestInjectionFactory2 {
-      @Inject(TestFactory) testFactory
-
-      constructor() {
-        expect(this.testFactory).toBeInstanceOf(TestFactory)
-        expect(TestFactory.calls).toBe(2)
-      }
-    }
-
-    const result = new TestInjectionFactory()
-    new TestInjectionFactory2()
-    expect(result.testFactory.testSingleton).toBeInstanceOf(TestSingleton)
-  })
-
-  it('should inject factory with parameters', () => {
-    class TestInjectionFactoryParams {
-      @Inject(TestFactory, 'param1', 'param2') testFactory
-
-      constructor() {
-        expect(this.testFactory).toBeInstanceOf(TestFactory)
-        expect(this.testFactory.params).toEqual(['param1', 'param2'])
-      }
-    }
-
-    new TestInjectionFactoryParams()
-  })
-
-  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
-
-    constructor() {
-      NamedSingleton.calls++
-    }
-  }
-
-  it('should inject named singleton', () => {
-    class TestInjectionNamedSingleton {
-      @Inject('named') namedSingleton
-
-      constructor() {
-        expect(this.namedSingleton).toBeInstanceOf(NamedSingleton)
-        expect(NamedSingleton.calls).toBe(1)
-      }
-    }
-
-    class TestInjectionNamedSingleton2 {
-      @Inject('named') namedSingleton
-
-      constructor() {
-        expect(this.namedSingleton).toBeInstanceOf(NamedSingleton)
-        expect(NamedSingleton.calls).toBe(1)
-      }
-    }
-
-    new TestInjectionNamedSingleton()
-    new TestInjectionNamedSingleton2()
-  })
-
-  @Factory('named2')
-  class NamedFactory {
-    static calls = 0
-    params
-
-    constructor(...params) {
-      NamedFactory.calls++
-      this.params = params
-    }
-  }
-
-  it('should inject named factory', () => {
-    class TestInjectionNamedFactory {
-      @Inject('named2') namedFactory
-
-      constructor() {
-        expect(this.namedFactory).toBeInstanceOf(NamedFactory)
-        expect(NamedFactory.calls).toBe(1)
-      }
-    }
-
-    class TestInjectionNamedFactory2 {
-      @Inject('named2') namedFactory
-
-      constructor() {
-        expect(this.namedFactory).toBeInstanceOf(NamedFactory)
-        expect(NamedFactory.calls).toBe(2)
-      }
-    }
-
-    const result = new TestInjectionNamedFactory()
-    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

@@ -1,249 +0,0 @@
-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()
-  })
-})