import { SuaveplanError } from "@suaveplan/error";
import { describe, expect, it } from "@suaveplan/testing/runner";
import { SEED_CODES, SeedError } from "./error-codes.js";

describe("SEED_CODES registry", () => {
    it("declares every required code with namespaced value", () => {
        expect(SEED_CODES.DUPLICATE_NAME).toBe("SEED.DUPLICATE_NAME");
        expect(SEED_CODES.UNREGISTERED_DEPENDENCY).toBe(
            "SEED.UNREGISTERED_DEPENDENCY"
        );
        expect(SEED_CODES.CIRCULAR_DEPENDENCY).toBe("SEED.CIRCULAR_DEPENDENCY");
        expect(SEED_CODES.DEPENDENCY_DEPTH_EXCEEDED).toBe(
            "SEED.DEPENDENCY_DEPTH_EXCEEDED"
        );
        expect(SEED_CODES.INVALID_CONFIG).toBe("SEED.INVALID_CONFIG");
        expect(SEED_CODES.STORE_ERROR).toBe("SEED.STORE_ERROR");
        expect(SEED_CODES.ABORTED).toBe("SEED.ABORTED");
    });

    it("registry is frozen", () => {
        expect(Object.isFrozen(SEED_CODES)).toBe(true);
    });
});

describe("SeedError", () => {
    it("every SEED.* code is reachable from a call site", () => {
        for (const code of Object.values(SEED_CODES)) {
            const err = new SeedError(code, `test ${code}`);
            expect(err.code).toBe(code);
            expect(err).toBeInstanceOf(SuaveplanError);
            expect(err).toBeInstanceOf(SeedError);
            expect(err).toBeInstanceOf(Error);
        }
    });

    it("SeedError preserves cause and SuaveplanError contract", () => {
        const root = new Error("underlying boom");
        const err = new SeedError(SEED_CODES.STORE_ERROR, "wrap", {
            cause: root,
        });
        expect(err.cause).toBe(root);
        expect(err.code).toBe("SEED.STORE_ERROR");
        expect(err.timestamp).toBeTypeOf("number");
        expect(err.message).toBe("wrap");
    });

    it("exposes seedName discriminant when provided", () => {
        const err = new SeedError(SEED_CODES.DUPLICATE_NAME, "dup", {
            seedName: "users",
        });
        expect(err.seedName).toBe("users");
        expect(err.dependency).toBeUndefined();
    });

    it("exposes dependency discriminant when provided", () => {
        const err = new SeedError(
            SEED_CODES.UNREGISTERED_DEPENDENCY,
            "missing",
            {
                seedName: "posts",
                dependency: "users",
            }
        );
        expect(err.seedName).toBe("posts");
        expect(err.dependency).toBe("users");
    });

    it("omits discriminants when not provided", () => {
        const err = new SeedError(SEED_CODES.INVALID_CONFIG, "bad config");
        expect(err.seedName).toBeUndefined();
        expect(err.dependency).toBeUndefined();
    });
});