add tests

This commit is contained in:
Alex Holliday committed 2026-08-20 14:38:18 -07:00
1 parent 637bb5cca9
commit cd520dacc5
3 files changed
+374

No files matched your search

@@ -470,3 +470,72 @@ describe("monitorValidation — customUpCodes", () => {
});
});
});
describe("monitorValidation — proxy fields", () => {
const baseHttpBody = {
name: "HTTP check",
type: "http" as const,
url: "https://example.com",
};
describe("createMonitorBodyValidation", () => {
it("defaults proxyMode to inherit", () => {
const parsed = createMonitorBodyValidation.parse(baseHttpBody);
expect(parsed.proxyMode).toBe("inherit");
expect(parsed.proxyId).toBeUndefined();
});
it("accepts custom mode with a proxyId", () => {
const parsed = createMonitorBodyValidation.parse({ ...baseHttpBody, proxyMode: "custom", proxyId: "proxy-1" });
expect(parsed.proxyMode).toBe("custom");
expect(parsed.proxyId).toBe("proxy-1");
});
it("rejects custom mode without a proxyId", () => {
expect(() => createMonitorBodyValidation.parse({ ...baseHttpBody, proxyMode: "custom" })).toThrow();
});
it("rejects an unknown proxyMode", () => {
expect(() => createMonitorBodyValidation.parse({ ...baseHttpBody, proxyMode: "global" })).toThrow();
});
it("allows a stray proxyId on non-custom modes", () => {
for (const proxyMode of ["inherit", "none"] as const) {
const parsed = createMonitorBodyValidation.parse({ ...baseHttpBody, proxyMode, proxyId: "proxy-1" });
expect(parsed.proxyMode).toBe(proxyMode);
}
});
});
describe("editMonitorBodyValidation", () => {
it("leaves proxyMode unset when omitted (no default injected on PATCH)", () => {
const parsed = editMonitorBodyValidation.parse({ name: "Renamed" });
expect(parsed.proxyMode).toBeUndefined();
});
it("rejects custom mode without a proxyId", () => {
expect(() => editMonitorBodyValidation.parse({ proxyMode: "custom" })).toThrow();
});
it("accepts custom mode with a proxyId", () => {
const parsed = editMonitorBodyValidation.parse({ proxyMode: "custom", proxyId: "proxy-1" });
expect(parsed.proxyId).toBe("proxy-1");
});
});
describe("importMonitorsBodyValidation", () => {
it("defaults proxyMode to inherit on import", () => {
const parsed = importMonitorsBodyValidation.parse({ monitors: [baseHttpBody] });
expect(parsed.monitors[0].proxyMode).toBe("inherit");
});
it("rejects an imported monitor with custom mode and no proxyId", () => {
expect(() => importMonitorsBodyValidation.parse({ monitors: [{ ...baseHttpBody, proxyMode: "custom" }] })).toThrow();
});
});
});
@@ -0,0 +1,97 @@
import { describe, expect, it } from "@jest/globals";
import { createProxyBodyValidation, editProxyBodyValidation, proxyResponseSchema } from "../../../src/api/validation/proxyValidation.ts";
const validBody = {
name: "Egress proxy",
protocol: "http" as const,
host: "proxy.internal",
port: 3128,
};
describe("proxyValidation", () => {
describe("createProxyBodyValidation", () => {
it("accepts a minimal valid body", () => {
const parsed = createProxyBodyValidation.parse(validBody);
expect(parsed).toEqual(validBody);
});
it("accepts optional credentials", () => {
const parsed = createProxyBodyValidation.parse({ ...validBody, username: "user", password: "secret" });
expect(parsed.username).toBe("user");
expect(parsed.password).toBe("secret");
});
it("rejects an empty name", () => {
expect(() => createProxyBodyValidation.parse({ ...validBody, name: "" })).toThrow();
});
it("rejects an empty host", () => {
expect(() => createProxyBodyValidation.parse({ ...validBody, host: "" })).toThrow();
});
it("rejects a protocol outside the tuple", () => {
expect(() => createProxyBodyValidation.parse({ ...validBody, protocol: "socks5" })).toThrow();
});
it("accepts the port boundaries", () => {
expect(createProxyBodyValidation.parse({ ...validBody, port: 1 }).port).toBe(1);
expect(createProxyBodyValidation.parse({ ...validBody, port: 65535 }).port).toBe(65535);
});
it("rejects out-of-range and non-integer ports", () => {
for (const port of [0, -1, 65536, 3128.5, "3128"]) {
expect(() => createProxyBodyValidation.parse({ ...validBody, port })).toThrow();
}
});
});
describe("editProxyBodyValidation", () => {
it("accepts the create shape without clear flags", () => {
const parsed = editProxyBodyValidation.parse(validBody);
expect(parsed.clearPassword).toBeUndefined();
expect(parsed.clearUsername).toBeUndefined();
});
it("accepts clearPassword and clearUsername", () => {
const parsed = editProxyBodyValidation.parse({ ...validBody, clearPassword: true, clearUsername: true });
expect(parsed.clearPassword).toBe(true);
expect(parsed.clearUsername).toBe(true);
});
it("rejects non-boolean clear flags", () => {
expect(() => editProxyBodyValidation.parse({ ...validBody, clearPassword: "yes" })).toThrow();
});
});
describe("proxyResponseSchema", () => {
const validResponse = {
id: "proxy-1",
teamId: "team-1",
name: "Egress proxy",
protocol: "http",
host: "proxy.internal",
port: 3128,
hasPassword: false,
createdAt: "2026-01-01T00:00:00Z",
updatedAt: "2026-01-01T00:00:00Z",
};
it("accepts a masked proxy", () => {
expect(() => proxyResponseSchema.parse(validResponse)).not.toThrow();
});
it("requires hasPassword", () => {
const { hasPassword: _hasPassword, ...withoutFlag } = validResponse;
expect(() => proxyResponseSchema.parse(withoutFlag)).toThrow();
});
it("does not declare a password field", () => {
expect(Object.keys(proxyResponseSchema.shape)).not.toContain("password");
});
});
});