322 lines
10 KiB
TypeScript
322 lines
10 KiB
TypeScript
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
|
|
const isDatabaseConfiguredMock = vi.fn();
|
|
const findUniqueMock = vi.fn();
|
|
const findManyMock = vi.fn();
|
|
const stakeholderFindManyMock = vi.fn();
|
|
const browserHoldsClaimForHashMock = vi.fn();
|
|
const isRuleAdminEmailMock = vi.fn();
|
|
const logAdminRuleReadMock = vi.fn();
|
|
|
|
vi.mock("../../lib/server/env", () => ({
|
|
isDatabaseConfigured: () => isDatabaseConfiguredMock(),
|
|
}));
|
|
|
|
vi.mock("../../lib/server/db", () => ({
|
|
prisma: {
|
|
publishedRule: {
|
|
findUnique: (...args: unknown[]) => findUniqueMock(...args),
|
|
findMany: (...args: unknown[]) => findManyMock(...args),
|
|
},
|
|
ruleStakeholder: {
|
|
findMany: (...args: unknown[]) => stakeholderFindManyMock(...args),
|
|
},
|
|
},
|
|
}));
|
|
|
|
vi.mock("../../lib/server/guestRuleClaim", () => ({
|
|
browserHoldsClaimForHash: (...args: unknown[]) =>
|
|
browserHoldsClaimForHashMock(...args),
|
|
}));
|
|
|
|
vi.mock("../../lib/server/ruleAdmins", () => ({
|
|
isRuleAdminEmail: (...args: unknown[]) => isRuleAdminEmailMock(...args),
|
|
}));
|
|
|
|
vi.mock("../../lib/server/adminRuleReadLog", () => ({
|
|
logAdminRuleRead: (...args: unknown[]) => logAdminRuleReadMock(...args),
|
|
}));
|
|
|
|
import {
|
|
getReadablePublishedRule,
|
|
listListedPublishedRules,
|
|
listListedPublishedRulesForSitemap,
|
|
listProfileRulesForUser,
|
|
} from "../../lib/server/publishedRules";
|
|
import { LISTED_PUBLISHED_RULE_WHERE } from "../../lib/publishedRuleAccess";
|
|
import { RULE_VISIBILITY } from "../../lib/ruleVisibility";
|
|
|
|
function row(overrides: Record<string, unknown> = {}) {
|
|
return {
|
|
id: "owned-1",
|
|
title: "Owned",
|
|
summary: "Hi",
|
|
document: {},
|
|
createdAt: new Date("2026-01-01T00:00:00.000Z"),
|
|
updatedAt: new Date("2026-01-02T00:00:00.000Z"),
|
|
userId: "user-1",
|
|
claimTokenHash: null,
|
|
visibility: RULE_VISIBILITY.private,
|
|
shareSlug: null,
|
|
stakeholders: [],
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
beforeEach(() => {
|
|
isDatabaseConfiguredMock.mockReset();
|
|
findUniqueMock.mockReset();
|
|
findManyMock.mockReset();
|
|
stakeholderFindManyMock.mockReset();
|
|
browserHoldsClaimForHashMock.mockReset();
|
|
isRuleAdminEmailMock.mockReset();
|
|
logAdminRuleReadMock.mockReset();
|
|
browserHoldsClaimForHashMock.mockResolvedValue(false);
|
|
isRuleAdminEmailMock.mockReturnValue(false);
|
|
logAdminRuleReadMock.mockResolvedValue(undefined);
|
|
});
|
|
|
|
describe("getReadablePublishedRule", () => {
|
|
it("returns listed public-and-featured Rules to anonymous readers", async () => {
|
|
isDatabaseConfiguredMock.mockReturnValue(true);
|
|
findUniqueMock.mockResolvedValueOnce(
|
|
row({ visibility: RULE_VISIBILITY.public_and_featured }),
|
|
);
|
|
|
|
const resolved = await getReadablePublishedRule({
|
|
idOrSlug: "owned-1",
|
|
user: null,
|
|
viaShareSlug: false,
|
|
requestPath: "/rules/owned-1",
|
|
});
|
|
expect(resolved?.rule).toMatchObject({
|
|
id: "owned-1",
|
|
title: "Owned",
|
|
isListed: true,
|
|
});
|
|
expect(resolved?.rule).not.toHaveProperty("userId");
|
|
expect(resolved?.rule).not.toHaveProperty("claimTokenHash");
|
|
});
|
|
|
|
it("hides private Rules from anonymous readers", async () => {
|
|
isDatabaseConfiguredMock.mockReturnValue(true);
|
|
findUniqueMock.mockResolvedValueOnce(row());
|
|
expect(
|
|
await getReadablePublishedRule({
|
|
idOrSlug: "owned-1",
|
|
user: null,
|
|
viaShareSlug: false,
|
|
requestPath: "/rules/owned-1",
|
|
}),
|
|
).toBeNull();
|
|
});
|
|
|
|
it("lets the publishing browser read a private Rule with the guest claim", async () => {
|
|
isDatabaseConfiguredMock.mockReturnValue(true);
|
|
browserHoldsClaimForHashMock.mockResolvedValue(true);
|
|
findUniqueMock.mockResolvedValueOnce(
|
|
row({ userId: null, claimTokenHash: "claim-hash" }),
|
|
);
|
|
const resolved = await getReadablePublishedRule({
|
|
idOrSlug: "owned-1",
|
|
user: null,
|
|
viaShareSlug: false,
|
|
requestPath: "/rules/owned-1",
|
|
});
|
|
expect(resolved?.rule.id).toBe("owned-1");
|
|
expect(browserHoldsClaimForHashMock).toHaveBeenCalledWith("claim-hash");
|
|
});
|
|
|
|
it("lets the owner read a private Rule by id", async () => {
|
|
isDatabaseConfiguredMock.mockReturnValue(true);
|
|
findUniqueMock.mockResolvedValueOnce(row());
|
|
const resolved = await getReadablePublishedRule({
|
|
idOrSlug: "owned-1",
|
|
user: { id: "user-1", email: "owner@example.org" } as never,
|
|
viaShareSlug: false,
|
|
requestPath: "/rules/owned-1",
|
|
});
|
|
expect(resolved?.rule.id).toBe("owned-1");
|
|
expect(resolved?.viewerIsOwner).toBe(true);
|
|
expect(resolved?.rule.isListed).toBe(false);
|
|
});
|
|
|
|
it("does not treat a shared-by-link Rule as public at /rules/{id}", async () => {
|
|
isDatabaseConfiguredMock.mockReturnValue(true);
|
|
findUniqueMock.mockResolvedValueOnce(
|
|
row({
|
|
visibility: RULE_VISIBILITY.shared_by_link,
|
|
shareSlug: "k7f2-9qxm",
|
|
}),
|
|
);
|
|
expect(
|
|
await getReadablePublishedRule({
|
|
idOrSlug: "owned-1",
|
|
user: null,
|
|
viaShareSlug: false,
|
|
requestPath: "/rules/owned-1",
|
|
}),
|
|
).toBeNull();
|
|
});
|
|
|
|
it("lets anonymous readers of a shared Rule through when the caller already has the id", async () => {
|
|
isDatabaseConfiguredMock.mockReturnValue(true);
|
|
findUniqueMock.mockResolvedValueOnce(
|
|
row({
|
|
visibility: RULE_VISIBILITY.shared_by_link,
|
|
shareSlug: "k7f2-9qxm",
|
|
}),
|
|
);
|
|
const resolved = await getReadablePublishedRule({
|
|
idOrSlug: "owned-1",
|
|
user: null,
|
|
viaShareSlug: true,
|
|
lookup: "id",
|
|
requestPath: "/api/uploads/file-1",
|
|
});
|
|
expect(resolved?.rule.id).toBe("owned-1");
|
|
expect(findUniqueMock).toHaveBeenCalledWith(
|
|
expect.objectContaining({ where: { id: "owned-1" } }),
|
|
);
|
|
});
|
|
|
|
it("lets anonymous readers use the rotating slug", async () => {
|
|
isDatabaseConfiguredMock.mockReturnValue(true);
|
|
findUniqueMock.mockResolvedValueOnce(
|
|
row({
|
|
visibility: RULE_VISIBILITY.shared_by_link,
|
|
shareSlug: "k7f2-9qxm",
|
|
}),
|
|
);
|
|
const resolved = await getReadablePublishedRule({
|
|
idOrSlug: "k7f2-9qxm",
|
|
user: null,
|
|
viaShareSlug: true,
|
|
requestPath: "/r/k7f2-9qxm",
|
|
});
|
|
expect(resolved?.rule.id).toBe("owned-1");
|
|
expect(resolved?.rule.isListed).toBe(false);
|
|
expect(findUniqueMock).toHaveBeenCalledWith(
|
|
expect.objectContaining({ where: { shareSlug: "k7f2-9qxm" } }),
|
|
);
|
|
});
|
|
|
|
it("logs named-admin reads of private Rules", async () => {
|
|
isDatabaseConfiguredMock.mockReturnValue(true);
|
|
isRuleAdminEmailMock.mockReturnValue(true);
|
|
findUniqueMock.mockResolvedValueOnce(row());
|
|
const resolved = await getReadablePublishedRule({
|
|
idOrSlug: "owned-1",
|
|
user: { id: "admin-1", email: "admin@example.org" } as never,
|
|
viaShareSlug: false,
|
|
requestPath: "/rules/owned-1",
|
|
});
|
|
expect(resolved?.viewerIsOwner).toBe(false);
|
|
expect(logAdminRuleReadMock).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
ruleId: "owned-1",
|
|
adminEmail: "admin@example.org",
|
|
path: "/rules/owned-1",
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("listListedPublishedRules", () => {
|
|
it("queries the listed-rule where clause", async () => {
|
|
isDatabaseConfiguredMock.mockReturnValue(true);
|
|
findManyMock.mockResolvedValueOnce([]);
|
|
|
|
await listListedPublishedRules(10);
|
|
|
|
expect(findManyMock).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: LISTED_PUBLISHED_RULE_WHERE,
|
|
take: 10,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("returns null when the database is not configured", async () => {
|
|
isDatabaseConfiguredMock.mockReturnValue(false);
|
|
expect(await listListedPublishedRules(10)).toBeNull();
|
|
expect(findManyMock).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe("listListedPublishedRulesForSitemap", () => {
|
|
it("returns an empty list when the database is not configured", async () => {
|
|
isDatabaseConfiguredMock.mockReturnValue(false);
|
|
expect(await listListedPublishedRulesForSitemap()).toEqual([]);
|
|
expect(findManyMock).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("queries only public and featured Rules", async () => {
|
|
isDatabaseConfiguredMock.mockReturnValue(true);
|
|
findManyMock.mockResolvedValueOnce([]);
|
|
await listListedPublishedRulesForSitemap();
|
|
expect(findManyMock).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: LISTED_PUBLISHED_RULE_WHERE,
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("listProfileRulesForUser", () => {
|
|
it("returns null when the database is not configured", async () => {
|
|
isDatabaseConfiguredMock.mockReturnValue(false);
|
|
expect(await listProfileRulesForUser("user-1", 50)).toBeNull();
|
|
expect(findManyMock).not.toHaveBeenCalled();
|
|
expect(stakeholderFindManyMock).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("keeps owned Rules as owner and invited Rules as stakeholder, newest first", async () => {
|
|
isDatabaseConfiguredMock.mockReturnValue(true);
|
|
const owned = {
|
|
id: "owned-1",
|
|
title: "Garden coop",
|
|
summary: "Plots",
|
|
createdAt: new Date("2026-10-01T00:00:00.000Z"),
|
|
updatedAt: new Date("2026-11-01T00:00:00.000Z"),
|
|
};
|
|
const invited = {
|
|
id: "invited-1",
|
|
title: "Hawthorn Row",
|
|
summary: "Seeds",
|
|
createdAt: new Date("2026-09-01T00:00:00.000Z"),
|
|
updatedAt: new Date("2026-11-02T00:00:00.000Z"),
|
|
};
|
|
findManyMock.mockResolvedValueOnce([owned]);
|
|
stakeholderFindManyMock.mockResolvedValueOnce([{ rule: invited }]);
|
|
|
|
const listed = await listProfileRulesForUser("user-1", 50);
|
|
|
|
expect(stakeholderFindManyMock).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
where: { userId: "user-1" },
|
|
}),
|
|
);
|
|
expect(listed).toEqual([
|
|
{ ...invited, role: "stakeholder" },
|
|
{ ...owned, role: "owner" },
|
|
]);
|
|
});
|
|
|
|
it("does not list an invited Rule the person also holds the pen for as stakeholder", async () => {
|
|
isDatabaseConfiguredMock.mockReturnValue(true);
|
|
const owned = {
|
|
id: "same-1",
|
|
title: "Garden coop",
|
|
summary: "Plots",
|
|
createdAt: new Date("2026-10-01T00:00:00.000Z"),
|
|
updatedAt: new Date("2026-11-01T00:00:00.000Z"),
|
|
};
|
|
findManyMock.mockResolvedValueOnce([owned]);
|
|
stakeholderFindManyMock.mockResolvedValueOnce([{ rule: owned }]);
|
|
|
|
const listed = await listProfileRulesForUser("user-1", 50);
|
|
expect(listed).toEqual([{ ...owned, role: "owner" }]);
|
|
});
|
|
});
|