@terreno/api 0.20.2 → 0.22.0

package/src/tests/models.ts

@@ -0,0 +1,164 @@
+import mongoose, {type Model, model, Schema} from "mongoose";
+import passportLocalMongoose from "passport-local-mongoose";
+
+import {createdUpdatedPlugin, DateOnly, isDisabledPlugin} from "../plugins";
+
+export interface User {
+  admin: boolean;
+  name?: string;
+  username: string;
+  email: string;
+  age?: number;
+  disabled?: boolean;
+}
+
+export interface SuperUser extends User {
+  superTitle: string;
+}
+
+export interface StaffUser extends User {
+  department: string;
+}
+
+export interface FoodCategory {
+  _id?: string;
+  name: string;
+  show: boolean;
+  created: Date;
+  updated: Date;
+}
+
+export interface Food {
+  _id: string;
+  name: string;
+  calories: number;
+  created: Date;
+  ownerId: mongoose.Types.ObjectId | User;
+  hidden?: boolean;
+  source: {
+    name: string;
+    href?: string;
+    dateAdded?: string;
+  };
+  tags: string[];
+  eatenBy: [Schema.Types.ObjectId | User];
+  lastEatenWith: {[name: string]: Date};
+  categories: FoodCategory[];
+  expiration: string;
+  likesIds: {userId: string; likes: boolean}[];
+}
+
+export interface RequiredField {
+  name: string;
+  about?: string;
+}
+
+const userSchema = new Schema<User>({
+  admin: {default: false, description: "Whether the user has admin privileges", type: Boolean},
+  age: {description: "The user's age", type: Number},
+  name: {description: "The user's display name", type: String},
+  username: {description: "The user's username", type: String},
+});
+
+userSchema.plugin(
+  passportLocalMongoose as unknown as (schema: Schema, options?: Record<string, unknown>) => void,
+  {
+    attemptsField: "attempts",
+    interval: process.env.NODE_ENV === "test" ? 1 : 100,
+    limitAttempts: true,
+    maxAttempts: 3,
+    maxInterval: process.env.NODE_ENV === "test" ? 1 : 300000,
+    usernameCaseInsensitive: true,
+    usernameField: "email",
+  }
+);
+userSchema.plugin(createdUpdatedPlugin);
+userSchema.plugin(isDisabledPlugin);
+userSchema.methods.postCreate = async function (body: {age?: number}) {
+  this.age = body.age;
+  return this.save();
+};
+
+export const UserModel = model<User>("User", userSchema);
+
+const superUserSchema = new Schema<SuperUser>({
+  superTitle: {description: "The super user's title", required: true, type: String},
+});
+export const SuperUserModel = UserModel.discriminator("SuperUser", superUserSchema);
+
+const staffUserSchema = new Schema<StaffUser>({
+  department: {
+    description: "The department the staff member belongs to",
+    required: true,
+    type: String,
+  },
+});
+export const StaffUserModel = UserModel.discriminator("Staff", staffUserSchema);
+
+const foodCategorySchema = new Schema<FoodCategory>(
+  {
+    name: {description: "The name of the food category", type: String},
+    show: {description: "Whether this category is visible", type: Boolean},
+  },
+  {timestamps: {createdAt: "created", updatedAt: "updated"}}
+);
+
+interface Likes {
+  likes: boolean;
+  userId: mongoose.Types.ObjectId;
+}
+
+const likesSchema = new Schema<Likes>({
+  likes: {description: "Whether the user liked the item", type: Boolean},
+  userId: {description: "The user who liked the item", ref: "User", type: "ObjectId"},
+});
+
+const foodSchema = new Schema<Food>(
+  {
+    calories: {description: "Number of calories in the food", type: Number},
+    categories: {description: "Categories this food belongs to", type: [foodCategorySchema]},
+    created: {description: "When this food was created", type: Date},
+    eatenBy: [
+      {
+        description: "Users who have eaten this food",
+        ref: "User",
+        required: true,
+        type: Schema.Types.ObjectId,
+      },
+    ],
+    // biome-ignore lint/suspicious/noExplicitAny: DateOnly is a custom SchemaType not recognized by Mongoose's built-in type definitions
+    expiration: {description: "Expiration date of the food", type: DateOnly as any},
+    hidden: {
+      default: false,
+      description: "Whether this food is hidden from listings",
+      type: Boolean,
+    },
+    lastEatenWith: {
+      description: "Map of user names to dates they last ate this food with",
+      of: Date,
+      type: Map,
+    },
+    likesIds: {description: "User likes for this food", required: true, type: [likesSchema]},
+    name: {description: "The name of the food", type: String},
+    ownerId: {description: "The user who owns this food entry", ref: "User", type: "ObjectId"},
+    source: {
+      dateAdded: {description: "When the source was added", type: String},
+      href: {description: "URL of the source", type: String},
+      name: {description: "Name of the source", type: String},
+    },
+    tags: {description: "Tags associated with this food", type: [String]},
+  },
+  {strict: "throw", toJSON: {virtuals: true}, toObject: {virtuals: true}}
+);
+
+foodSchema.virtual("description").get(function (this: Food) {
+  return `${this.name} has ${this.calories} calories`;
+});
+
+export const FoodModel: Model<Food> = model<Food>("Food", foodSchema);
+
+const requiredSchema = new Schema<RequiredField>({
+  about: {description: "Information about the item", type: String},
+  name: {description: "The name of the item", required: true, type: String},
+});
+export const RequiredModel = model<RequiredField>("Required", requiredSchema);

