decorator-dependency-injection 1.0.3 → 1.0.5

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

package/test/mock.test.js

@@ -1,295 +0,0 @@
-import {Factory, Inject, InjectLazy, Mock, resetMock, resetMocks, Singleton} from '../index.js'
-
-describe('Mocking', () => {
-  @Singleton()
-  class ToBeMockedSingleton {
-    op() {
-      return 'original'
-    }
-
-    op2() {
-      return 'original2'
-    }
-  }
-
-  class TestInjection {
-    @Inject(ToBeMockedSingleton) toBeMockedSingleton
-  }
-
-  afterEach(() => {
-    resetMocks()
-  })
-
-  it('should inject a mock singleton', () => {
-    @Mock(ToBeMockedSingleton)
-    class MockedSingleton {
-      op() {
-        return 'mocked1'
-      }
-    }
-
-    const result = new TestInjection()
-    expect(result.toBeMockedSingleton.op()).toBe('mocked1')
-    expect(result.toBeMockedSingleton.op2).toBe.undefined
-
-    resetMocks()
-    const result2 = new TestInjection()
-    expect(result2.toBeMockedSingleton.op()).toBe('original')
-    expect(result2.toBeMockedSingleton.op2()).toBe('original2')
-  })
-
-  // New tests for lazy injection with mocks (non-proxied)
-  it('should inject a lazy mock singleton', () => {
-    @Mock(ToBeMockedSingleton)
-    class MockedSingletonLazy {
-      op() {
-        return 'mocked2'
-      }
-    }
-
-    class TestInjectionLazy {
-      @InjectLazy(ToBeMockedSingleton) lazyMockedSingleton
-    }
-
-    const instance = new TestInjectionLazy()
-    const result = instance.lazyMockedSingleton
-    expect(result.op()).toBe('mocked2')
-    expect(result.op2).toBe.undefined
-
-    resetMocks()
-    const instance2 = new TestInjectionLazy()
-    expect(instance2.lazyMockedSingleton.op()).toBe('original')
-    expect(instance2.lazyMockedSingleton.op2()).toBe('original2')
-  })
-
-  @Factory()
-  class ToBeMockedFactory {
-    op() {
-      return 'original'
-    }
-  }
-
-  class TestInjectionFactory {
-    @Inject(ToBeMockedFactory) toBeMockedFactory
-  }
-
-  it('should inject a mock factory', () => {
-    @Mock(ToBeMockedFactory)
-    class MockedFactory {
-      op() {
-        return 'mocked'
-      }
-    }
-
-    const result = new TestInjectionFactory()
-    expect(result.toBeMockedFactory.op()).toBe('mocked')
-
-    resetMocks()
-    const result2 = new TestInjectionFactory()
-    expect(result2.toBeMockedFactory.op()).toBe('original')
-  })
-
-  // New tests for lazy injection with mock factory
-  it('should inject a lazy mock factory', () => {
-    @Mock(ToBeMockedFactory)
-    class MockedFactoryLazy {
-      op() {
-        return 'mocked'
-      }
-    }
-
-    class TestInjectionFactoryLazy {
-      @InjectLazy(ToBeMockedFactory) lazyMockedFactory
-    }
-
-    const instance = new TestInjectionFactoryLazy()
-    const result = instance.lazyMockedFactory
-    expect(result.op()).toBe('mocked')
-
-    resetMocks()
-    const instance2 = new TestInjectionFactoryLazy()
-    expect(instance2.lazyMockedFactory.op()).toBe('original')
-  })
-
-  it('should throw an error if a mock is not a singleton or factory', () => {
-    expect(() => {
-      @Mock(ToBeMockedFactory)
-      class Mocked1 {
-      }
-
-      @Mock(ToBeMockedFactory)
-      class Mocked2 {
-      }
-    }).toThrow('Mock already defined, reset before mocking again')
-  })
-
-  // Edge case: Resetting specific mocks
-  it('should reset only the specified mock', () => {
-    @Singleton()
-    class A {
-      value() {
-        return 'A'
-      }
-    }
-
-    @Singleton()
-    class B {
-      value() {
-        return 'B'
-      }
-    }
-
-    @Mock(A)
-    class MockA {
-      value() {
-        return 'mockA'
-      }
-    }
-
-    @Mock(B)
-    class MockB {
-      value() {
-        return 'mockB'
-      }
-    }
-
-    class Test {
-      @Inject(A) a
-      @Inject(B) b
-    }
-
-    const t = new Test()
-    expect(t.a.value()).toBe('mockA')
-    expect(t.b.value()).toBe('mockB')
-
-    resetMock(A)
-    const t2 = new Test()
-    expect(t2.a.value()).toBe('A')
-    expect(t2.b.value()).toBe('mockB')
-  })
-
-  it('should use the latest mock when multiple mocks are applied', () => {
-    @Singleton()
-    class Original {
-    }
-
-    @Mock(Original)
-    class Mock1 {
-    }
-
-    resetMock(Original)
-
-    @Mock(Original)
-    class Mock2 {
-    }
-
-    class Test {
-      @Inject(Original) dep
-    }
-
-    const t = new Test()
-    expect(t.dep).toBeInstanceOf(Mock2)
-  })
-
-  it('should restore the original after unmocking', () => {
-    @Singleton()
-    class Orig {
-    }
-
-    @Mock(Orig)
-    class Mocked {
-    }
-
-    resetMock(Orig)
-
-    class Test {
-      @Inject(Orig) dep
-    }
-
-    const t = new Test()
-    expect(t.dep).toBeInstanceOf(Orig)
-  })
-
-  it('should inject subclass correctly', () => {
-    @Singleton()
-    class Base {
-    }
-
-    class Sub extends Base {
-    }
-
-    @Mock(Base)
-    class SubMock extends Sub {
-    }
-
-    class Test {
-      @Inject(Base) dep
-    }
-
-    const t = new Test()
-    expect(t.dep).toBeInstanceOf(Sub)
-  })
-
-  it('should use latest mock for lazy injection', () => {
-    @Singleton()
-    class Orig {
-    }
-
-    @Mock(Orig)
-    class Mock1 {
-    }
-
-    resetMock(Orig)
-
-    @Mock(Orig)
-    class Mock2 {
-    }
-
-    class Test {
-      @InjectLazy(Orig) dep
-    }
-
-    const t = new Test()
-    expect(t.dep).toBeInstanceOf(Mock2)
-  })
-
-  it('should restore original after unmocking (lazy)', () => {
-    @Singleton()
-    class Orig {
-    }
-
-    @Mock(Orig)
-    class Mocked {
-    }
-
-    resetMock(Orig)
-
-    class Test {
-      @InjectLazy(Orig) dep
-    }
-
-    const t = new Test()
-    expect(t.dep).toBeInstanceOf(Orig)
-  })
-
-  it('should inject subclass correctly (lazy)', () => {
-    @Singleton()
-    class Base {
-    }
-
-    class Sub extends Base {
-    }
-
-    @Mock(Base)
-    class SubMock extends Sub {
-    }
-
-    class Test {
-      @InjectLazy(Base) dep
-    }
-
-    const t = new Test()
-    expect(t.dep).toBeInstanceOf(Sub)
-  })
-})
-

