@terreno/api 0.21.0 → 0.22.0

package/dist/tests/testHelper.js

@@ -0,0 +1,115 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTestData = exports.createTestData = exports.resetTestCollections = exports.setupTestData = exports.setupDb = exports.applyTestAuthEnv = void 0;
+var test_1 = require("@terreno/test");
+var logger_1 = require("../logger");
+var createTestData_1 = require("./createTestData");
+var models_1 = require("./models");
+var mongoTestSetup_1 = require("./mongoTestSetup");
+var defaultTestMongoUri = "mongodb://127.0.0.1/terreno?&connectTimeoutMS=360000";
+var applyTestAuthEnv = function () {
+    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";
+};
+exports.applyTestAuthEnv = applyTestAuthEnv;
+var ensureConnected = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, test_1.ensureTestMongooseConnected)({
+                    defaultUri: defaultTestMongoUri,
+                    onConnectError: logger_1.logger.catch,
+                })];
+            case 1:
+                _a.sent();
+                (0, exports.applyTestAuthEnv)();
+                return [2 /*return*/];
+        }
+    });
+}); };
+/** Seeds only the standard users (legacy helper). */
+var setupDb = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var users, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, ensureConnected()];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/, Promise.all([models_1.UserModel.deleteMany({}), models_1.FoodModel.deleteMany({})]).catch(logger_1.logger.catch)];
+            case 2:
+                _a.sent();
+                _a.label = 3;
+            case 3:
+                _a.trys.push([3, 5, , 6]);
+                return [4 /*yield*/, (0, createTestData_1.createTestUsers)()];
+            case 4:
+                users = _a.sent();
+                return [2 /*return*/, [users.admin, users.notAdmin, users.adminOther]];
+            case 5:
+                error_1 = _a.sent();
+                logger_1.logger.error("Error setting up DB", error_1);
+                throw error_1;
+            case 6: return [2 /*return*/];
+        }
+    });
+}); };
+exports.setupDb = setupDb;
+/** Seeds users, foods, and required docs — the recommended API test baseline. */
+var setupTestData = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, ensureConnected()];
+            case 1:
+                _a.sent();
+                if (process.env.TERRENO_TEST_USE_FIXTURE_CACHE === "true") {
+                    return [2 /*return*/, (0, mongoTestSetup_1.loadTestData)()];
+                }
+                return [2 /*return*/, (0, createTestData_1.createTestData)()];
+        }
+    });
+}); };
+exports.setupTestData = setupTestData;
+/** Clears all API test collections without re-seeding. */
+exports.resetTestCollections = createTestData_1.clearTestCollections;
+var createTestData_2 = require("./createTestData");
+Object.defineProperty(exports, "createTestData", { enumerable: true, get: function () { return createTestData_2.createTestData; } });
+var mongoTestSetup_2 = require("./mongoTestSetup");
+Object.defineProperty(exports, "loadTestData", { enumerable: true, get: function () { return mongoTestSetup_2.loadTestData; } });

package/dist/tests/types.d.ts

@@ -0,0 +1,29 @@
+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/dist/tests/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tests.d.ts

@@ -1,81 +1,13 @@
-import express, { type Express } from "express";
-import mongoose, { type Model, Schema } from "mongoose";
+import type express from "express";
+import type { Express } from "express";
 import type TestAgent from "supertest/lib/agent";
-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 declare const UserModel: mongoose.Model<User, {}, {}, {}, mongoose.Document<unknown, {}, User, {}, {}> & User & {
-    _id: mongoose.Types.ObjectId;
-} & {
-    __v: number;
-}, any>;
-export declare const SuperUserModel: mongoose.Model<User & SuperUser, {}, {}, {}, mongoose.Document<unknown, {}, User & SuperUser, {}, {}> & User & SuperUser & {
-    _id: mongoose.Types.ObjectId;
-} & {
-    __v: number;
-}, any>;
-export declare const StaffUserModel: mongoose.Model<User & StaffUser, {}, {}, {}, mongoose.Document<unknown, {}, User & StaffUser, {}, {}> & User & StaffUser & {
-    _id: mongoose.Types.ObjectId;
-} & {
-    __v: number;
-}, any>;
-export declare const FoodModel: Model<Food>;
-interface RequiredField {
-    name: string;
-    about?: string;
-}
-export declare const RequiredModel: mongoose.Model<RequiredField, {}, {}, {}, mongoose.Document<unknown, {}, RequiredField, {}, {}> & RequiredField & {
-    _id: mongoose.Types.ObjectId;
-} & {
-    __v: number;
-}, any>;
+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 declare const getBaseServer: () => Express;
 export declare const authAsUser: (app: express.Application, type: "admin" | "notAdmin") => Promise<TestAgent>;
-export declare const setupDb: () => Promise<(mongoose.Document<unknown, {}, User, {}, {}> & User & {
-    _id: mongoose.Types.ObjectId;
-} & {
-    __v: number;
-})[]>;
-export {};
+export { loadTestData } from "./tests/mongoTestSetup";