package/src/tests/mongoTestSetup.ts

@@ -0,0 +1,69 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+import {createMongoTestCache} from "@terreno/test";
+
+import {createTestData, loadTestDataFromDocuments, toCachedTestData} from "./createTestData";
+import type {CachedTestData, TestData} from "./types";
+
+const moduleDir = __dirname;
+const defaultCacheDir =
+  process.env.TERRENO_TEST_CACHE_DIR || path.join("/tmp", "terreno-api-test-cache");
+
+const apiTestCache = createMongoTestCache({
+  baseDatabaseName: "terrenoTest_base",
+  cacheDir: defaultCacheDir,
+  createTestData: async (): Promise<CachedTestData> => {
+    const testData = await createTestData();
+    return toCachedTestData(testData);
+  },
+  sourceDirs: [path.resolve(moduleDir, "..")],
+});
+
+export const {cacheFilesExist, cleanCache, loadTestDataFromCache, setupTestCache} = apiTestCache;
+
+let cachedTestData: TestData | undefined;
+
+/** Loads fixture documents after the collection cache has been restored. */
+export const loadTestData = async (): Promise<TestData> => {
+  if (cachedTestData) {
+    return cachedTestData;
+  }
+
+  const cachedFilePath = path.join(defaultCacheDir, "cached-data.json");
+  const cached = JSON.parse(fs.readFileSync(cachedFilePath, "utf-8")) as CachedTestData;
+  cachedTestData = await loadTestDataFromDocuments(cached);
+  return cachedTestData;
+};
+
+export const resetCachedTestData = (): void => {
+  cachedTestData = undefined;
+};
+
+if (process.argv[1]?.includes("mongoTestSetup")) {
+  const command = process.argv[2];
+  const force = process.argv.includes("--force");
+
+  void (async (): Promise<void> => {
+    if (command === "setup") {
+      await setupTestCache({force});
+      process.exit(0);
+    }
+
+    if (command === "clean") {
+      cleanCache();
+      resetCachedTestData();
+      process.exit(0);
+    }
+
+    if (command === "status") {
+      console.info(`[mongoTestSetup] cache exists: ${cacheFilesExist()}`);
+      process.exit(0);
+    }
+
+    console.error(
+      `[mongoTestSetup] Unknown command: ${command ?? "(none)"}. Usage: setup | clean | status`
+    );
+    process.exit(1);
+  })();
+}

package/src/tests/testEnv.ts

@@ -0,0 +1,4 @@
+/** Use in-memory MongoDB when no external test URI is configured (local / CI without mongod). */
+if (!process.env.TERRENO_TEST_MONGODB_URI?.trim()) {
+  process.env.TERRENO_TEST_USE_MEMORY_MONGO = "true";
+}

package/src/tests/testHelper.ts

