@nodeboot/starter-persistence/dist/adapter/DefaulRepositoriesAdapter.test.js

Nodeboot starter package for persistence. Supports data access layer auto-configuration providing features like database initialization, consistency check, entity mapping, repository pattern, transactions, paging, migrations, persistence listeners, persis

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const DefaultRepositoriesAdapter_1 = require("./DefaultRepositoriesAdapter");
const typeorm_1 = require("typeorm");
const winston_1 = require("winston");
const PersistenceContext_1 = require("../PersistenceContext");
describe("DefaultRepositoriesAdapter", () => {
    let iocContainer;
    let entityManager;
    let logger;
    let repositories;
    beforeEach(() => {
        entityManager = { queryRunner: {}, repositories: new Map() };
        logger = { info: jest.fn() };
        iocContainer = {
            get: jest.fn((cls) => {
                if (cls === typeorm_1.EntityManager)
                    return entityManager;
                if (cls === winston_1.Logger)
                    return logger;
            }),
            set: jest.fn(),
        };
        class TestRepo {
            entity;
            em;
            qr;
            constructor(entity, em, qr) {
                this.entity = entity;
                this.em = em;
                this.qr = qr;
            }
        }
        class TestEntity {
        }
        repositories = [
            { target: TestRepo, entity: TestEntity, type: "custom" },
        ];
        jest.spyOn(PersistenceContext_1.PersistenceContext, "get").mockReturnValue({ repositories });
    });
    afterEach(() => {
        jest.restoreAllMocks();
    });
    it("should bind repositories to IoC container and EntityManager", () => {
        const adapter = new DefaultRepositoriesAdapter_1.DefaultRepositoriesAdapter();
        adapter.bind(iocContainer);
        expect(iocContainer.get).toHaveBeenCalledWith(typeorm_1.EntityManager);
        expect(iocContainer.get).toHaveBeenCalledWith(winston_1.Logger);
        // Check repository instance creation and registration
        const repoInstance = entityManager.repositories.get(repositories[0].target);
        expect(repoInstance).toBeInstanceOf(repositories[0].target);
        expect(iocContainer.set).toHaveBeenCalledWith(repositories[0].target, repoInstance);
        // Check logger call
        expect(logger.info).toHaveBeenCalledWith(`Registering a '${repositories[0].type}' repository '${repositories[0].target.name}' for entity '${repositories[0].entity.name}'`);
    });
    it("does nothing if there are no repositories in PersistenceContext", () => {
        jest.spyOn(PersistenceContext_1.PersistenceContext, "get").mockReturnValue({ repositories: [] });
        const iocContainer = {
            get: jest.fn((cls) => {
                if (cls === typeorm_1.EntityManager)
                    return { queryRunner: {}, repositories: new Map() };
                if (cls === winston_1.Logger)
                    return { info: jest.fn() };
            }),
            set: jest.fn(),
        };
        const adapter = new DefaultRepositoriesAdapter_1.DefaultRepositoriesAdapter();
        adapter.bind(iocContainer);
        expect(iocContainer.set).not.toHaveBeenCalled();
    });
    it("throws if IoC container does not provide EntityManager", () => {
        const iocContainer = {
            get: jest.fn((cls) => {
                if (cls === winston_1.Logger)
                    return { info: jest.fn() };
                return undefined;
            }),
            set: jest.fn(),
        };
        jest.spyOn(PersistenceContext_1.PersistenceContext, "get").mockReturnValue({
            repositories: [
                {
                    target: class {
                    }, entity: class {
                    }, type: "custom",
                },
            ],
        });
        const adapter = new DefaultRepositoriesAdapter_1.DefaultRepositoriesAdapter();
        expect(() => adapter.bind(iocContainer)).toThrow();
    });
    it("throws if IoC container does not provide Logger", () => {
        const iocContainer = {
            get: jest.fn((cls) => {
                if (cls === typeorm_1.EntityManager)
                    return { queryRunner: {}, repositories: new Map() };
                return undefined;
            }),
            set: jest.fn(),
        };
        jest.spyOn(PersistenceContext_1.PersistenceContext, "get").mockReturnValue({
            repositories: [
                {
                    target: class {
                    }, entity: class {
                    }, type: "custom",
                },
            ],
        });
        const adapter = new DefaultRepositoriesAdapter_1.DefaultRepositoriesAdapter();
        expect(() => adapter.bind(iocContainer)).toThrow();
    });
    it("throws if repository target is missing", () => {
        const entityManager = { queryRunner: {}, repositories: new Map() };
        const logger = { info: jest.fn() };
        const iocContainer = {
            get: jest.fn((cls) => {
                if (cls === typeorm_1.EntityManager)
                    return entityManager;
                if (cls === winston_1.Logger)
                    return logger;
            }),
            set: jest.fn(),
        };
        jest.spyOn(PersistenceContext_1.PersistenceContext, "get").mockReturnValue({
            repositories: [
                {
                    entity: class {
                    }, type: "custom",
                },
            ],
        });
        const adapter = new DefaultRepositoriesAdapter_1.DefaultRepositoriesAdapter();
        expect(() => adapter.bind(iocContainer)).toThrow();
    });
    it("throws if repository entity is missing", () => {
        const entityManager = { queryRunner: {}, repositories: new Map() };
        const logger = { info: jest.fn() };
        const iocContainer = {
            get: jest.fn((cls) => {
                if (cls === typeorm_1.EntityManager)
                    return entityManager;
                if (cls === winston_1.Logger)
                    return logger;
            }),
            set: jest.fn(),
        };
        jest.spyOn(PersistenceContext_1.PersistenceContext, "get").mockReturnValue({
            repositories: [
                {
                    target: class {
                    }, type: "custom",
                },
            ],
        });
        const adapter = new DefaultRepositoriesAdapter_1.DefaultRepositoriesAdapter();
        expect(() => adapter.bind(iocContainer)).toThrow();
    });
    it("handles repository constructor throwing an error", () => {
        class FailingRepo {
            constructor() {
                throw new Error("Constructor failed");
            }
        }
        class TestEntity {
        }
        const entityManager = { queryRunner: {}, repositories: new Map() };
        const logger = { info: jest.fn() };
        const iocContainer = {
            get: jest.fn((cls) => {
                if (cls === typeorm_1.EntityManager)
                    return entityManager;
                if (cls === winston_1.Logger)
                    return logger;
            }),
            set: jest.fn(),
        };
        jest.spyOn(PersistenceContext_1.PersistenceContext, "get").mockReturnValue({
            repositories: [{ target: FailingRepo, entity: TestEntity, type: "custom" }],
        });
        const adapter = new DefaultRepositoriesAdapter_1.DefaultRepositoriesAdapter();
        expect(() => adapter.bind(iocContainer)).toThrow("Constructor failed");
    });
    it("throws if entityManager.repositories is missing", () => {
        const entityManager = { queryRunner: {} };
        const logger = { info: jest.fn() };
        const iocContainer = {
            get: jest.fn((cls) => {
                if (cls === typeorm_1.EntityManager)
                    return entityManager;
                if (cls === winston_1.Logger)
                    return logger;
            }),
            set: jest.fn(),
        };
        class TestRepo {
        }
        class TestEntity {
        }
        jest.spyOn(PersistenceContext_1.PersistenceContext, "get").mockReturnValue({
            repositories: [{ target: TestRepo, entity: TestEntity, type: "custom" }],
        });
        const adapter = new DefaultRepositoriesAdapter_1.DefaultRepositoriesAdapter();
        expect(() => adapter.bind(iocContainer)).toThrow();
    });
    it("throws if entityManager.repositories is not a Map", () => {
        const entityManager = { queryRunner: {}, repositories: {} };
        const logger = { info: jest.fn() };
        const iocContainer = {
            get: jest.fn((cls) => {
                if (cls === typeorm_1.EntityManager)
                    return entityManager;
                if (cls === winston_1.Logger)
                    return logger;
            }),
            set: jest.fn(),
        };
        class TestRepo {
        }
        class TestEntity {
        }
        jest.spyOn(PersistenceContext_1.PersistenceContext, "get").mockReturnValue({
            repositories: [{ target: TestRepo, entity: TestEntity, type: "custom" }],
        });
        const adapter = new DefaultRepositoriesAdapter_1.DefaultRepositoriesAdapter();
        expect(() => adapter.bind(iocContainer)).toThrow();
    });
    it("handles logger.info not being a function", () => {
        const entityManager = { queryRunner: {}, repositories: new Map() };
        const logger = {};
        const iocContainer = {
            get: jest.fn((cls) => {
                if (cls === typeorm_1.EntityManager)
                    return entityManager;
                if (cls === winston_1.Logger)
                    return logger;
            }),
            set: jest.fn(),
        };
        class TestRepo {
        }
        class TestEntity {
        }
        jest.spyOn(PersistenceContext_1.PersistenceContext, "get").mockReturnValue({
            repositories: [{ target: TestRepo, entity: TestEntity, type: "custom" }],
        });
        const adapter = new DefaultRepositoriesAdapter_1.DefaultRepositoriesAdapter();
        expect(() => adapter.bind(iocContainer)).toThrow();
    });
    it("registers multiple repositories with different targets", () => {
        class RepoA {
        }
        class RepoB {
        }
        class EntityA {
        }
        class EntityB {
        }
        const entityManager = { queryRunner: {}, repositories: new Map() };
        const logger = { info: jest.fn() };
        const iocContainer = {
            get: jest.fn((cls) => {
                if (cls === typeorm_1.EntityManager)
                    return entityManager;
                if (cls === winston_1.Logger)
                    return logger;
            }),
            set: jest.fn(),
        };
        jest.spyOn(PersistenceContext_1.PersistenceContext, "get").mockReturnValue({
            repositories: [
                { target: RepoA, entity: EntityA, type: "custom" },
                { target: RepoB, entity: EntityB, type: "custom" },
            ],
        });
        const adapter = new DefaultRepositoriesAdapter_1.DefaultRepositoriesAdapter();
        adapter.bind(iocContainer);
        expect(iocContainer.set).toHaveBeenCalledTimes(2);
        expect(logger.info).toHaveBeenCalledTimes(2);
    });
    it("throws if repository target is not a class", () => {
        const entityManager = { queryRunner: {}, repositories: new Map() };
        const logger = { info: jest.fn() };
        const iocContainer = {
            get: jest.fn((cls) => {
                if (cls === typeorm_1.EntityManager)
                    return entityManager;
                if (cls === winston_1.Logger)
                    return logger;
            }),
            set: jest.fn(),
        };
        class TestEntity {
        }
        jest.spyOn(PersistenceContext_1.PersistenceContext, "get").mockReturnValue({
            repositories: [{ target: "notAClass", entity: TestEntity, type: "custom" }],
        });
        const adapter = new DefaultRepositoriesAdapter_1.DefaultRepositoriesAdapter();
        expect(() => adapter.bind(iocContainer)).toThrow();
    });
});
//# sourceMappingURL=DefaulRepositoriesAdapter.test.js.map