test: cover main functionality

Author: castarco

.gitignore

@@ -1,4 +1,5 @@
 # Dependencies, Caches & Artifacts
+coverage/
 dist/
 node_modules/
 tsconfig.tsbuildinfo

lambda-ioc/deno/combinators.ts

@@ -1,4 +1,8 @@
-import { Container, ContainerKey, DependencyFactory } from './container.ts';
+import {
+  ContainerKey,
+  DependencyFactory,
+  ReadableContainer,
+} from './container.ts';
 import { ParamsToResolverKeys, TupleO, Zip } from './util.ts';
 
 /**
@@ -9,8 +13,8 @@ export function singleton<
   TVal,
   TDependencies extends Record<ContainerKey, unknown>,
 >(
-  factory: DependencyFactory<TVal, Container<TDependencies>>,
-): DependencyFactory<TVal, Container<TDependencies>> {
+  factory: DependencyFactory<TVal, ReadableContainer<TDependencies>>,
+): DependencyFactory<TVal, ReadableContainer<TDependencies>> {
   let result: TVal | undefined
 
   return async (container) => {
@@ -82,7 +86,7 @@ export function constructor<
 type FuncContainer<
   TParams extends readonly unknown[],
   TDependencies extends ParamsToResolverKeys<TParams>,
-> = Container<
+> = ReadableContainer<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   TupleO<Extract<Zip<TDependencies, TParams>, readonly [ContainerKey, any][]>>
 >

lambda-ioc/jest.config.js

@@ -10,5 +10,17 @@ module.exports = {
   testPathIgnorePatterns: [
     'node_modules',
     'dist'
-  ]
+  ],
+  collectCoverageFrom: [
+    '<rootDir>/src/**/*.{js,ts}',
+    '!<rootDir>/src/**/__tests__/**/*.{js,ts}',
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 99,
+      functions: 99,
+      lines: 99,
+      statements: 99,
+    },
+  },
 }

lambda-ioc/src/__tests__/constructor.test.ts

@@ -0,0 +1,41 @@
+import { constructor, createContainer, singleton } from '..'
+
+describe('constructor', () => {
+  it('can be registered without parameters', async () => {
+    class A {}
+    const container = createContainer().register('A', constructor(A))
+    const a = await container.resolve('A')
+    expect(a).toBeInstanceOf(A)
+  })
+
+  it('can be registered with parameters', async () => {
+    class A {}
+    class B {
+      constructor(readonly a: A) {}
+    }
+    class C {
+      constructor(readonly b: B) {}
+    }
+
+    const container = createContainer()
+      .register('A', constructor(A))
+      .register('B', constructor(B, 'A'))
+      .register('C', singleton(constructor(C, 'B')))
+
+    // We abuse a bit this test to verify other tangential properties, like
+    // uniqueness of instances.
+    const b1 = await container.resolve('B')
+    const b2 = await container.resolve('B')
+
+    expect(b1).toBeInstanceOf(B) // That's the real test.
+    expect(b2).toBeInstanceOf(B)
+    expect(b1).not.toBe(b2)
+
+    const c1 = await container.resolve('C')
+    const c2 = await container.resolve('C')
+
+    expect(c1).toBeInstanceOf(C)
+    expect(c2).toBeInstanceOf(C)
+    expect(c1).toBe(c2)
+  })
+})

lambda-ioc/src/__tests__/container.test.ts

@@ -0,0 +1,21 @@
+import { createContainer } from '..'
+
+describe('container', () => {
+  it('can register simple values', async () => {
+    const container = createContainer()
+      .registerValue('foo', 'bar')
+      .registerValue('theanswer', 42)
+
+    expect(await container.resolve('foo')).toBe('bar')
+    expect(await container.resolve('theanswer')).toBe(42)
+  })
+
+  it('can register simple factories', async () => {
+    const container = createContainer()
+      .register('foo', () => 'bar')
+      .register('theanswer', () => 42)
+
+    expect(await container.resolve('foo')).toBe('bar')
+    expect(await container.resolve('theanswer')).toBe(42)
+  })
+})

lambda-ioc/src/__tests__/fake.test.ts

@@ -0,0 +1,37 @@
+import { createContainer, func } from '..'
+
+describe('func', () => {
+  it('can be registered without parameters', async () => {
+    const container = createContainer().register(
+      'foo',
+      func(() => 'result'),
+    )
+    expect((await container.resolve('foo'))()).toBe('result')
+  })
+
+  it('can be registered with parameters', async () => {
+    const container = createContainer()
+      .registerValue('a', 3)
+      .registerValue('b', 5)
+      .register(
+        'f',
+        func((a: number, b: number) => a * b, 'a', 'b'),
+      )
+
+    expect((await container.resolve('f'))()).toBe(15)
+  })
+
+  it('resolves a new function each time', async () => {
+    const container = createContainer().register(
+      'foo',
+      func(() => 'result'),
+    )
+
+    const f1 = await container.resolve('foo')
+    const f2 = await container.resolve('foo')
+
+    expect(f1()).toBe('result')
+    expect(f2()).toBe('result')
+    expect(f1).not.toBe(f2)
+  })
+})

lambda-ioc/src/__tests__/func.test.ts

@@ -0,0 +1,31 @@
+import { createContainer, func, singleton } from '..'
+
+describe('singleton', () => {
+  it('resolves the same instance each time (no dependencies)', async () => {
+    const container = createContainer().register(
+      'foo',
+      singleton(func(() => 'result')),
+    )
+
+    const f1 = await container.resolve('foo')
+    const f2 = await container.resolve('foo')
+
+    expect(f1()).toBe('result')
+    expect(f2()).toBe('result')
+    expect(f1).toBe(f2)
+  })
+
+  it('resolves the same instance each time (multiple dependencies)', async () => {
+    const container = createContainer()
+      .registerValue('a', 3)
+      .registerValue('b', 5)
+      .register('f', singleton(func((a: number, b: number) => a * b, 'a', 'b')))
+
+    const f1 = await container.resolve('f')
+    const f2 = await container.resolve('f')
+
+    expect(f1()).toBe(15)
+    expect(f2()).toBe(15)
+    expect(f1).toBe(f2)
+  })
+})

lambda-ioc/src/__tests__/singleton.test.ts

@@ -1,4 +1,8 @@
-import { Container, ContainerKey, DependencyFactory } from './container'
+import {
+  ContainerKey,
+  DependencyFactory,
+  ReadableContainer,
+} from './container'
 import { ParamsToResolverKeys, TupleO, Zip } from './util'
 
 /**
@@ -9,8 +13,8 @@ export function singleton<
   TVal,
   TDependencies extends Record<ContainerKey, unknown>,
 >(
-  factory: DependencyFactory<TVal, Container<TDependencies>>,
-): DependencyFactory<TVal, Container<TDependencies>> {
+  factory: DependencyFactory<TVal, ReadableContainer<TDependencies>>,
+): DependencyFactory<TVal, ReadableContainer<TDependencies>> {
   let result: TVal | undefined
 
   return async (container) => {
@@ -82,7 +86,7 @@ export function constructor<
 type FuncContainer<
   TParams extends readonly unknown[],
   TDependencies extends ParamsToResolverKeys<TParams>,
-> = Container<
+> = ReadableContainer<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   TupleO<Extract<Zip<TDependencies, TParams>, readonly [ContainerKey, any][]>>
 >