@@ -0,0 +1,57 @@
+import {ensureTestMongooseConnected} from "@terreno/test";
+
+import {logger} from "../logger";
+import {clearTestCollections, createTestData, createTestUsers} from "./createTestData";
+import {FoodModel, UserModel} from "./models";
+import {loadTestData} from "./mongoTestSetup";
+import type {TestData} from "./types";
+
+const defaultTestMongoUri = "mongodb://127.0.0.1/terreno?&connectTimeoutMS=360000";
+
+export const applyTestAuthEnv = (): void => {
+  process.env.REFRESH_TOKEN_SECRET = "refresh_secret";
+  process.env.TOKEN_SECRET = "secret";
+  process.env.TOKEN_EXPIRES_IN = "30m";
+  process.env.TOKEN_ISSUER = "example.com";
+  process.env.SESSION_SECRET = "session";
+};
+
+const ensureConnected = async (): Promise<void> => {
+  await ensureTestMongooseConnected({
+    defaultUri: defaultTestMongoUri,
+    onConnectError: logger.catch,
+  });
+  applyTestAuthEnv();
+};
+
+/** Seeds only the standard users (legacy helper). */
+export const setupDb = async () => {
+  await ensureConnected();
+
+  await Promise.all([UserModel.deleteMany({}), FoodModel.deleteMany({})]).catch(logger.catch);
+
+  try {
+    const users = await createTestUsers();
+    return [users.admin, users.notAdmin, users.adminOther] as const;
+  } catch (error) {
+    logger.error("Error setting up DB", error);
+    throw error;
+  }
+};
+
+/** Seeds users, foods, and required docs — the recommended API test baseline. */
+export const setupTestData = async (): Promise<TestData> => {
+  await ensureConnected();
+
+  if (process.env.TERRENO_TEST_USE_FIXTURE_CACHE === "true") {
+    return loadTestData();
+  }
+
+  return createTestData();
+};
+
+/** Clears all API test collections without re-seeding. */
+export const resetTestCollections = clearTestCollections;
+
+export {createTestData} from "./createTestData";
+export {loadTestData} from "./mongoTestSetup";

package/src/tests/types.ts

@@ -0,0 +1,35 @@
+import type {HydratedDocument} from "mongoose";
+
+import type {Food, RequiredField, User} from "./models";
+
+export interface TestUsers {
+  admin: HydratedDocument<User>;
+  adminOther: HydratedDocument<User>;
+  notAdmin: HydratedDocument<User>;
+}
+
+export interface TestFoods {
+  apple: HydratedDocument<Food>;
+  carrots: HydratedDocument<Food>;
+  pizza: HydratedDocument<Food>;
+  spinach: HydratedDocument<Food>;
+}
+
+export interface TestRequired {
+  sample: HydratedDocument<RequiredField>;
+  withAbout: HydratedDocument<RequiredField>;
+}
+
+/** Canonical API integration-test fixture graph. */
+export interface TestData {
+  foods: TestFoods;
+  required: TestRequired;
+  users: TestUsers;
+}
+
+/** JSON-serializable snapshot stored alongside collection cache files. */
+export interface CachedTestData {
+  foods: Record<keyof TestFoods, string>;
+  required: Record<keyof TestRequired, string>;
+  users: Record<keyof TestUsers, string>;
+}

package/src/tests.ts

@@ -1,200 +1,48 @@
-import express, {type Express} from "express";
-import mongoose, {type Model, model, Schema} from "mongoose";
-import passportLocalMongoose, {type PassportLocalMongooseDocument} from "passport-local-mongoose";
-import qs from "qs";
-import supertest from "supertest";
+import {
+  authAsUser as authAsUserWithCredentials,
+  getBaseServer as createBaseTestServer,
+} from "@terreno/test";
+import type express from "express";
+import type {Express} from "express";
 import type TestAgent from "supertest/lib/agent";
 
-import {logger} from "./logger";
 import {patchAppUse} from "./openApiCompat";