package/dist/tests.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -68,245 +35,38 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupDb = exports.authAsUser = exports.getBaseServer = exports.RequiredModel = exports.FoodModel = exports.StaffUserModel = exports.SuperUserModel = exports.UserModel = void 0;
-var express_1 = __importDefault(require("express"));
-var mongoose_1 = __importStar(require("mongoose"));
-var passport_local_mongoose_1 = __importDefault(require("passport-local-mongoose"));
-var qs_1 = __importDefault(require("qs"));
-var supertest_1 = __importDefault(require("supertest"));
-var logger_1 = require("./logger");
+exports.loadTestData = exports.authAsUser = exports.getBaseServer = exports.UserModel = exports.setupTestData = exports.setupTestCache = exports.setupDb = exports.SuperUserModel = exports.StaffUserModel = exports.RequiredModel = exports.loadTestDataFromCache = exports.FoodModel = exports.createTestData = void 0;
+var test_1 = require("@terreno/test");
 var openApiCompat_1 = require("./openApiCompat");
-var plugins_1 = require("./plugins");
-var userSchema = new mongoose_1.Schema({
-    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(passport_local_mongoose_1.default, {
-    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(plugins_1.createdUpdatedPlugin);
-userSchema.plugin(plugins_1.isDisabledPlugin);
-userSchema.methods.postCreate = function (body) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            this.age = body.age;
-            return [2 /*return*/, this.save()];
-        });
-    });
-};
-exports.UserModel = (0, mongoose_1.model)("User", userSchema);
-var superUserSchema = new mongoose_1.Schema({
-    superTitle: { description: "The super user's title", required: true, type: String },
-});
-exports.SuperUserModel = exports.UserModel.discriminator("SuperUser", superUserSchema);
-var staffUserSchema = new mongoose_1.Schema({
-    department: {
-        description: "The department the staff member belongs to",
-        required: true,
-        type: String,
-    },
-});
-exports.StaffUserModel = exports.UserModel.discriminator("Staff", staffUserSchema);
-var foodCategorySchema = new mongoose_1.Schema({
-    name: { description: "The name of the food category", type: String },
-    show: { description: "Whether this category is visible", type: Boolean },
-}, { timestamps: { createdAt: "created", updatedAt: "updated" } });
-var likesSchema = new mongoose_1.Schema({
-    likes: { description: "Whether the user liked the item", type: Boolean },
-    userId: { description: "The user who liked the item", ref: "User", type: "ObjectId" },
-});
-var foodSchema = new mongoose_1.Schema({
-    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: mongoose_1.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: plugins_1.DateOnly },
-    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 () {
-    return "".concat(this.name, " has ").concat(this.calories, " calories");
-});
-exports.FoodModel = (0, mongoose_1.model)("Food", foodSchema);
-var requiredSchema = new mongoose_1.Schema({
-    about: { description: "Information about the item", type: String },
-    name: { description: "The name of the item", required: true, type: String },
-});
-exports.RequiredModel = (0, mongoose_1.model)("Required", requiredSchema);
+var createTestData_1 = require("./tests/createTestData");
+Object.defineProperty(exports, "createTestData", { enumerable: true, get: function () { return createTestData_1.createTestData; } });
+var models_1 = require("./tests/models");
+Object.defineProperty(exports, "FoodModel", { enumerable: true, get: function () { return models_1.FoodModel; } });
+Object.defineProperty(exports, "RequiredModel", { enumerable: true, get: function () { return models_1.RequiredModel; } });
+Object.defineProperty(exports, "StaffUserModel", { enumerable: true, get: function () { return models_1.StaffUserModel; } });
+Object.defineProperty(exports, "SuperUserModel", { enumerable: true, get: function () { return models_1.SuperUserModel; } });
+Object.defineProperty(exports, "UserModel", { enumerable: true, get: function () { return models_1.UserModel; } });
+var mongoTestSetup_1 = require("./tests/mongoTestSetup");
+Object.defineProperty(exports, "loadTestDataFromCache", { enumerable: true, get: function () { return mongoTestSetup_1.loadTestDataFromCache; } });
+Object.defineProperty(exports, "setupTestCache", { enumerable: true, get: function () { return mongoTestSetup_1.setupTestCache; } });
+var testHelper_1 = require("./tests/testHelper");
+Object.defineProperty(exports, "setupDb", { enumerable: true, get: function () { return testHelper_1.setupDb; } });
+Object.defineProperty(exports, "setupTestData", { enumerable: true, get: function () { return testHelper_1.setupTestData; } });
 var getBaseServer = function () {
-    var app = (0, express_1.default)();
-    app.set("query parser", function (str) { return qs_1.default.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 TerrenoApp.build() configures.
-    app.set("query parser", function (str) { return qs_1.default.parse(str, { arrayLimit: 200 }); });
-    // Record mount paths on layers for Express 5 → OpenAPI compat
-    (0, openApiCompat_1.patchAppUse)(app);
-    app.use(function (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 (0, test_1.getBaseServer)({
+        patchOpenApiCompat: openApiCompat_1.patchAppUse,
     });
-    app.use(express_1.default.json());
-    return app;
 };
 exports.getBaseServer = getBaseServer;
 var authAsUser = function (app, type) { return __awaiter(void 0, void 0, void 0, function () {
-    var email, password, agent, res;
+    var email, password;
     return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                email = type === "admin" ? "admin@example.com" : "notAdmin@example.com";
-                password = type === "admin" ? "securePassword" : "password";
-                agent = supertest_1.default.agent(app);
-                return [4 /*yield*/, agent.post("/auth/login").send({ email: email, password: password }).expect(200)];
-            case 1:
-                res = _a.sent();
-                return [4 /*yield*/, agent.set("authorization", "Bearer ".concat(res.body.data.token))];
-            case 2:
-                _a.sent();
-                return [2 /*return*/, agent];
-        }
+        email = type === "admin" ? "admin@example.com" : "notAdmin@example.com";
+        password = type === "admin" ? "securePassword" : "password";
+        return [2 /*return*/, (0, test_1.authAsUser)(app, { email: email, password: password })];
     });
 }); };
 exports.authAsUser = authAsUser;
-var defaultTestMongoUri = "mongodb://127.0.0.1/terreno?&connectTimeoutMS=360000";
-/** Ensures Mongoose is connected without replacing an existing test connection (e.g. MongoMemoryServer from bunSetup). */
-var ensureTestMongooseConnected = function () { return __awaiter(void 0, void 0, void 0, function () {
-    var uri;
-    var _a;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                if (mongoose_1.default.connection.readyState === 1) {
-                    return [2 /*return*/];
-                }
-                if (!(mongoose_1.default.connection.readyState === 2)) return [3 /*break*/, 2];
-                return [4 /*yield*/, mongoose_1.default.connection.asPromise()];
-            case 1:
-                _b.sent();
-                return [2 /*return*/];
-            case 2:
-                uri = ((_a = process.env.TERRENO_TEST_MONGODB_URI) === null || _a === void 0 ? void 0 : _a.trim()) || defaultTestMongoUri;
-                return [4 /*yield*/, mongoose_1.default.connect(uri).catch(logger_1.logger.catch)];
-            case 3:
-                _b.sent();
-                return [2 /*return*/];
-        }
-    });
-}); };
-var setupDb = function () { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, notAdmin, admin, adminOther, error_1;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0: return [4 /*yield*/, ensureTestMongooseConnected()];
-            case 1:
-                _b.sent();
-                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.
-                return [4 /*yield*/, Promise.all([exports.UserModel.deleteMany({}), exports.FoodModel.deleteMany({})]).catch(logger_1.logger.catch)];
-            case 2:
-                // Broken out of the try/catch below so you can test the catch logger by shutting down mongo.
-                _b.sent();
-                _b.label = 3;
-            case 3:
-                _b.trys.push([3, 11, , 12]);
-                return [4 /*yield*/, Promise.all([
-                        exports.UserModel.create({ email: "notAdmin@example.com", name: "Not Admin" }),
-                        exports.UserModel.create({ admin: true, email: "admin@example.com", name: "Admin" }),
-                        exports.UserModel.create({ admin: true, email: "admin+other@example.com", name: "Admin Other" }),
-                    ])];
-            case 4:
-                _a = __read.apply(void 0, [_b.sent(), 3]), notAdmin = _a[0], admin = _a[1], adminOther = _a[2];
-                return [4 /*yield*/, notAdmin.setPassword("password")];
-            case 5:
-                _b.sent();
-                return [4 /*yield*/, notAdmin.save()];
-            case 6:
-                _b.sent();
-                return [4 /*yield*/, admin.setPassword("securePassword")];
-            case 7:
-                _b.sent();
-                return [4 /*yield*/, admin.save()];
-            case 8:
-                _b.sent();
-                return [4 /*yield*/, adminOther.setPassword("otherPassword")];
-            case 9:
-                _b.sent();
-                return [4 /*yield*/, adminOther.save()];
-            case 10:
-                _b.sent();
-                return [2 /*return*/, [admin, notAdmin, adminOther]];
-            case 11:
-                error_1 = _b.sent();
-                logger_1.logger.error("Error setting up DB", error_1);
-                throw error_1;
-            case 12: return [2 /*return*/];
-        }
-    });
-}); };
-exports.setupDb = setupDb;
+var mongoTestSetup_2 = require("./tests/mongoTestSetup");
+Object.defineProperty(exports, "loadTestData", { enumerable: true, get: function () { return mongoTestSetup_2.loadTestData; } });