Files
outline/server/models/DocumentInsight.test.ts
Tom MoorandClaude Opus 4.8 edd2395214 fix: Deflake DocumentInsight rollupPeriod no-activity test (#13022)
The test asserted the global rollupPeriod return value was 0 while passing
the full UUID range, so activity from other tests sharing the database
(especially near the UTC midnight boundary) leaked into the window. Scope
the partition to the test's own document id to make the count deterministic.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-16 20:17:24 -04:00

322 lines
9.4 KiB
TypeScript

import { format, startOfISOWeek, subDays } from "date-fns";
import DocumentInsight, {
DocumentInsightPeriod,
} from "@server/models/DocumentInsight";
import { Comment, Event, Revision } from "@server/models";
import { buildDocument, buildTeam, buildUser } from "@server/test/factories";
const FULL_UUID_RANGE: [string, string] = [
"00000000-0000-4000-8000-000000000000",
"ffffffff-ffff-4fff-bfff-ffffffffffff",
];
const dayStr = (d: Date) => format(d, "yyyy-MM-dd");
describe("DocumentInsight.rollupPeriod", () => {
it("writes nothing when no source activity exists in the window", async () => {
const team = await buildTeam();
const document = await buildDocument({ teamId: team.id });
// Scope the partition to just this document so the global rollup count
// isn't affected by activity from other tests sharing the database.
const upserted = await DocumentInsight.rollupPeriod({
periodStart: dayStr(subDays(new Date(), 1)),
intervalDays: 1,
period: DocumentInsightPeriod.Day,
startUuid: document.id,
endUuid: document.id,
});
expect(upserted).toBe(0);
expect(await DocumentInsight.count({ where: { teamId: team.id } })).toBe(0);
});
it("respects the window boundaries and excludes events outside it", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const document = await buildDocument({
teamId: team.id,
publishedAt: new Date(),
});
const target = subDays(new Date(), 10);
const before = subDays(target, 1);
const after = subDays(target, -1);
await Event.create({
name: "views.create",
teamId: team.id,
userId: user.id,
documentId: document.id,
createdAt: before,
});
await Event.create({
name: "views.create",
teamId: team.id,
userId: user.id,
documentId: document.id,
createdAt: target,
});
await Event.create({
name: "views.create",
teamId: team.id,
userId: user.id,
documentId: document.id,
createdAt: after,
});
await DocumentInsight.rollupPeriod({
periodStart: dayStr(target),
intervalDays: 1,
period: DocumentInsightPeriod.Day,
startUuid: FULL_UUID_RANGE[0],
endUuid: FULL_UUID_RANGE[1],
});
const row = await DocumentInsight.findOne({
where: { documentId: document.id, date: dayStr(target) },
});
expect(row).toBeTruthy();
expect(row!.period).toBe(DocumentInsightPeriod.Day);
expect(row!.viewCount).toBe(1);
});
it("aggregates a 7-day window into a single weekly row", async () => {
const team = await buildTeam();
const userA = await buildUser({ teamId: team.id });
const userB = await buildUser({ teamId: team.id });
const document = await buildDocument({
teamId: team.id,
publishedAt: new Date(),
});
const weekStart = startOfISOWeek(subDays(new Date(), 60));
// Views across multiple days of the same week; userA on two days, userB on one.
await Event.create({
name: "views.create",
teamId: team.id,
userId: userA.id,
documentId: document.id,
createdAt: subDays(weekStart, -1), // Tuesday
});
await Event.create({
name: "views.create",
teamId: team.id,
userId: userA.id,
documentId: document.id,
createdAt: subDays(weekStart, -3), // Thursday
});
await Event.create({
name: "views.create",
teamId: team.id,
userId: userB.id,
documentId: document.id,
createdAt: subDays(weekStart, -5), // Saturday
});
// Revision within the week by userB.
await Revision.create({
documentId: document.id,
userId: userB.id,
title: document.title,
text: "x",
createdAt: subDays(weekStart, -2),
});
await DocumentInsight.rollupPeriod({
periodStart: dayStr(weekStart),
intervalDays: 7,
period: DocumentInsightPeriod.Week,
startUuid: FULL_UUID_RANGE[0],
endUuid: FULL_UUID_RANGE[1],
});
const rows = await DocumentInsight.findAll({
where: { documentId: document.id },
});
expect(rows).toHaveLength(1);
expect(rows[0].period).toBe(DocumentInsightPeriod.Week);
expect(rows[0].date).toBe(dayStr(weekStart));
expect(rows[0].viewCount).toBe(3);
// Two distinct viewers across the week, not double-counted by day.
expect(rows[0].viewerCount).toBe(2);
expect(rows[0].revisionCount).toBe(1);
expect(rows[0].editorCount).toBe(1);
});
it("counts reactions on older comments when the reaction is in-window", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const document = await buildDocument({
teamId: team.id,
publishedAt: new Date(),
});
const target = subDays(new Date(), 2);
const olderComment = await Comment.create({
documentId: document.id,
createdById: user.id,
data: { type: "doc", content: [] },
createdAt: subDays(target, 30),
});
const { Reaction } = await import("@server/models");
await Reaction.create(
{
emoji: "🎉",
commentId: olderComment.id,
userId: user.id,
createdAt: target,
},
{ hooks: false }
);
await DocumentInsight.rollupPeriod({
periodStart: dayStr(target),
intervalDays: 1,
period: DocumentInsightPeriod.Day,
startUuid: FULL_UUID_RANGE[0],
endUuid: FULL_UUID_RANGE[1],
});
const row = await DocumentInsight.findOne({
where: { documentId: document.id, date: dayStr(target) },
});
expect(row).toBeTruthy();
expect(row!.commentCount).toBe(0);
expect(row!.reactionCount).toBe(1);
});
it("skips documents outside the partition UUID range", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const document = await buildDocument({
teamId: team.id,
publishedAt: new Date(),
});
const target = subDays(new Date(), 1);
await Event.create({
name: "views.create",
teamId: team.id,
userId: user.id,
documentId: document.id,
createdAt: target,
});
// An empty range that excludes all documents.
const [bogusStart, bogusEnd] = [
"ffffffff-ffff-4fff-bfff-fffffffffffe",
"ffffffff-ffff-4fff-bfff-ffffffffffff",
];
// Only hits if the test document's UUID happens to fall in the range; in
// practice buildDocument generates a random v4 that won't. Assert that
// the rollup writes nothing for this document.
const upserted = await DocumentInsight.rollupPeriod({
periodStart: dayStr(target),
intervalDays: 1,
period: DocumentInsightPeriod.Day,
startUuid: bogusStart,
endUuid: bogusEnd,
});
expect(upserted).toBe(0);
expect(
await DocumentInsight.count({ where: { documentId: document.id } })
).toBe(0);
});
it("upserts on (documentId, date, period) and updates counts on re-run", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const document = await buildDocument({
teamId: team.id,
publishedAt: new Date(),
});
const target = subDays(new Date(), 1);
await Event.create({
name: "views.create",
teamId: team.id,
userId: user.id,
documentId: document.id,
createdAt: target,
});
await DocumentInsight.rollupPeriod({
periodStart: dayStr(target),
intervalDays: 1,
period: DocumentInsightPeriod.Day,
startUuid: FULL_UUID_RANGE[0],
endUuid: FULL_UUID_RANGE[1],
});
// Add another event and re-run.
await Event.create({
name: "views.create",
teamId: team.id,
userId: user.id,
documentId: document.id,
createdAt: target,
});
await DocumentInsight.rollupPeriod({
periodStart: dayStr(target),
intervalDays: 1,
period: DocumentInsightPeriod.Day,
startUuid: FULL_UUID_RANGE[0],
endUuid: FULL_UUID_RANGE[1],
});
const rows = await DocumentInsight.findAll({
where: { documentId: document.id },
});
expect(rows).toHaveLength(1);
expect(rows[0].viewCount).toBe(2);
});
it("stores daily and weekly rows for the same start date side-by-side", async () => {
const team = await buildTeam();
const user = await buildUser({ teamId: team.id });
const document = await buildDocument({
teamId: team.id,
publishedAt: new Date(),
});
const weekStart = startOfISOWeek(subDays(new Date(), 60));
await Event.create({
name: "views.create",
teamId: team.id,
userId: user.id,
documentId: document.id,
createdAt: weekStart,
});
await DocumentInsight.rollupPeriod({
periodStart: dayStr(weekStart),
intervalDays: 1,
period: DocumentInsightPeriod.Day,
startUuid: FULL_UUID_RANGE[0],
endUuid: FULL_UUID_RANGE[1],
});
await DocumentInsight.rollupPeriod({
periodStart: dayStr(weekStart),
intervalDays: 7,
period: DocumentInsightPeriod.Week,
startUuid: FULL_UUID_RANGE[0],
endUuid: FULL_UUID_RANGE[1],
});
const rows = await DocumentInsight.findAll({
where: { documentId: document.id },
order: [["period", "ASC"]],
});
expect(rows).toHaveLength(2);
expect(rows.map((r) => r.period).sort()).toEqual([
DocumentInsightPeriod.Day,
DocumentInsightPeriod.Week,
]);
});
});