TSinjex/tests/TSInjex.ts

// deno-coverage-ignore-file
// deno-lint-ignore-file
import {
    assertEquals,
    assertStrictEquals,
    assertThrows,
} from "https://deno.land/std@0.224.0/assert/mod.ts";
import { TSinjex } from "../src/classes/mod.ts";

const container = TSinjex.getInstance() as TSinjex;

Deno.test("should register and resolve a dependency (instance)", () => {
    container.clear();

    const identifier = "myDependency";
    const dependency = { value: 42 };

    container.register(identifier, dependency);

    const resolved = container.resolve<typeof dependency>(identifier);
    assertStrictEquals(resolved, dependency);
});

Deno.test("should register and resolve a dependency (static)", () => {
    container.clear();

    const identifier = "myDependency";
    const dependency = { value: 42 };

    TSinjex.register(identifier, dependency);
    const resolved = TSinjex.resolve<typeof dependency>(identifier);

    assertStrictEquals(resolved, dependency);
});

Deno.test("should throw error when resolving non-registered dependency (static)", () => {
    container.clear();

    const identifier = "nonExistentDependency";
    assertThrows(() => {
        TSinjex.resolve<unknown>(identifier);
    });
});

Deno.test("should return undefined when resolving non-necessary dependency", () => {
    container.clear();

    const result = TSinjex.resolve<unknown>("nonExistentDependency", false);
    assertEquals(result, undefined);
});

Deno.test("should warn when resolving a deprecated dependency", () => {
    container.clear();

    const identifier = "deprecatedDependency";
    const dependency = { value: 42 };

    // Mock console.warn
    const originalWarn = console.warn;
    let wasCalled = false;
    let lastMessage = "";

    console.warn = (msg: string) => {
        wasCalled = true;
        lastMessage = msg;
    };

    try {
        TSinjex.register(identifier, dependency, true);
        const resolved = TSinjex.resolve<typeof dependency>(identifier);
        assertStrictEquals(resolved, dependency);
        if (!wasCalled) {
            throw new Error("console.warn was not called");
        }
    } finally {
        console.warn = originalWarn; // Restore
    }
});