···
+
import { assertEquals, assertExists } from "@std/assert";
+
import { z } from "@zod/zod";
+
import { connect, disconnect, Model, type Input } from "../mod.ts";
+
import { applyDefaultsForUpsert } from "../model/validation.ts";
+
import { MongoMemoryServer } from "mongodb-memory-server-core";
+
* Test suite for default value handling in different operation types
+
* This tests the three main cases:
+
* 1. Plain inserts - defaults applied directly
+
* 2. Updates without upsert - defaults NOT applied
+
* 3. Upserts that create - defaults applied via $setOnInsert
+
* 4. Upserts that match - $setOnInsert ignored (correct behavior)
+
* 5. Replace with upsert - defaults applied on creation
+
// Schema with defaults for testing
+
const productSchema = z.object({
+
price: z.number().min(0),
+
category: z.string().default("general"),
+
inStock: z.boolean().default(true),
+
createdAt: z.date().default(() => new Date("2024-01-01T00:00:00Z")),
+
tags: z.array(z.string()).default([]),
+
type Product = z.infer<typeof productSchema>;
+
type ProductInsert = Input<typeof productSchema>;
+
let ProductModel: Model<typeof productSchema>;
+
let mongoServer: MongoMemoryServer;
+
Deno.test.beforeAll(async () => {
+
mongoServer = await MongoMemoryServer.create();
+
const uri = mongoServer.getUri();
+
await connect(uri, "test_defaults_db");
+
ProductModel = new Model("test_products_defaults", productSchema);
+
Deno.test.beforeEach(async () => {
+
await ProductModel.delete({});
+
Deno.test.afterAll(async () => {
+
await ProductModel.delete({});
+
await mongoServer.stop();
+
name: "Defaults: Case 1 - Plain insert applies defaults",
+
// Insert without providing optional fields with defaults
+
const result = await ProductModel.insertOne({
+
// category, inStock, createdAt, tags not provided - should use defaults
+
assertExists(result.insertedId);
+
// Verify defaults were applied
+
const product = await ProductModel.findById(result.insertedId);
+
assertEquals(product.name, "Widget");
+
assertEquals(product.price, 29.99);
+
assertEquals(product.category, "general"); // default
+
assertEquals(product.inStock, true); // default
+
assertExists(product.createdAt); // default function called
+
assertEquals(product.tags, []); // default empty array
+
sanitizeResources: false,
+
name: "Defaults: Case 2 - Update without upsert does NOT apply defaults",
+
// First create a document without defaults (simulate old data)
+
const insertResult = await ProductModel.insertOne({
+
category: "electronics",
+
createdAt: new Date("2023-01-01"),
+
assertExists(insertResult.insertedId);
+
// Now update it - defaults should NOT be applied
+
await ProductModel.updateOne(
+
{ _id: insertResult.insertedId },
+
const updated = await ProductModel.findById(insertResult.insertedId);
+
assertEquals(updated.price, 24.99); // updated
+
assertEquals(updated.category, "electronics"); // unchanged
+
assertEquals(updated.inStock, false); // unchanged
+
assertEquals(updated.tags, ["test"]); // unchanged
+
sanitizeResources: false,
+
name: "Defaults: Case 3 - Upsert that creates applies defaults via $setOnInsert",
+
// Upsert with a query that won't match - will create new document
+
const result = await ProductModel.updateOne(
+
{ name: "NonExistent" },
+
assertEquals(result.upsertedCount, 1);
+
assertExists(result.upsertedId);
+
// Verify the created document has defaults applied
+
const product = await ProductModel.findOne({ name: "NonExistent" });
+
assertEquals(product.price, 39.99); // from $set
+
assertEquals(product.name, "NonExistent"); // from query
+
assertEquals(product.category, "general"); // default via $setOnInsert
+
assertEquals(product.inStock, true); // default via $setOnInsert
+
assertExists(product.createdAt); // default via $setOnInsert
+
assertEquals(product.tags, []); // default via $setOnInsert
+
sanitizeResources: false,
+
name: "Defaults: Case 4 - Upsert that matches does NOT apply defaults",
+
// Create a document first with explicit non-default values
+
const insertResult = await ProductModel.insertOne({
+
name: "ExistingProduct",
+
createdAt: new Date("2023-06-01"),
+
tags: ["premium", "featured"],
+
assertExists(insertResult.insertedId);
+
// Upsert with matching query - should update, not insert
+
const result = await ProductModel.updateOne(
+
{ name: "ExistingProduct" },
+
assertEquals(result.matchedCount, 1);
+
assertEquals(result.modifiedCount, 1);
+
assertEquals(result.upsertedCount, 0); // No insert happened
+
// Verify defaults were NOT applied (existing values preserved)
+
const product = await ProductModel.findOne({ name: "ExistingProduct" });
+
assertEquals(product.price, 44.99); // updated via $set
+
assertEquals(product.category, "premium"); // preserved (not overwritten with default)
+
assertEquals(product.inStock, false); // preserved
+
assertEquals(product.tags, ["premium", "featured"]); // preserved
+
sanitizeResources: false,
+
name: "Defaults: Case 5 - Replace without upsert uses defaults from parse",
+
// Create initial document
+
const insertResult = await ProductModel.insertOne({
+
createdAt: new Date("2020-01-01"),
+
assertExists(insertResult.insertedId);
+
// Replace with partial data - defaults should fill in missing fields
+
await ProductModel.replaceOne(
+
{ _id: insertResult.insertedId },
+
// category, inStock, createdAt, tags not provided - defaults should apply
+
const product = await ProductModel.findById(insertResult.insertedId);
+
assertEquals(product.name, "Replaced");
+
assertEquals(product.price, 15.0);
+
assertEquals(product.category, "general"); // default applied
+
assertEquals(product.inStock, true); // default applied
+
assertExists(product.createdAt); // default applied
+
assertEquals(product.tags, []); // default applied
+
sanitizeResources: false,
+
name: "Defaults: Case 6 - Replace with upsert (creates) applies defaults",
+
// Replace with upsert on non-existent document
+
const result = await ProductModel.replaceOne(
+
{ name: "NewViaReplace" },
+
// Missing optional fields - defaults should apply
+
assertEquals(result.upsertedCount, 1);
+
assertExists(result.upsertedId);
+
const product = await ProductModel.findOne({ name: "NewViaReplace" });
+
assertEquals(product.name, "NewViaReplace");
+
assertEquals(product.price, 99.99);
+
assertEquals(product.category, "general"); // default
+
assertEquals(product.inStock, true); // default
+
assertExists(product.createdAt); // default
+
assertEquals(product.tags, []); // default
+
sanitizeResources: false,
+
name: "Defaults: Upsert only applies defaults to unmodified fields",
+
// Upsert where we explicitly set some fields that have defaults
+
const result = await ProductModel.updateOne(
+
{ name: "CustomDefaults" },
+
category: "custom", // Explicitly setting a field that has a default
+
// inStock not set - should get default
+
assertEquals(result.upsertedCount, 1);
+
const product = await ProductModel.findOne({ name: "CustomDefaults" });
+
assertEquals(product.name, "CustomDefaults"); // from query
+
assertEquals(product.price, 25.0); // from $set
+
assertEquals(product.category, "custom"); // from $set (NOT default)
+
assertEquals(product.inStock, true); // default via $setOnInsert
+
assertExists(product.createdAt); // default via $setOnInsert
+
assertEquals(product.tags, []); // default via $setOnInsert
+
sanitizeResources: false,
+
name: "Defaults: insertMany applies defaults to all documents",
+
const result = await ProductModel.insertMany([
+
{ name: "Bulk1", price: 10 },
+
{ name: "Bulk2", price: 20, category: "special" },
+
{ name: "Bulk3", price: 30 },
+
assertEquals(Object.keys(result.insertedIds).length, 3);
+
const products = await ProductModel.find({});
+
assertEquals(products.length, 3);
+
// All should have defaults where not provided
+
for (const product of products) {
+
assertExists(product.createdAt);
+
assertEquals(product.inStock, true);
+
assertEquals(product.tags, []);
+
if (product.name === "Bulk2") {
+
assertEquals(product.category, "special");
+
assertEquals(product.category, "general");
+
sanitizeResources: false,
+
name: "Defaults: applyDefaultsForUpsert preserves existing $setOnInsert values",
+
const schema = z.object({
+
flag: z.boolean().default(true),
+
count: z.number().default(0),
+
$set: { name: "test" },
+
$setOnInsert: { flag: false },
+
const result = applyDefaultsForUpsert(schema, {}, update);
+
assertEquals(result.$setOnInsert?.flag, false);
+
assertEquals(result.$setOnInsert?.count, 0);
+
sanitizeResources: false,
+
name: "Defaults: applyDefaultsForUpsert keeps query equality fields untouched",
+
const schema = z.object({
+
status: z.string().default("pending"),
+
flag: z.boolean().default(true),
+
const query = { status: "queued" };
+
const update = { $set: { name: "upsert-test" } };
+
const result = applyDefaultsForUpsert(schema, query, update);
+
assertEquals(result.$setOnInsert?.status, undefined);
+
assertEquals(result.$setOnInsert?.flag, true);
+
sanitizeResources: false,
knotbin.com