⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.
TypeScript honoissue-managementissue-trackerjira-alternativekanbanlinear-alternativemcpproject-managementreactself-hostedtypescript
import { randomUUID } from "node:crypto";
import { eq } from "drizzle-orm";
import {
afterAll,
beforeAll,
beforeEach,
describe,
expect,
it,
vi,
} from "vite-plus/test";
const sendTrialReminderEmail = vi.fn();
vi.mock("@kaneo/email", () => ({
isSmtpConfigured: () => true,
sendTrialReminderEmail: (...args: unknown[]) =>
sendTrialReminderEmail(...args),
}));
const { default: db, schema } = await import("../../apps/api/src/database");
const { checkTrialReminders } =
await import("../../apps/api/src/scheduler/trial-reminders");
const { resetTestDatabase } = await import("./helpers/database");
const { createWorkspaceMember } = await import("./helpers/fixtures");
const DAY = 24 * 60 * 60 * 1000;
const CLOUD_ENV = {
KANEO_CLOUD: "true",
CREEM_API_KEY: "creem_test_dummy",
CREEM_WEBHOOK_SECRET: "whsec_dummy",
SMTP_HOST: "smtp.example.com",
SMTP_FROM: "[email protected]",
BILLING_REMINDER_MAX_PER_RUN: "2",
};
const saved: Record<string, string | undefined> = {};
beforeAll(() => {
for (const [key, value] of Object.entries(CLOUD_ENV)) {
saved[key] = process.env[key];
process.env[key] = value;
}
});
afterAll(() => {
for (const key of Object.keys(CLOUD_ENV)) {
if (saved[key] === undefined) delete process.env[key];
else process.env[key] = saved[key];
}
});
async function addWorkspaceOwnedBy(userId: string, trialEndsAt: Date | null) {
const workspaceId = `workspace-${randomUUID()}`;
const [workspace] = await db
.insert(schema.workspaceTable)
.values({
id: workspaceId,
createdAt: new Date(),
name: `Extra-${randomUUID().slice(0, 6)}`,
slug: `workspace-${randomUUID()}`,
})
.returning();
await db.insert(schema.workspaceUserTable).values({
workspaceId: workspace.id,
userId,
role: "owner",
joinedAt: new Date(),
});
await db.insert(schema.workspaceBillingTable).values({
workspaceId: workspace.id,
trialEndsAt,
});
return workspace;
}
async function seedTrial(
trialEndsAt: Date | null,
overrides: Partial<typeof schema.workspaceBillingTable.$inferInsert> = {},
) {
const { user, workspace } = await createWorkspaceMember({
role: "owner",
workspaceName: `WS-${randomUUID().slice(0, 6)}`,
});
await db.insert(schema.workspaceBillingTable).values({
workspaceId: workspace.id,
trialEndsAt,
...overrides,
});
return { user, workspace };
}
function recipients() {
return sendTrialReminderEmail.mock.calls.map((call) => call[0] as string);
}
describe("trial reminder emails", () => {
beforeEach(async () => {
await resetTestDatabase();
sendTrialReminderEmail.mockClear();
});
it("warns the owner before the trial ends", async () => {
const { user } = await seedTrial(new Date(Date.now() + 2.5 * DAY));
await checkTrialReminders();
expect(recipients()).toEqual([user.email]);
const [, subject, data] = sendTrialReminderEmail.mock.calls[0] as [
string,
string,
{ daysLeft: number },
];
expect(subject).toContain("ends in 3 days");
expect(data.daysLeft).toBe(3);
});
it("emails once the trial has lapsed", async () => {
const { user } = await seedTrial(new Date(Date.now() - DAY));
await checkTrialReminders();
expect(recipients()).toEqual([user.email]);
const [, subject, data] = sendTrialReminderEmail.mock.calls[0] as [
string,
string,
{ daysLeft: number },
];
expect(subject).toContain("has ended");
expect(data.daysLeft).toBe(0);
});
it("never sends the same reminder twice", async () => {
await seedTrial(new Date(Date.now() - DAY));
await checkTrialReminders();
await checkTrialReminders();
expect(sendTrialReminderEmail).toHaveBeenCalledTimes(1);
});
it("ignores trials that are neither ending soon nor lapsed", async () => {
await seedTrial(new Date(Date.now() + 9 * DAY));
await checkTrialReminders();
expect(sendTrialReminderEmail).not.toHaveBeenCalled();
});
it("skips founding-free workspaces and paying subscribers", async () => {
await seedTrial(null, { foundingFree: true });
await seedTrial(new Date(Date.now() - DAY), {
creemSubscriptionId: `sub_${randomUUID()}`,
status: "active",
});
await checkTrialReminders();
expect(sendTrialReminderEmail).not.toHaveBeenCalled();
});
it("records what it sent so a later run can be audited", async () => {
const { workspace } = await seedTrial(new Date(Date.now() - DAY));
await checkTrialReminders();
const rows = await db
.select()
.from(schema.billingReminderSentTable)
.where(eq(schema.billingReminderSentTable.workspaceId, workspace.id));
expect(rows).toHaveLength(1);
expect(rows[0]?.reminderType).toBe("trial_expired");
});
it("caps how many it sends per run so the provider is not flooded", async () => {
for (let i = 0; i < 5; i++) {
await seedTrial(new Date(Date.now() - (i + 1) * DAY));
}
await checkTrialReminders();
expect(sendTrialReminderEmail).toHaveBeenCalledTimes(2);
});
it("shares one cap across both reminder types and leaves unsent rows for the next run", async () => {
for (let i = 0; i < 2; i++) {
await seedTrial(new Date(Date.now() + 2.5 * DAY));
await seedTrial(new Date(Date.now() - DAY));
}
await checkTrialReminders();
expect(sendTrialReminderEmail).toHaveBeenCalledTimes(2);
expect(
await db.select().from(schema.billingReminderSentTable),
).toHaveLength(2);
await checkTrialReminders();
expect(sendTrialReminderEmail).toHaveBeenCalledTimes(4);
expect(new Set(recipients()).size).toBe(4);
expect(
await db.select().from(schema.billingReminderSentTable),
).toHaveLength(4);
});
it("spends only the remaining budget on the second reminder type", async () => {
const ending = await seedTrial(new Date(Date.now() + 2.5 * DAY));
for (let i = 0; i < 3; i++) await seedTrial(new Date(Date.now() - DAY));
await checkTrialReminders();
expect(sendTrialReminderEmail).toHaveBeenCalledTimes(2);
expect(recipients()).toContain(ending.user.email);
const rows = await db.select().from(schema.billingReminderSentTable);
expect(rows.map((row) => row.reminderType).sort()).toEqual([
"trial_ending",
"trial_expired",
]);
});
it("sends the most urgent trials first", async () => {
const soonest = await seedTrial(new Date(Date.now() - 9 * DAY));
await seedTrial(new Date(Date.now() - 2 * DAY));
await seedTrial(new Date(Date.now() - 1 * DAY));
await checkTrialReminders();
expect(recipients()[0]).toBe(soonest.user.email);
});
it("emails an owner once no matter how many workspaces they have", async () => {
const lapsed = new Date(Date.now() - DAY);
const { user } = await seedTrial(lapsed);
for (let i = 0; i < 19; i++) {
await addWorkspaceOwnedBy(user.id, lapsed);
}
await checkTrialReminders();
expect(sendTrialReminderEmail).toHaveBeenCalledTimes(1);
expect(recipients()).toEqual([user.email]);
});
it("still emails every distinct owner", async () => {
const lapsed = new Date(Date.now() - DAY);
const a = await seedTrial(lapsed);
const b = await seedTrial(lapsed);
await checkTrialReminders();
expect(recipients().sort()).toEqual([a.user.email, b.user.email].sort());
});
});