New Rules stay off lists until the person who holds the pen turns on a share link, or the team features one. Uploaded files are readable only by those readers, stripped of location metadata, and deleted with the Rule, draft, or account.
238 lines
7.3 KiB
TypeScript
238 lines
7.3 KiB
TypeScript
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
|
|
const isDatabaseConfiguredMock = vi.fn();
|
|
const findUniqueMock = vi.fn();
|
|
const findManyMock = 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),
|
|
},
|
|
},
|
|
}));
|
|
|
|
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,
|
|
} 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();
|
|
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 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,
|
|
}),
|
|
);
|
|
});
|
|
});
|