95 lines
3.5 KiB
TypeScript
95 lines
3.5 KiB
TypeScript
import { readFileSync } from "node:fs";
|
|
import { join } from "node:path";
|
|
import { describe, expect, it } from "@suaveplan/testing/runner";
|
|
|
|
describe("tree-shake", () => {
|
|
it("sideEffects is false", { timeout: 5000 }, () => {
|
|
const pkgPath = join(__dirname, "..", "package.json");
|
|
const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as {
|
|
sideEffects?: boolean;
|
|
};
|
|
expect(pkg.sideEffects).toBe(false);
|
|
});
|
|
|
|
it("exposes expected subpath exports", { timeout: 5000 }, () => {
|
|
const pkgPath = join(__dirname, "..", "package.json");
|
|
const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as {
|
|
exports?: Record<string, unknown>;
|
|
};
|
|
const keys = Object.keys(pkg.exports ?? {});
|
|
expect(keys).toContain(".");
|
|
expect(keys).toContain("./core");
|
|
expect(keys).toContain("./fields");
|
|
expect(keys).toContain("./loaders");
|
|
expect(keys).toContain("./errors");
|
|
expect(keys).toContain("./schemas");
|
|
expect(keys).toContain("./package.json");
|
|
});
|
|
|
|
it("main export works — createEnv is callable", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
const { createEnv, str, num, bool } = await import("../src/index.js");
|
|
const env = createEnv({
|
|
schema: {
|
|
HOST: str().default("localhost"),
|
|
PORT: num().default(3000),
|
|
DEBUG: bool().default(false),
|
|
},
|
|
source: {},
|
|
});
|
|
expect(env.HOST).toBe("localhost");
|
|
expect(env.PORT).toBe(3000);
|
|
expect(env.DEBUG).toBe(false);
|
|
});
|
|
|
|
it("errors subpath works", { timeout: 30000 }, async () => {
|
|
const { EnvValidationError, CoercionError } = await import(
|
|
"../src/errors/env-error.js"
|
|
);
|
|
const { ENV_CODES } = await import("../src/errors/error-codes.js");
|
|
expect(ENV_CODES.VALIDATION_FAILED).toBe("ENV.VALIDATION_FAILED");
|
|
expect(ENV_CODES.COERCE_ERROR).toBe("ENV.COERCE_ERROR");
|
|
const err = new CoercionError("KEY", "bad", "number");
|
|
expect(err).toBeInstanceOf(CoercionError);
|
|
const validErr = new EnvValidationError([
|
|
{ key: "PORT", message: "Required variable is missing" },
|
|
]);
|
|
expect(validErr).toBeInstanceOf(EnvValidationError);
|
|
});
|
|
|
|
it("loaders subpath works", { timeout: 30000 }, async () => {
|
|
const { objectLoader, parseDotenv } = await import(
|
|
"../src/loaders/dotenv/dotenv.js"
|
|
);
|
|
const result = parseDotenv("KEY=value\nOTHER=foo");
|
|
expect(result).toEqual({ KEY: "value", OTHER: "foo" });
|
|
const { objectLoader: ol } = await import(
|
|
"../src/loaders/object/object.js"
|
|
);
|
|
const loader = ol({ source: { A: "1" } });
|
|
expect(loader.load().values).toEqual({ A: "1" });
|
|
// suppress unused warning
|
|
void objectLoader;
|
|
});
|
|
|
|
it("schemas subpath works", { timeout: 30000 }, async () => {
|
|
const { FieldConfigSchema, ValidationResultSchema } = await import(
|
|
"../src/schemas/env.schemas.js"
|
|
);
|
|
const result = FieldConfigSchema.safeParse({
|
|
isRequired: true,
|
|
hasDefault: false,
|
|
isSensitive: false,
|
|
rules: [],
|
|
});
|
|
expect(result.success).toBe(true);
|
|
const vr = ValidationResultSchema.safeParse({
|
|
success: true,
|
|
data: {},
|
|
errors: [],
|
|
});
|
|
expect(vr.success).toBe(true);
|
|
});
|
|
});
|