-import {createdUpdatedPlugin, DateOnly, isDisabledPlugin} from "./plugins";
-
-export interface User {
-  admin: boolean;
-  name?: string;
-  username: string;
-  email: string;
-  age?: number;
-  disabled?: boolean;
-}
-
-export interface SuperUser extends User {
-  superTitle: string;
-}
-
-export interface StaffUser extends User {
-  department: string;
-}
-
-export interface FoodCategory {
-  _id?: string;
-  name: string;
-  show: boolean;
-  created: Date;
-  updated: Date;
-}
-
-export interface Food {
-  _id: string;
-  name: string;
-  calories: number;
-  created: Date;
-  ownerId: mongoose.Types.ObjectId | User;
-  hidden?: boolean;
-  source: {
-    name: string;
-    href?: string;
-    dateAdded?: string;
-  };
-  tags: string[];
-  eatenBy: [Schema.Types.ObjectId | User];
-  // We want to test that map type works.
-  lastEatenWith: {[name: string]: Date};
-  categories: FoodCategory[];
-  expiration: string;
-  likesIds: {userId: string; likes: boolean}[];
-}
-
-const userSchema = new Schema<User>({
-  admin: {default: false, description: "Whether the user has admin privileges", type: Boolean},
-  age: {description: "The user's age", type: Number},
-  name: {description: "The user's display name", type: String},
-  username: {description: "The user's username", type: String},
-});
-
-userSchema.plugin(
-  passportLocalMongoose as unknown as (schema: Schema, options?: Record<string, unknown>) => void,
-  {
-    attemptsField: "attempts",
-    interval: process.env.NODE_ENV === "test" ? 1 : 100,
-    limitAttempts: true,
-    maxAttempts: 3,
-    maxInterval: process.env.NODE_ENV === "test" ? 1 : 300000,
-    usernameCaseInsensitive: true,
-    usernameField: "email",
-  }
-);
-// userSchema.plugin(tokenPlugin);
-userSchema.plugin(createdUpdatedPlugin);
-userSchema.plugin(isDisabledPlugin);
-userSchema.methods.postCreate = async function (body: {age?: number}) {
-  this.age = body.age;
-  return this.save();
+import {createTestData} from "./tests/createTestData";
+import {
+  type Food,
+  type FoodCategory,
+  FoodModel,
+  type RequiredField,
+  RequiredModel,
+  type StaffUser,
+  StaffUserModel,
+  type SuperUser,
+  SuperUserModel,
+  type User,
+  UserModel,
+} from "./tests/models";
+import {loadTestDataFromCache, setupTestCache} from "./tests/mongoTestSetup";
+import {setupDb, setupTestData} from "./tests/testHelper";
+import type {TestData} from "./tests/types";
+
+export type {Food, FoodCategory, RequiredField, StaffUser, SuperUser, TestData, User};
+export {
+  createTestData,
+  FoodModel,
+  loadTestDataFromCache,
+  RequiredModel,
+  StaffUserModel,
+  SuperUserModel,
+  setupDb,
+  setupTestCache,
+  setupTestData,
+  UserModel,
 };
 
-export const UserModel = model<User>("User", userSchema);
-
-const superUserSchema = new Schema<SuperUser>({
-  superTitle: {description: "The super user's title", required: true, type: String},
-});
-export const SuperUserModel = UserModel.discriminator("SuperUser", superUserSchema);
-
-const staffUserSchema = new Schema<StaffUser>({
-  department: {
-    description: "The department the staff member belongs to",
-    required: true,
-    type: String,
-  },
-});
-export const StaffUserModel = UserModel.discriminator("Staff", staffUserSchema);
-
-const foodCategorySchema = new Schema<FoodCategory>(
-  {
-    name: {description: "The name of the food category", type: String},
-    show: {description: "Whether this category is visible", type: Boolean},
-  },
-  {timestamps: {createdAt: "created", updatedAt: "updated"}}
-);
-
-interface Likes {
-  likes: boolean;
-  userId: mongoose.Types.ObjectId;
-}
-
-const likesSchema = new Schema<Likes>({
-  likes: {description: "Whether the user liked the item", type: Boolean},
-  userId: {description: "The user who liked the item", ref: "User", type: "ObjectId"},
-});
-
-const foodSchema = new Schema<Food>(
-  {
-    calories: {description: "Number of calories in the food", type: Number},
-    categories: {description: "Categories this food belongs to", type: [foodCategorySchema]},
-    created: {description: "When this food was created", type: Date},
-    eatenBy: [
-      {
-        description: "Users who have eaten this food",
-        ref: "User",
-        required: true,
-        type: Schema.Types.ObjectId,
-      },
-    ],
-    // biome-ignore lint/suspicious/noExplicitAny: DateOnly is a custom SchemaType not recognized by Mongoose's built-in type definitions
-    expiration: {description: "Expiration date of the food", type: DateOnly as any},
-    hidden: {
-      default: false,
-      description: "Whether this food is hidden from listings",
-      type: Boolean,
-    },
-    lastEatenWith: {
-      description: "Map of user names to dates they last ate this food with",
-      of: Date,
-      type: Map,
-    },
-    likesIds: {description: "User likes for this food", required: true, type: [likesSchema]},
-    name: {description: "The name of the food", type: String},
-    ownerId: {description: "The user who owns this food entry", ref: "User", type: "ObjectId"},
-    source: {
-      dateAdded: {description: "When the source was added", type: String},
-      href: {description: "URL of the source", type: String},
-      name: {description: "Name of the source", type: String},
-    },
-    tags: {description: "Tags associated with this food", type: [String]},
-  },
-  {strict: "throw", toJSON: {virtuals: true}, toObject: {virtuals: true}}
-);
-
-foodSchema.virtual("description").get(function (this: Food) {
-  return `${this.name} has ${this.calories} calories`;
-});
-
-export const FoodModel: Model<Food> = model<Food>("Food", foodSchema);
-
-interface RequiredField {
-  name: string;
-  about?: string;
-}
-
-const requiredSchema = new Schema<RequiredField>({
-  about: {description: "Information about the item", type: String},
-  name: {description: "The name of the item", required: true, type: String},
-});
-export const RequiredModel = model<RequiredField>("Required", requiredSchema);
-
 export const getBaseServer = (): Express => {
-  const app = express();
-  app.set("query parser", (str: string) => qs.parse(str, {arrayLimit: 200}));
-
-  // Express 5 defaults to 'simple' query parser (Node querystring) which doesn't
-  // support nested bracket notation like name[$regex]=Green. Use qs to match
-  // what setupServer() configures.
-  app.set("query parser", (str: string) => qs.parse(str, {arrayLimit: 200}));
-
-  // Record mount paths on layers for Express 5 → OpenAPI compat
-  patchAppUse(app);
-
-  app.use((req, res, next) => {
-    res.header("Access-Control-Allow-Origin", "*");
-    res.header("Access-Control-Allow-Headers", "*");
-    // intercepts OPTIONS method
-    if (req.method === "OPTIONS") {
-      res.send(200);
-    } else {
-      next();
-    }
+  return createBaseTestServer({
+    patchOpenApiCompat: patchAppUse,
   });
-  app.use(express.json());
-  return app;
 };
 
 export const authAsUser = async (
@@ -203,46 +51,7 @@ export const authAsUser = async (
 ): Promise<TestAgent> => {
   const email = type === "admin" ? "admin@example.com" : "notAdmin@example.com";
   const password = type === "admin" ? "securePassword" : "password";
-
-  const agent = supertest.agent(app);
-  const res = await agent.post("/auth/login").send({email, password}).expect(200);
-  await agent.set("authorization", `Bearer ${res.body.data.token}`);
-  return agent;
+  return authAsUserWithCredentials(app, {email, password});
 };
 
-export const setupDb = async () => {
-  await mongoose
-    .connect("mongodb://127.0.0.1/terreno?&connectTimeoutMS=360000")
-    .catch(logger.catch);
-
-  process.env.REFRESH_TOKEN_SECRET = "refresh_secret";
-  process.env.TOKEN_SECRET = "secret";
-  process.env.TOKEN_EXPIRES_IN = "30m";
-  process.env.TOKEN_ISSUER = "example.com";
-  process.env.SESSION_SECRET = "session";
-
-  // Broken out of the try/catch below so you can test the catch logger by shutting down mongo.
-  await Promise.all([UserModel.deleteMany({}), FoodModel.deleteMany({})]).catch(logger.catch);
-
-  try {
-    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 (notAdmin as unknown as PassportLocalMongooseDocument).setPassword("password");
-    await notAdmin.save();
-
-    await (admin as unknown as PassportLocalMongooseDocument).setPassword("securePassword");
-    await admin.save();
-
-    await (adminOther as unknown as PassportLocalMongooseDocument).setPassword("otherPassword");
-
-    await adminOther.save();
-
-    return [admin, notAdmin, adminOther];
-  } catch (error) {
-    logger.error("Error setting up DB", error);
-    throw error;
-  }
-};
+export {loadTestData} from "./tests/mongoTestSetup";