113 lines
3.5 KiB
TypeScript
113 lines
3.5 KiB
TypeScript
import { describe, expect, it } from "@suaveplan/testing/runner";
|
|
import {
|
|
BatchMigratorConfigSchema,
|
|
DistributedLockConfigSchema,
|
|
MemoryStorageOptionsSchema,
|
|
MigrationRunnerOptionsSchema,
|
|
RedisLockConfigSchema,
|
|
RunOptionsSchema,
|
|
} from "./migration.schemas.js";
|
|
|
|
describe("RunOptionsSchema", () => {
|
|
it("parses empty object", { timeout: 5000 }, () => {
|
|
const r = RunOptionsSchema.parse({});
|
|
expect(r.signal).toBeUndefined();
|
|
expect(r.target).toBeUndefined();
|
|
});
|
|
|
|
it("parses with target", { timeout: 5000 }, () => {
|
|
const r = RunOptionsSchema.parse({ target: "001_init" });
|
|
expect(r.target).toBe("001_init");
|
|
});
|
|
|
|
it("parses with signal", { timeout: 5000 }, () => {
|
|
const ctrl = new AbortController();
|
|
const r = RunOptionsSchema.parse({ signal: ctrl.signal });
|
|
expect(r.signal).toBe(ctrl.signal);
|
|
});
|
|
|
|
it("rejects extra keys", { timeout: 5000 }, () => {
|
|
expect(() => RunOptionsSchema.parse({ unknown: true })).toThrow();
|
|
});
|
|
});
|
|
|
|
describe("MigrationRunnerOptionsSchema", () => {
|
|
it("applies defaults", { timeout: 5000 }, () => {
|
|
const r = MigrationRunnerOptionsSchema.parse({});
|
|
expect(r.dryRun).toBe(false);
|
|
expect(r.checksumValidation).toBe(true);
|
|
});
|
|
|
|
it("accepts overrides", { timeout: 5000 }, () => {
|
|
const r = MigrationRunnerOptionsSchema.parse({
|
|
dryRun: true,
|
|
checksumValidation: false,
|
|
});
|
|
expect(r.dryRun).toBe(true);
|
|
expect(r.checksumValidation).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("DistributedLockConfigSchema", () => {
|
|
it("parses empty object", { timeout: 5000 }, () => {
|
|
const r = DistributedLockConfigSchema.parse({});
|
|
expect(r.key).toBeUndefined();
|
|
});
|
|
|
|
it("rejects negative ttl", { timeout: 5000 }, () => {
|
|
expect(() => DistributedLockConfigSchema.parse({ ttl: -1 })).toThrow();
|
|
});
|
|
|
|
it("accepts positive ttl", { timeout: 5000 }, () => {
|
|
const r = DistributedLockConfigSchema.parse({ ttl: 5000 });
|
|
expect(r.ttl).toBe(5000);
|
|
});
|
|
});
|
|
|
|
describe("RedisLockConfigSchema", () => {
|
|
it("parses with key", { timeout: 5000 }, () => {
|
|
const r = RedisLockConfigSchema.parse({ key: "my-lock" });
|
|
expect(r.key).toBe("my-lock");
|
|
});
|
|
|
|
it("rejects zero ttl", { timeout: 5000 }, () => {
|
|
expect(() => RedisLockConfigSchema.parse({ ttl: 0 })).toThrow();
|
|
});
|
|
});
|
|
|
|
describe("BatchMigratorConfigSchema", () => {
|
|
it("defaults concurrency to 5", { timeout: 5000 }, () => {
|
|
const r = BatchMigratorConfigSchema.parse({});
|
|
expect(r.concurrency).toBe(5);
|
|
});
|
|
|
|
it("rejects concurrency of 0", { timeout: 5000 }, () => {
|
|
expect(() =>
|
|
BatchMigratorConfigSchema.parse({ concurrency: 0 })
|
|
).toThrow();
|
|
});
|
|
|
|
it("accepts positive concurrency", { timeout: 5000 }, () => {
|
|
const r = BatchMigratorConfigSchema.parse({ concurrency: 3 });
|
|
expect(r.concurrency).toBe(3);
|
|
});
|
|
});
|
|
|
|
describe("MemoryStorageOptionsSchema", () => {
|
|
it("parses empty", { timeout: 5000 }, () => {
|
|
const r = MemoryStorageOptionsSchema.parse({});
|
|
expect(r.maxSize).toBeUndefined();
|
|
});
|
|
|
|
it("accepts maxSize", { timeout: 5000 }, () => {
|
|
const r = MemoryStorageOptionsSchema.parse({ maxSize: 100 });
|
|
expect(r.maxSize).toBe(100);
|
|
});
|
|
|
|
it("rejects negative maxSize", { timeout: 5000 }, () => {
|
|
expect(() =>
|
|
MemoryStorageOptionsSchema.parse({ maxSize: -1 })
|
|
).toThrow();
|
|
});
|
|
});
|