package/test/proxy.test.js

@@ -1,130 +0,0 @@
-import {Factory, Inject, InjectLazy, Mock, resetMocks, Singleton} from '../index.js'
-
-describe('Proxy Mocking', () => {
-  @Singleton()
-  class ToBeProxiedSingleton {
-    op() {
-      return 'original'
-    }
-
-    op2() {
-      return 'original2'
-    }
-  }
-
-  class TestInjection {
-    @Inject(ToBeProxiedSingleton) toBeProxiedSingleton
-  }
-
-  afterEach(() => {
-    resetMocks()
-  })
-
-  it('should inject a proxy singleton', () => {
-    @Mock(ToBeProxiedSingleton, true)
-    class ProxiedSingleton {
-      op() {
-        return 'mocked'
-      }
-    }
-
-    const result = new TestInjection()
-    expect(result.toBeProxiedSingleton.op()).toBe('mocked')
-    expect(result.toBeProxiedSingleton.op2()).toBe('original2')
-
-    resetMocks()
-    const result2 = new TestInjection()
-    expect(result2.toBeProxiedSingleton.op()).toBe('original')
-    expect(result2.toBeProxiedSingleton.op2()).toBe('original2')
-  })
-
-  @Factory()
-  class ToBeProxiedFactory {
-    op() {
-      return 'original'
-    }
-
-    op2() {
-      return 'original2'
-    }
-  }
-
-  class TestInjectionFactory {
-    @Inject(ToBeProxiedFactory) toBeProxiedFactory
-  }
-
-  it('should inject a proxy factory', () => {
-    @Mock(ToBeProxiedFactory, true)
-    class ProxiedFactory {
-      op() {
-        return 'mocked'
-      }
-    }
-
-    const result = new TestInjectionFactory()
-    expect(result.toBeProxiedFactory.op()).toBe('mocked')
-    expect(result.toBeProxiedFactory.op2()).toBe('original2')
-
-    resetMocks()
-    const result2 = new TestInjectionFactory()
-    expect(result2.toBeProxiedFactory.op()).toBe('original')
-    expect(result2.toBeProxiedFactory.op2()).toBe('original2')
-  })
-
-  it('should inject a lazy proxy singleton', () => {
-    @Mock(ToBeProxiedSingleton, true)
-    class ProxiedSingletonLazy {
-      op() {
-        return 'mocked'
-      }
-    }
-
-    class TestInjectionLazy {
-      @InjectLazy(ToBeProxiedSingleton) lazyProxiedSingleton
-    }
-
-    const instance = new TestInjectionLazy()
-    const result = instance.lazyProxiedSingleton
-    expect(result.op()).toBe('mocked')
-    expect(result.op2()).toBe('original2')
-
-    resetMocks()
-    const instance2 = new TestInjectionLazy()
-    expect(instance2.lazyProxiedSingleton.op()).toBe('original')
-    expect(instance2.lazyProxiedSingleton.op2()).toBe('original2')
-  })
-
-  it('should inject a lazy proxy factory', () => {
-    @Factory()
-    class ToBeProxiedFactoryLazy {
-      op() {
-        return 'original'
-      }
-
-      op2() {
-        return 'original2'
-      }
-    }
-
-    class TestInjectionFactoryLazy {
-      @InjectLazy(ToBeProxiedFactoryLazy) lazyProxiedFactory
-    }
-
-    @Mock(ToBeProxiedFactoryLazy, true)
-    class ProxiedFactoryLazy {
-      op() {
-        return 'mocked'
-      }
-    }
-
-    const instance = new TestInjectionFactoryLazy()
-    const result = instance.lazyProxiedFactory
-    expect(result.op()).toBe('mocked')
-    expect(result.op2()).toBe('original2')
-
-    resetMocks()
-    const instance2 = new TestInjectionFactoryLazy()
-    expect(instance2.lazyProxiedFactory.op()).toBe('original')
-    expect(instance2.lazyProxiedFactory.op2()).toBe('original2')
-  })
-})