@terreno/api 0.21.0 → 0.22.1

package/src/permissions.test.ts

@@ -13,7 +13,7 @@ import {
   FoodModel,
   getBaseServer,
   RequiredModel,
-  setupDb,
+  setupTestData,
   UserModel,
 } from "./tests";
 
@@ -24,22 +24,7 @@ describe("permissions", () => {
   beforeEach(async () => {
     process.env.REFRESH_TOKEN_SECRET = "testsecret1234";
 
-    const [admin, notAdmin] = await setupDb();
-
-    await Promise.all([
-      FoodModel.create({
-        calories: 1,
-        created: new Date(),
-        name: "Spinach",
-        ownerId: notAdmin._id,
-      }),
-      FoodModel.create({
-        calories: 100,
-        created: Date.now() - 10,
-        name: "Apple",
-        ownerId: admin._id,
-      }),
-    ]);
+    await setupTestData();
     app = getBaseServer();
     setupAuth(app, UserModel as any);
     addAuthRoutes(app, UserModel as any);
@@ -74,12 +59,12 @@ describe("permissions", () => {
   describe("anonymous food", () => {
     it("list", async () => {
       const res = await server.get("/food").expect(200);
-      expect(res.body.data).toHaveLength(2);
+      expect(res.body.data).toHaveLength(4);
     });
 
     it("get", async () => {
       const res = await server.get("/food").expect(200);
-      expect(res.body.data).toHaveLength(2);
+      expect(res.body.data).toHaveLength(4);
       const res2 = await server.get(`/food/${res.body.data[0]._id}`).expect(200);
       expect(res.body.data[0]._id).toBe(res2.body.data._id);
     });
@@ -116,12 +101,12 @@ describe("permissions", () => {
 
     it("list", async () => {
       const res = await agent.get("/food").expect(200);
-      expect(res.body.data).toHaveLength(2);
+      expect(res.body.data).toHaveLength(4);
     });
 
     it("get", async () => {
       const res = await agent.get("/food").expect(200);
-      expect(res.body.data).toHaveLength(2);
+      expect(res.body.data).toHaveLength(4);
       const res2 = await server.get(`/food/${res.body.data[0]._id}`).expect(200);
       expect(res.body.data[0]._id).toBe(res2.body.data._id);
     });
@@ -175,12 +160,12 @@ describe("permissions", () => {
 
     it("list", async () => {
       const res = await agent.get("/food");
-      expect(res.body.data).toHaveLength(2);
+      expect(res.body.data).toHaveLength(4);
     });
 
     it("get", async () => {
       const res = await agent.get("/food");
-      expect(res.body.data).toHaveLength(2);
+      expect(res.body.data).toHaveLength(4);
       const res2 = await agent.get(`/food/${res.body.data[0]._id}`);
       expect(res.body.data[0]._id).toBe(res2.body.data._id);
     });

package/src/populate.test.ts

@@ -3,7 +3,7 @@ import {beforeEach, describe, expect, it} from "bun:test";
 import mongoose, {type Document, type HydratedDocument, Schema} from "mongoose";
 
 import {fixMixedFields, getOpenApiSpecForModel, unpopulate} from "./populate";
-import {FoodModel, setupDb, type User, UserModel} from "./tests";
+import {FoodModel, setupTestData, type User, UserModel} from "./tests";
 
 describe("populate functions", () => {
   let admin: HydratedDocument<User>;
@@ -13,32 +13,17 @@ describe("populate functions", () => {
   let spinach: any;
 
   beforeEach(async () => {
-    [admin, notAdmin] = await setupDb();
-
-    [spinach] = await Promise.all([
-      FoodModel.create({
-        calories: 1,
-        created: new Date("2021-12-03T00:00:20.000Z"),
-        eatenBy: [admin._id],
-        hidden: false,
-        likesIds: [
-          {likes: true, userId: admin._id},
-          {likes: false, userId: notAdmin._id},
-        ],
-        name: "Spinach",
-        ownerId: admin._id,
-        source: {
-          name: "Brand",
-        },
-      }),
-    ]);
+    const testData = await setupTestData();
+    admin = testData.users.admin;
+    notAdmin = testData.users.notAdmin;
+    spinach = testData.foods.spinach;
   });
 
   it("unpopulate", async () => {
     let populated = await spinach.populate("ownerId");
     populated = await populated.populate("eatenBy");
     populated = await populated.populate("likesIds.userId");
-    expect(populated.ownerId.name).toBe("Admin");
+    expect(populated.ownerId.name).toBe("Not Admin");
     expect(populated.eatenBy[0].id).toBe(admin.id);
     expect(populated.eatenBy[0].name).toBe("Admin");
     expect(populated.likesIds[0].userId.id).toBe(admin.id);
@@ -49,7 +34,7 @@ describe("populate functions", () => {
     // noExplicitAny: unpopulate returns Document<T> which doesn't expose model properties; would require refactoring the return type
     let unpopulated: any = unpopulate(populated, "ownerId");
     expect(spinach.ownerId.name).toBeUndefined();
-    expect(unpopulated.ownerId.toString()).toBe(admin.id);
+    expect(unpopulated.ownerId.toString()).toBe(notAdmin.id);
     // Ensure nothing else was touched.
     expect(populated.likesIds[0].userId.id).toBe(admin.id);
     expect(populated.likesIds[0].userId.name).toBe("Admin");

package/src/syncConsents.test.ts

@@ -2,7 +2,7 @@ import {afterEach, beforeEach, describe, expect, it} from "bun:test";
 import {ConsentForm} from "./models/consentForm";
 import type {ConsentFormDefinition} from "./syncConsents";
 import {syncConsents} from "./syncConsents";
-import {setupDb} from "./tests";
+import {setupDb} from "./tests/testHelper";
 
 const baseDef: ConsentFormDefinition = {
   content: {en: "# Terms\nPlease agree."},

package/src/tests/bunSetup.ts

@@ -1,254 +1,27 @@
-// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
-import {afterAll, afterEach, beforeAll, beforeEach, mock} from "bun:test";
-import {Writable} from "node:stream";
-import mongoose from "mongoose";
-import winston from "winston";
+import {registerBackendPreload, registerSimpleMongoPreload} from "@terreno/test";
 
-import {setupEnvironment} from "../expressServer";
-import {logger, winstonLogger} from "../logger";
+const useFixtureCache = process.env.TERRENO_TEST_USE_FIXTURE_CACHE === "true";
 
-const shouldConnectToTestDb = process.env.BUN_TEST_DISABLE_DB !== "true";
-
-const defaultLocalMongoUri = "mongodb://127.0.0.1/terreno?&connectTimeoutMS=360000";
-
-/** When set by {@link TERRENO_TEST_USE_MEMORY_MONGO}, holds the server to stop in afterAll. */
-let memoryMongo: {getUri: () => string; stop: () => Promise<boolean>} | undefined;
-
-// Connect to MongoDB once for all tests
-if (shouldConnectToTestDb) {
-  beforeAll(async () => {
-    let uri = process.env.TERRENO_TEST_MONGODB_URI?.trim();
-    if (!uri && process.env.TERRENO_TEST_USE_MEMORY_MONGO === "true") {
-      const {MongoMemoryServer} = await import("mongodb-memory-server");
-      memoryMongo = await MongoMemoryServer.create();
-      uri = memoryMongo.getUri();
-    }
-    const connectUri = uri ?? defaultLocalMongoUri;
-    await mongoose.connect(connectUri).catch(logger.catch);
+if (useFixtureCache) {
+  registerBackendPreload({
+    connectMongoInBeforeAll: true,
+    loadTestDataFromCache: async () => {
+      const {loadTestDataFromCache} = await import("./mongoTestSetup");
+      await loadTestDataFromCache();
+    },
+    mongo: {
+      baseDatabaseName: "terrenoTest_base",
+      useReplSet: true,
+    },
+    testEnv: {
+      tokenIssuer: "terreno-api.test",
+    },
+    useTransactions: true,
   });
-}
-
-// Close MongoDB connection after all tests
-if (shouldConnectToTestDb) {
-  afterAll(async () => {
-    await mongoose.connection.close();
-    if (memoryMongo) {
-      await memoryMongo.stop();
-    }
+} else {
+  registerSimpleMongoPreload({
+    testEnv: {
+      tokenIssuer: "terreno-api.test",
+    },
   });
 }
-
-let logs: string[] = [];
-
-const SHOW_ALL_LOGS = process.env.SHOW_ALL_TEST_LOGS === "true";
-
-// Create a custom stream that captures logs
-const logStream = new Writable({
-  write(chunk: any, _encoding: any, callback: any) {
-    logs.push(chunk.toString());
-    if (SHOW_ALL_LOGS) {
-      process.stdout.write(chunk);
-    }
-    callback();
-  },
-});
-
-// Silence both winston loggers by replacing all transports with our capturing stream
-const silentTransport = new winston.transports.Stream({
-  format: winston.format.simple(),
-  stream: logStream,
-});
-
-// Clear and silence the default winston logger
-winston.clear();
-winston.add(silentTransport);
-
-// Clear and silence the custom winstonLogger
-winstonLogger.clear();
-winstonLogger.add(silentTransport);
-
-// Capture and silence console methods
-const originalConsole = {
-  debug: console.debug,
-  error: console.error,
-  info: console.info,
-  // biome-ignore lint/suspicious/noConsole: We keep the original reference.
-  log: console.log,
-  warn: console.warn,
-};
-
-const captureConsoleMethod = (method: keyof typeof originalConsole): void => {
-  (console as any)[method] = (...args: any[]) => {
-    const logMessage = `[console.${method}] ${args.map((arg) => (typeof arg === "object" ? JSON.stringify(arg) : String(arg))).join(" ")}`;
-    logs.push(logMessage);
-    if (SHOW_ALL_LOGS) {
-      originalConsole[method](...args);
-    }
-  };
-};
-
-captureConsoleMethod("log");
-captureConsoleMethod("info");
-captureConsoleMethod("warn");
-captureConsoleMethod("error");
-captureConsoleMethod("debug");
-
-// Setup before each test
-beforeEach(() => {
-  process.env.TOKEN_SECRET = "secret";
-  process.env.TOKEN_ISSUER = "terreno-api.test";
-  process.env.SESSION_SECRET = "sessionSecret";
-  process.env.REFRESH_TOKEN_SECRET = "refreshTokenSecret";
-  setupEnvironment();
-  // Re-silence loggers after setupEnvironment which may reconfigure them
-  winston.clear();
-  winston.add(silentTransport);
-  winstonLogger.clear();
-  winstonLogger.add(silentTransport);
-  logs = [];
-});
-
-// Clear logs after each test
-afterEach(() => {
-  logs = [];
-});
-
-// Mock @sentry/bun module
-mock.module("@sentry/bun", () => {
-  const mockFn = (): ReturnType<typeof mock> => mock(() => {});
-
-  // Mock Scope
-  const mockScope = {
-    addBreadcrumb: mockFn(),
-    clear: mockFn(),
-    getSpan: mockFn(),
-    setContext: mockFn(),
-    setFingerprint: mockFn(),
-    setLevel: mockFn(),
-    setSpan: mockFn(),
-    setTag: mockFn(),
-    setTags: mockFn(),
-    setTransactionName: mockFn(),
-    setUser: mockFn(),
-  };
-
-  // Mock Hub
-  const mockClient = {
-    captureException: mockFn(),
-    captureMessage: mockFn(),
-    close: mock(() => Promise.resolve(true)),
-    flush: mock(() => Promise.resolve(true)),
-    getOptions: mock(() => ({})),
-  };
-
-  const mockHub = {
-    addBreadcrumb: mockFn(),
-    captureException: mockFn(),
-    captureMessage: mockFn(),
-    configureScope: mockFn(),
-    getClient: mock(() => mockClient),
-    getScope: mock(() => mockScope),
-    popScope: mockFn(),
-    pushScope: mockFn(),
-    setContext: mockFn(),
-    setTag: mockFn(),
-    setTags: mockFn(),
-    setUser: mockFn(),
-    withScope: mockFn(),
-  };
-
-  const mockSpan: any = {
-    finish: mockFn(),
-    setData: mockFn(),
-    setStatus: mockFn(),
-    setTag: mockFn(),
-    startChild: mockFn(),
-    toTraceparent: mock(() => "mock-trace-parent"),
-  };
-  mockSpan.startChild = mock(() => mockSpan);
-
-  const mockTransaction = {
-    finish: mockFn(),
-    setData: mockFn(),
-    setName: mockFn(),
-    setStatus: mockFn(),
-    setTag: mockFn(),
-    startChild: mock(() => mockSpan),
-    toTraceparent: mock(() => "mock-trace-parent"),
-  };
-
-  return {
-    addBreadcrumb: mockFn(),
-    captureException: mockFn(),
-    captureMessage: mockFn(),
-    clearScope: mockFn(),
-    close: mock(() => Promise.resolve(true)),
-    configureScope: mockFn(),
-    default: {
-      addBreadcrumb: mockFn(),
-      captureException: mockFn(),
-      captureMessage: mockFn(),
-      clearScope: mockFn(),
-      close: mock(() => Promise.resolve(true)),
-      configureScope: mockFn(),
-      flush: mock(() => Promise.resolve(true)),
-      getClient: mock(() => mockClient),
-      getCurrentHub: mock(() => mockHub),
-      getCurrentScope: mock(() => mockScope),
-      Handlers: {
-        errorHandler: mock(() => (err: any, _req: any, _res: any, next: any) => next(err)),
-        requestHandler: mock(() => (_req: any, _res: any, next: any) => next()),
-        tracingHandler: mock(() => (_req: any, _res: any, next: any) => next()),
-      },
-      init: mockFn(),
-      isInitialized: mock(() => true),
-      popScope: mockFn(),
-      pushScope: mockFn(),
-      Severity: {
-        Debug: "debug",
-        Error: "error",
-        Fatal: "fatal",
-        Info: "info",
-        Warning: "warning",
-      } as const,
-      setContext: mockFn(),
-      setFingerprint: mockFn(),
-      setLevel: mockFn(),
-      setTag: mockFn(),
-      setTags: mockFn(),
-      setUser: mockFn(),
-      setupExpressErrorHandler: mockFn(),
-      startTransaction: mock(() => mockTransaction),
-      withScope: mock((callback: any) => callback(mockScope)),
-    },
-    flush: mock(() => Promise.resolve(true)),
-    getClient: mock(() => mockClient),
-    getCurrentHub: mock(() => mockHub),
-    getCurrentScope: mock(() => mockScope),
-    Handlers: {
-      errorHandler: mock(() => (err: any, _req: any, _res: any, next: any) => next(err)),
-      requestHandler: mock(() => (_req: any, _res: any, next: any) => next()),
-      tracingHandler: mock(() => (_req: any, _res: any, next: any) => next()),
-    },
-    init: mockFn(),
-    isInitialized: mock(() => true),
-    popScope: mockFn(),
-    pushScope: mockFn(),
-    Severity: {
-      Debug: "debug",
-      Error: "error",
-      Fatal: "fatal",
-      Info: "info",
-      Warning: "warning",
-    } as const,
-    setContext: mockFn(),
-    setFingerprint: mockFn(),
-    setLevel: mockFn(),
-    setTag: mockFn(),
-    setTags: mockFn(),
-    setUser: mockFn(),
-    setupExpressErrorHandler: mockFn(),
-    startTransaction: mock(() => mockTransaction),
-    withScope: mock((callback: any) => callback(mockScope)),
-  };
-});

package/src/tests/createTestData.ts

@@ -0,0 +1,176 @@
+import type {HydratedDocument} from "mongoose";
+import type {PassportLocalMongooseDocument} from "passport-local-mongoose";
+
+import {logger} from "../logger";
+import {FoodModel, RequiredModel, type User, UserModel} from "./models";
+import type {CachedTestData, TestData, TestFoods, TestRequired, TestUsers} from "./types";
+
+const setPassword = async (user: HydratedDocument<User>, password: string): Promise<void> => {
+  await (user as unknown as PassportLocalMongooseDocument).setPassword(password);
+  await user.save();
+};
+
+export const clearTestCollections = async (): Promise<void> => {
+  await Promise.all([
+    UserModel.deleteMany({}),
+    FoodModel.deleteMany({}),
+    RequiredModel.deleteMany({}),
+  ]).catch(logger.catch);
+};
+
+export const createTestUsers = async (): Promise<TestUsers> => {
+  const [notAdmin, admin, adminOther] = await Promise.all([
+    UserModel.create({email: "notAdmin@example.com", name: "Not Admin"}),
+    UserModel.create({admin: true, email: "admin@example.com", name: "Admin"}),
+    UserModel.create({admin: true, email: "admin+other@example.com", name: "Admin Other"}),
+  ]);
+
+  await Promise.all([
+    setPassword(notAdmin, "password"),
+    setPassword(admin, "securePassword"),
+    setPassword(adminOther, "otherPassword"),
+  ]);
+
+  return {admin, adminOther, notAdmin};
+};
+
+export const createStandardFoods = async (users: TestUsers): Promise<TestFoods> => {
+  const {admin, adminOther, notAdmin} = users;
+
+  const [spinach, apple, carrots, pizza] = await Promise.all([
+    FoodModel.create({
+      calories: 1,
+      categories: [{name: "Vegetables", show: true}],
+      created: new Date("2021-12-03T00:00:20.000Z"),
+      eatenBy: [admin._id],
+      expiration: "2026-12-31",
+      hidden: false,
+      lastEatenWith: {
+        dressing: new Date("2021-12-03T19:00:30.000Z"),
+      },
+      likesIds: [
+        {likes: true, userId: admin._id},
+        {likes: false, userId: notAdmin._id},
+      ],
+      name: "Spinach",
+      ownerId: notAdmin._id,
+      source: {
+        dateAdded: "2023-12-13T12:30:00.000Z",
+        href: "https://www.example.com/spinach",
+        name: "Brand",
+      },
+      tags: ["healthy"],
+    }),
+    FoodModel.create({
+      calories: 100,
+      created: new Date("2021-12-03T00:00:30.000Z"),
+      expiration: "2026-12-31",
+      hidden: true,
+      likesIds: [{likes: true, userId: admin._id}],
+      name: "Apple",
+      ownerId: admin._id,
+      source: {name: "Orchard"},
+      tags: ["healthy"],
+    }),
+    FoodModel.create({
+      calories: 100,
+      created: new Date("2021-12-03T00:00:00.000Z"),
+      eatenBy: [admin._id, notAdmin._id],
+      expiration: "2026-12-31",
+      hidden: false,
+      likesIds: [{likes: false, userId: notAdmin._id}],
+      name: "Carrots",
+      ownerId: admin._id,
+      source: {name: "Farm"},
+      tags: ["vegetable"],
+    }),
+    FoodModel.create({
+      calories: 800,
+      created: new Date("2022-01-01T00:00:00.000Z"),
+      expiration: "2026-12-31",
+      hidden: false,
+      likesIds: [{likes: true, userId: adminOther._id}],
+      name: "Pizza",
+      ownerId: adminOther._id,
+      source: {name: "Pizzeria"},
+      tags: ["comfort"],
+    }),
+  ]);
+
+  return {apple, carrots, pizza, spinach};
+};
+
+export const createRequiredFixtures = async (): Promise<TestRequired> => {
+  const [sample, withAbout] = await Promise.all([
+    RequiredModel.create({name: "Sample Required"}),
+    RequiredModel.create({about: "Optional about text", name: "Required With About"}),
+  ]);
+
+  return {sample, withAbout};
+};
+
+/** Builds the standard Terreno API test database (users, foods, required docs). */
+export const createTestData = async (): Promise<TestData> => {
+  await clearTestCollections();
+
+  const users = await createTestUsers();
+  const [foods, required] = await Promise.all([
+    createStandardFoods(users),
+    createRequiredFixtures(),
+  ]);
+
+  return {foods, required, users};
+};
+
+export const toCachedTestData = (testData: TestData): CachedTestData => ({
+  foods: {
+    apple: testData.foods.apple.id,
+    carrots: testData.foods.carrots.id,
+    pizza: testData.foods.pizza.id,
+    spinach: testData.foods.spinach.id,
+  },
+  required: {
+    sample: testData.required.sample.id,
+    withAbout: testData.required.withAbout.id,
+  },
+  users: {
+    admin: testData.users.admin.id,
+    adminOther: testData.users.adminOther.id,
+    notAdmin: testData.users.notAdmin.id,
+  },
+});
+
+export const loadTestDataFromDocuments = async (cached: CachedTestData): Promise<TestData> => {
+  const [admin, notAdmin, adminOther, spinach, apple, carrots, pizza, sample, withAbout] =
+    await Promise.all([
+      UserModel.findById(cached.users.admin),
+      UserModel.findById(cached.users.notAdmin),
+      UserModel.findById(cached.users.adminOther),
+      FoodModel.findById(cached.foods.spinach),
+      FoodModel.findById(cached.foods.apple),
+      FoodModel.findById(cached.foods.carrots),
+      FoodModel.findById(cached.foods.pizza),
+      RequiredModel.findById(cached.required.sample),
+      RequiredModel.findById(cached.required.withAbout),
+    ]);
+
+  if (
+    !admin ||
+    !notAdmin ||
+    !adminOther ||
+    !spinach ||
+    !apple ||
+    !carrots ||
+    !pizza ||
+    !sample ||
+    !withAbout
+  ) {
+    throw new Error("[createTestData] Cached test data references missing documents");
+  }
+
+  return {
+    foods: {apple, carrots, pizza, spinach},
+    required: {sample, withAbout},
+    users: {admin, adminOther, notAdmin},
+  };
+};