@declaro/core 2.0.0-beta.8 → 2.0.0-y.0

package/src/context/context.test.ts

@@ -1,144 +1,635 @@
-import { Context } from '.'
-import { sleep } from '../timing'
-import { ContextConsumer } from './context-consumer'
-import { describe, it, vi } from 'vitest'
+import { describe, expect, it } from 'vitest'
+import { Context } from './context'
 
 describe('Context', () => {
-    it('Should allow simple value dependency injection', async ({ expect }) => {
-        const context = new Context()
+    it('Should allow value dependency injection', async () => {
+        type Scope = {
+            foo: string
+            bar: number
+        }
+        const context = new Context<Scope>()
+
+        context.registerValue('foo', 'Hello')
+        context.registerValue('bar', 42)
+
+        const foo = context.resolve('foo')
+        const bar = context.resolve('bar')
+
+        expect(foo).toBe('Hello')
+        expect(bar).toBe(42)
+    })
+
+    it('Should allow factory dependency injection', async () => {
+        type Scope = {
+            foo: string
+            bar: number
+            name: string
+        }
+        const context = new Context<Scope>()
+
+        context.registerValue('bar', 42)
+        context.registerValue('name', 'Person')
+
+        context.registerFactory('foo', (name: string, bar: number) => `Hello ${name}, the answer is ${bar}`, [
+            'name',
+            'bar',
+        ])
+
+        const foo = context.resolve('foo')
+
+        expect(foo).toBe('Hello Person, the answer is 42')
+    })
+
+    it('Should allow async factory dependency injection', async () => {
+        type Scope = {
+            foo: Promise<string>
+            bar: number
+            name: Promise<string>
+            baz: string
+        }
+        const context = new Context<Scope>()
+
+        context.registerValue('bar', 42)
+        context.registerAsyncFactory('name', async () => 'Person')
+
+        context.registerAsyncFactory(
+            'foo',
+            async (name: string, bar: number) => `Hello ${name}, the answer is ${bar}`,
+            ['name', 'bar'],
+        )
+
+        const foo = await context.resolve('foo')
+
+        expect(foo).toBe('Hello Person, the answer is 42')
+    })
+
+    it('should allow class dependency injection', async () => {
+        class Thing1 {
+            constructor(public name: string) {}
+
+            testThing1() {
+                return `Hello, ${this.name}, this is Thing 1`
+            }
+        }
+
+        class Thing2 {
+            constructor(public thing1: Thing1, public bar: number) {}
+
+            testThing2() {
+                return this.thing1.testThing1() + ' and Thing 2. The answer is ' + this.bar.toString()
+            }
+        }
+
+        type Scope = {
+            foo: string
+            bar: number
+            name: string
+            thing1: Thing1
+            thing2: Thing2
+        }
+        const context = new Context<Scope>()
+
+        context.registerValue('bar', 42)
+        context.registerValue('name', 'Person')
+
+        context.registerClass('thing1', Thing1, ['name'])
+        context.registerClass('thing2', Thing2, ['thing1', 'bar'])
+
+        const thing1 = context.resolve('thing1')
+        const thing2 = context.resolve('thing2')
+
+        expect(thing1.testThing1()).toBe('Hello, Person, this is Thing 1')
+        expect(thing2.testThing2()).toBe('Hello, Person, this is Thing 1 and Thing 2. The answer is 42')
+    })
+
+    it('should allow class dependency injection with async dependencies', async () => {
+        class Greeting {
+            constructor(public name: string) {}
+
+            greet() {
+                return `Hello, ${this.name}.`
+            }
+        }
+
+        class AgeCalculator {
+            constructor(public name: string, public age: number) {}
+
+            printAge() {
+                return `${this.name} is ${this.age} years old.`
+            }
+        }
 
-        context.provide('test', 'Hello World')
+        type Scope = {
+            name: Promise<string>
+            age: number
+            greeting: Promise<Greeting>
+            ageCalculator: Promise<AgeCalculator>
+        }
 
-        const message = context.inject('test')
+        const context = new Context<Scope>()
 
-        expect(message).toBe('Hello World')
+        context.registerValue('age', 42)
+        context.registerAsyncFactory('name', async () => 'Person')
+        context.registerAsyncClass('greeting', Greeting, ['name'])
+        context.registerAsyncClass('ageCalculator', AgeCalculator, ['name', 'age'])
 
-        const TEST_KEY = Symbol()
-        context.provide(TEST_KEY, 42)
+        const greeting = await context.resolve('greeting')
+        const ageCalculator = await context.resolve('ageCalculator')
 
-        const number = context.inject(TEST_KEY)
-        expect(number).toBe(42)
+        expect(greeting.greet()).toBe('Hello, Person.')
+        expect(ageCalculator.printAge()).toBe('Person is 42 years old.')
     })
 
-    it('Should allow subscription to arbitrary events', async ({ expect }) => {
-        const customEventCall = vi.fn()
+    it('should support singletons', async () => {
+        let factoryInstances = 0
+        let asyncFactoryInstances = 0
+        let classInstances = 0
 
-        const context = new Context()
-        context.provide('test', 'Hello World')
-        expect(customEventCall.mock.calls.length).toBe(0)
+        class Singleton {
+            constructor(public value: string) {
+                classInstances = classInstances + 1
+            }
 
-        context.on('customEvent', async (ctx, arg1, arg2, arg3) => {
-            customEventCall()
-            const message = await ctx.inject('test')
-            expect(message).toBe('Hello World')
-            expect(arg1).toBe(1)
-            expect(arg2).toBe(2)
-            expect(arg3).toBe(3)
+            test() {
+                return 'From a class: ' + this.value
+            }
+        }
+
+        type Scope = {
+            singletonValue: number
+            singletonFactory: string
+            singletonAsyncFactory: Promise<string>
+            singletonClass: Singleton
+            singletonAsyncClass: Promise<Singleton>
+        }
+
+        const context = new Context<Scope>()
+
+        context.registerValue('singletonValue', 42) // Note: Values are inherently singletons
+        context.registerFactory(
+            'singletonFactory',
+            (value: number) => {
+                factoryInstances = factoryInstances + 1
+                return `The answer is ${value}`
+            },
+            ['singletonValue'],
+            {
+                singleton: true,
+            },
+        )
+        context.registerAsyncFactory(
+            'singletonAsyncFactory',
+            async (answer: string) => {
+                asyncFactoryInstances = asyncFactoryInstances + 1
+                return `Since you've waited a long time, ${answer}`
+            },
+            ['singletonFactory'],
+            {
+                singleton: true,
+            },
+        )
+        context.registerClass('singletonClass', Singleton, ['singletonFactory'], {
+            singleton: true,
         })
+        context.registerAsyncClass('singletonAsyncClass', Singleton, ['singletonAsyncFactory'], {
+            singleton: true,
+        })
+
+        const singletonValue = context.resolve('singletonValue')
+        const singletonFactory = context.resolve('singletonFactory')
+        const singletonAsyncFactory = await context.resolve('singletonAsyncFactory')
+        const singletonClass = context.resolve('singletonClass')
+        const singletonAsyncClass = await context.resolve('singletonAsyncClass')
 
-        await context.emit('customEvent', 1, 2, 3)
+        expect(singletonValue).toBe(42)
+        expect(singletonFactory).toBe('The answer is 42')
+        expect(singletonAsyncFactory).toBe("Since you've waited a long time, The answer is 42")
+        expect(singletonClass.test()).toBe('From a class: The answer is 42')
+        expect(singletonAsyncClass.test()).toBe("From a class: Since you've waited a long time, The answer is 42")
 
-        expect(customEventCall.mock.calls.length).toBe(1)
+        expect(factoryInstances).toBe(1)
+        expect(classInstances).toBe(2)
     })
 
-    it('Should extend other contexts', async ({ expect }) => {
-        const context1 = new Context()
-        const context2 = new Context()
-        const context3 = new Context()
+    it('should support eager dependencies', async () => {
+        type Scope = {
+            foo: string
+            bar: number
+            name: string
+        }
+        const context = new Context<Scope>()
+
+        context.registerValue('bar', 42)
+        context.registerValue('name', 'Person')
+
+        let factoryInstances = 0
+
+        context.registerFactory(
+            'foo',
+            (name: string, bar: number) => {
+                factoryInstances = factoryInstances + 1
+                return `Hello ${name}, the answer is ${bar}`
+            },
+            ['name', 'bar'],
+            {
+                eager: true,
+            },
+        )
 
-        const SYMBOL_KEY = Symbol()
+        expect(factoryInstances).toBe(0)
 
-        context1.provide('a', 1)
-        context1.provide('c', 1)
-        context2.provide('b', 2)
-        context2.provide('c', 2)
-        context2.provide(SYMBOL_KEY, 42)
-        context3.provide('c', 3)
+        await context.emit('declaro:init')
 
-        context1.extend(context2, context3)
+        expect(factoryInstances).toBe(1)
 
-        const a = context1.inject('a')
-        const b = context1.inject('b')
-        const c = context1.inject('c')
-        const symbolValue = context1.inject(SYMBOL_KEY)
+        const foo = context.resolve('foo')
 
-        expect(a).toBe(1)
-        expect(b).toBe(2)
-        expect(c).toBe(3)
-        expect(symbolValue).toBe(42)
+        expect(factoryInstances).toBe(1)
+
+        expect(foo).toBe('Hello Person, the answer is 42')
     })
 
-    it('Should nest contexts', async ({ expect }) => {
-        const context1 = new Context()
-        const context2 = new Context()
+    it('should support scope resolution', async () => {
+        type Scope = {
+            foo: string
+            bar: number
+            name: string
+        }
+        const context = new Context<Scope>()
+
+        context.registerValue('bar', 42)
+        context.registerValue('name', 'Person')
+
+        let factoryInstances = 0
+
+        context.registerFactory(
+            'foo',
+            (name: string, bar: number) => {
+                factoryInstances = factoryInstances + 1
+                return `Hello ${name}, the answer is ${bar}`
+            },
+            ['name', 'bar'],
+        )
 
-        context1.provide('a', 1)
-        context2.provide('a', 2)
+        expect(factoryInstances).toBe(0)
 
-        context1.provide('nested', context2)
+        const foo = context.scope.foo
 
-        const a1 = context1.inject('a')
-        const a2 = context1.inject<Context>('nested')?.inject('a')
+        expect(factoryInstances).toBe(1)
+        expect(foo).toBe('Hello Person, the answer is 42')
 
-        expect(a1).toBe(1)
-        expect(a2).toBe(2)
+        const foo2 = context.scope.foo
+
+        expect(factoryInstances).toBe(2)
+        expect(foo2).toBe('Hello Person, the answer is 42')
+
+        expect(context.scope.bar).toBe(42)
+        expect(context.scope.name).toBe('Person')
     })
 
-    it('Should allow async middleware', async ({ expect }) => {
-        const context = new Context()
+    it('should support merging scopes', async () => {
+        type ScopeA = {
+            bar: number
+            name: string
+            foo: string
+        }
+        const context = new Context<ScopeA>()
+
+        let factoryInstances = 0
 
-        await context.use(async (context) => {
-            context.provide('TEST1', 'Hello World')
-            await sleep(1)
-            context.provide('TEST2', 'Hello Test')
+        context.registerValue('bar', 42)
+        context.registerValue('name', 'Person')
+        context.registerFactory('foo', () => {
+            factoryInstances = factoryInstances + 1
+            return 'This should never run'
         })
 
-        const test1 = context.inject('TEST1')
-        const test2 = context.inject('TEST2')
-        expect(test1).toBe('Hello World')
-        expect(test2).toBe('Hello Test')
+        type ScopeB = ScopeA & {
+            foo: string
+            baz: number
+        }
+
+        const context2 = new Context<ScopeB>()
+        context2.extend(context)
+
+        context2.registerFactory(
+            'foo',
+            (name: string, bar: number) => {
+                factoryInstances = factoryInstances + 1
+                return `Hello ${name}, the answer is ${bar}`
+            },
+            ['name', 'bar'],
+        )
+        context2.registerValue('baz', 100)
+
+        // Ensure that merging doesn't actually run any factories
+        expect(factoryInstances).toBe(0)
+
+        const foo = context2.scope.foo
+
+        expect(factoryInstances).toBe(1)
+        expect(foo).toBe('Hello Person, the answer is 42')
+
+        const foo2 = context2.scope.foo
+
+        expect(factoryInstances).toBe(2)
+        expect(foo2).toBe('Hello Person, the answer is 42')
+
+        expect(context2.scope.bar).toBe(42)
+        expect(context2.scope.name).toBe('Person')
     })
 
-    it('Should allow singletons', ({ expect }) => {
-        const context = new Context()
+    it(`Should allow factories without args`, () => {
+        type Scope = {
+            foo: string
+        }
+        const context = new Context<Scope>()
+
+        context.registerFactory('foo', () => 'Hello')
 
-        const KEY = Symbol()
-        let instance = context.singleton(KEY, 1)
-        instance = context.singleton(KEY, 2)
-        instance = context.singleton(KEY, 3)
+        const foo = context.resolve('foo')
 
-        expect(instance).toBe(1)
+        expect(foo).toBe('Hello')
     })
 
-    it('Should allow hydration', ({ expect }) => {
-        const context = new Context()
+    it('should get nested dependencies', async () => {
+        type Scope = {
+            foo: string
+        }
 
-        class Test extends ContextConsumer {
-            constructor(public context: Context) {
-                super(context)
-            }
+        type ScopeA = Scope & {
+            bar: string
+        }
 
-            test() {
-                return 'Yes'
-            }
+        type ScopeB = ScopeA & {
+            baz: string
         }
 
-        expect(context.hydrate(Test).test()).toBe('Yes')
+        type ScopeC = ScopeB & {
+            qux: string
+        }
+
+        const context = new Context<Scope>()
+        context.registerFactory('foo', () => 'A partridge in a pear tree')
+
+        const contextA = new Context<ScopeA>()
+        contextA.extend(context)
+        contextA.registerFactory('bar', (foo: string) => `${foo}, two turtle doves`, ['foo'])
+
+        const contextB = new Context<ScopeB>()
+        contextB.extend(contextA)
+        contextB.registerFactory('baz', (bar: string) => `${bar}, three French hens`, ['bar'])
+
+        const contextC = new Context<ScopeC>()
+        contextC.extend(contextB)
+        contextC.registerFactory('qux', (baz: string) => `${baz}, four calling birds`, ['baz'])
+
+        const qux = contextC.resolve('qux')
+
+        const allDependencies = contextC.getAllDependencies('qux')
+
+        expect(allDependencies[0].key).toBe('baz')
+        expect(allDependencies[1].key).toBe('bar')
+        expect(allDependencies[2].key).toBe('foo')
+
+        expect(allDependencies[0].inject).toEqual(['bar'])
+        expect(allDependencies[1].inject).toEqual(['foo'])
+        expect(allDependencies[2].inject).toEqual([])
+
+        expect(qux).toBe('A partridge in a pear tree, two turtle doves, three French hens, four calling birds')
     })
 
-    it('Should allow hydration with args', ({ expect }) => {
-        const context = new Context()
+    it('should get nested dependent values', async () => {
+        type Scope = {
+            foo: string
+        }
 
-        class Test extends ContextConsumer {
-            constructor(public context: Context, foo: string, bar: number) {
-                super(context)
-            }
+        type ScopeA = Scope & {
+            bar: string
+        }
 
-            test() {
-                return 'Yes'
-            }
+        type ScopeB = ScopeA & {
+            baz: string
+        }
+
+        type ScopeC = ScopeB & {
+            qux: string
+        }
+
+        const context = new Context<Scope>()
+        context.registerFactory('foo', () => 'A partridge in a pear tree')
+
+        const contextA = new Context<ScopeA>()
+        contextA.extend(context)
+        contextA.registerFactory('bar', (foo: string) => `${foo}, two turtle doves`, ['foo'])
+
+        const contextB = new Context<ScopeB>()
+        contextB.extend(contextA)
+        contextB.registerFactory('baz', (bar: string) => `${bar}, three French hens`, ['bar'])
+
+        const contextC = new Context<ScopeC>()
+        contextC.extend(contextB)
+        contextC.registerFactory('qux', (baz: string) => `${baz}, four calling birds`, ['baz'])
+
+        const dependents = contextC.getAllDependents('foo')
+
+        expect(dependents[0].key).toBe('bar')
+        expect(dependents[1].key).toBe('baz')
+        expect(dependents[2].key).toBe('qux')
+
+        expect(dependents[0].inject).toEqual(['foo'])
+        expect(dependents[1].inject).toEqual(['bar'])
+        expect(dependents[2].inject).toEqual(['baz'])
+    })
+
+    it('should protect against scope leakage', async () => {
+        type BaseScope = {
+            foo: string
+            bar: string
+            base: string
+            validSingleton: string
+            validCachedSingleton: string
+        }
+
+        type ScopeA = BaseScope & {
+            baz: string
+        }
+
+        type ScopeB = BaseScope & {
+            qux: string
         }
 
-        expect(context.hydrate(Test, 'hello', 42).test()).toBe('Yes')
+        const baseContext = new Context<BaseScope>()
+
+        baseContext.registerFactory('foo', () => 'Hello', [], {
+            singleton: true,
+        })
+        baseContext.registerFactory('bar', () => 'World', [])
+        baseContext.registerFactory('base', (foo: string, bar: string) => `Base: ${foo} ${bar}`, ['foo', 'bar'], {
+            singleton: true,
+        })
+        let validSingletonInstances = 0
+        baseContext.registerFactory(
+            'validSingleton',
+            () => {
+                validSingletonInstances = validSingletonInstances + 1
+                return 'Singleton'
+            },
+            [],
+            {
+                singleton: true,
+            },
+        )
+        let validCachedSingletonInstances = 0
+        baseContext.registerFactory(
+            'validCachedSingleton',
+            () => {
+                validCachedSingletonInstances = validCachedSingletonInstances + 1
+                return 'Cached Singleton'
+            },
+            [],
+            {
+                singleton: true,
+            },
+        )
+
+        // Resolve this before forking context to ensure that the cached value gets passed on.
+        const base = baseContext.resolve('base')
+        const validCachedSingleton = baseContext.resolve('validCachedSingleton')
+
+        const contextA = new Context<ScopeA>()
+        contextA.extend(baseContext)
+        // Override a value that the singleton is going to depend on, but is not a singleton
+        contextA.registerFactory('bar', () => 'Robby', [])
+        // Add another property that dependes on the overridden value
+        contextA.registerFactory('baz', (foo: string, bar: string) => `${foo} ${bar}`, ['foo', 'bar'], {
+            singleton: true,
+        })
+
+        const contextB = new Context<ScopeB>()
+        contextB.extend(baseContext)
+        // Override a value that the singleton is going to depend on, and is also a singleton
+        contextB.registerFactory('foo', () => 'Goodbye', [], {
+            singleton: true,
+        })
+        // Add another property that dependes on the overridden value
+        contextB.registerFactory('qux', (foo: string, bar: string) => `${foo} ${bar}`, ['foo', 'bar'], {
+            singleton: true,
+        })
+
+        const baseA = contextA.resolve('base')
+        const baseB = contextB.resolve('base')
+
+        const baz = contextA.resolve('baz')
+        const qux = contextB.resolve('qux')
+        const foo = baseContext.resolve('foo')
+        const bar = baseContext.resolve('bar')
+
+        const validSingleton = baseContext.resolve('validSingleton')
+        const validSingletonA = contextA.resolve('validSingleton')
+        const validSingletonB = contextB.resolve('validSingleton')
+
+        const validCachedSingletonA = contextA.resolve('validCachedSingleton')
+        const validCachedSingletonB = contextB.resolve('validCachedSingleton')
+
+        // resolve them all again
+        baseContext.resolve('validSingleton')
+        contextA.resolve('validSingleton')
+        contextB.resolve('validSingleton')
+        baseContext.resolve('validCachedSingleton')
+        contextA.resolve('validCachedSingleton')
+        contextB.resolve('validCachedSingleton')
+
+        expect(baz).toBe('Hello Robby')
+        expect(qux).toBe('Goodbye World')
+        expect(foo).toBe('Hello')
+        expect(bar).toBe('World')
+
+        expect(baseA).toBe('Base: Hello Robby')
+        expect(baseB).toBe('Base: Goodbye World')
+        expect(base).toBe('Base: Hello World')
+
+        expect(validSingleton).toBe('Singleton')
+        expect(validSingletonA).toBe('Singleton')
+        expect(validSingletonB).toBe('Singleton')
+
+        expect(validCachedSingleton).toBe('Cached Singleton')
+        expect(validCachedSingletonA).toBe('Cached Singleton')
+        expect(validCachedSingletonB).toBe('Cached Singleton')
+
+        expect(validSingletonInstances).toBe(3)
+        expect(validCachedSingletonInstances).toBe(1)
+    })
+
+    it('should invalid nested dependency caches when overriding a value', async () => {
+        type Scope = {
+            foo: string
+        }
+
+        type ScopeA = Scope & {
+            bar: string
+        }
+
+        type ScopeB = ScopeA & {
+            baz: string
+        }
+
+        type ScopeC = ScopeB & {
+            qux: string
+        }
+
+        const context = new Context<Scope>()
+        context.registerFactory('foo', () => 'A partridge in a pear tree', [], {
+            singleton: true,
+        })
+        context.resolve('foo')
+
+        const contextA = new Context<ScopeA>()
+        contextA.extend(context)
+        contextA.registerFactory('bar', (foo: string) => `two turtle doves, ${foo}`, ['foo'], {
+            singleton: true,
+        })
+        contextA.resolve('bar')
+
+        const contextB = new Context<ScopeB>()
+        contextB.extend(contextA)
+        contextB.registerFactory('baz', (bar: string) => `three French hens, ${bar}`, ['bar'], {
+            singleton: true,
+        })
+        contextB.resolve('baz')
+
+        const contextC = new Context<ScopeC>()
+        contextC.extend(contextB)
+        contextC.registerFactory('qux', (baz: string) => `four calling birds, ${baz}`, ['baz'], {
+            singleton: true,
+        })
+        contextC.resolve('qux')
+        contextC.registerFactory('foo', () => 'and a partridge in a pear tree', [], {
+            singleton: true,
+        })
+
+        const fooCache = contextC.introspect('foo').cachedValue
+        const barCache = contextC.introspect('bar').cachedValue
+        const bazCache = contextC.introspect('baz').cachedValue
+        const quxCache = contextC.introspect('qux').cachedValue
+
+        expect(fooCache).toBeUndefined()
+        expect(barCache).toBeUndefined()
+        expect(bazCache).toBeUndefined()
+        expect(quxCache).toBeUndefined()
+
+        contextC.resolve('qux')
+
+        const fooCache2 = contextC.introspect('foo').cachedValue
+        const barCache2 = contextC.introspect('bar').cachedValue
+        const bazCache2 = contextC.introspect('baz').cachedValue
+        const quxCache2 = contextC.introspect('qux').cachedValue
+
+        expect(fooCache2).toBe('and a partridge in a pear tree')
+        expect(barCache2).toBe('two turtle doves, and a partridge in a pear tree')
+        expect(bazCache2).toBe('three French hens, two turtle doves, and a partridge in a pear tree')
+        expect(quxCache2).toBe(
+            'four calling birds, three French hens, two turtle doves, and a partridge in a pear tree',
+        )
     })
 })