ts-patch-mongoose 3.1.0 → 4.0.0

package/tests/plugin-event-created.test.ts

@@ -1,371 +0,0 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
-
-import mongoose, { model, Types } from 'mongoose'
-import em from '../src/em'
-import { patchHistoryPlugin } from '../src/index'
-import { HistoryModel } from '../src/model'
-import { isMongooseLessThan7 } from '../src/version'
-import { USER_CREATED } from './constants/events'
-import server from './mongo/server'
-import { type User, UserSchema } from './schemas/User'
-
-vi.mock('../src/em', () => ({ default: { emit: vi.fn((event: string, data: Record<string, unknown>) => console.log(event, data)) } }))
-
-describe('plugin - event created & patch history disabled', () => {
-  const instance = server('plugin-event-created')
-
-  UserSchema.plugin(patchHistoryPlugin, {
-    eventCreated: USER_CREATED,
-    patchHistoryDisabled: true,
-  })
-
-  const UserModel = model<User>('User', UserSchema)
-
-  beforeAll(async () => {
-    await instance.create()
-  })
-
-  afterAll(async () => {
-    await instance.destroy()
-  })
-
-  beforeEach(async () => {
-    await mongoose.connection.collection('users').deleteMany({})
-    await mongoose.connection.collection('history').deleteMany({})
-  })
-
-  afterEach(() => {
-    vi.resetAllMocks()
-  })
-
-  describe('normal cases', () => {
-    it('should save() and emit one create event', async () => {
-      const john = new UserModel({ name: 'John', role: 'user' })
-      await john.save()
-
-      const history = await HistoryModel.find({})
-      expect(history).toHaveLength(0)
-
-      expect(em.emit).toHaveBeenCalledOnce()
-      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
-        doc: expect.objectContaining({
-          _id: john._id,
-          name: john.name,
-          role: john.role,
-          createdAt: john.createdAt,
-          updatedAt: john.updatedAt,
-        }),
-      })
-
-      // Check if the document is saved
-      const found = await UserModel.findOne({})
-      expect(found).not.toBeNull()
-      expect(found?.name).toBe('John')
-      expect(found?.role).toBe('user')
-    })
-
-    it('should create() and emit one create event', async () => {
-      const user = await UserModel.create({ name: 'John', role: 'user' })
-
-      const history = await HistoryModel.find({})
-      expect(history).toHaveLength(0)
-
-      expect(em.emit).toHaveBeenCalledOnce()
-      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
-        doc: expect.objectContaining({
-          _id: user._id,
-          name: user.name,
-          role: user.role,
-          createdAt: user.createdAt,
-          updatedAt: user.updatedAt,
-        }),
-      })
-
-      // Check if the document is saved
-      const found = await UserModel.findOne({})
-      expect(found).not.toBeNull()
-      expect(found?.name).toBe('John')
-      expect(found?.role).toBe('user')
-    })
-
-    it('should insertMany() and emit three create events', async () => {
-      const users = await UserModel.insertMany(
-        [
-          { name: 'John', role: 'user' },
-          { name: 'Alice', role: 'user' },
-          { name: 'Bob', role: 'user' },
-        ],
-        { ordered: true },
-      )
-
-      const [john, alice, bob] = users
-
-      const history = await HistoryModel.find({})
-      expect(history).toHaveLength(0)
-
-      expect(em.emit).toHaveBeenCalledTimes(3)
-      expect(em.emit).toHaveBeenNthCalledWith(1, USER_CREATED, {
-        doc: expect.objectContaining({
-          _id: john._id,
-          name: john.name,
-          role: john.role,
-          createdAt: john.createdAt,
-          updatedAt: john.updatedAt,
-        }),
-      })
-      expect(em.emit).toHaveBeenNthCalledWith(2, USER_CREATED, {
-        doc: expect.objectContaining({
-          _id: alice._id,
-          name: alice.name,
-          role: alice.role,
-          createdAt: alice.createdAt,
-          updatedAt: alice.updatedAt,
-        }),
-      })
-      expect(em.emit).toHaveBeenNthCalledWith(3, USER_CREATED, {
-        doc: expect.objectContaining({
-          _id: bob._id,
-          name: bob.name,
-          role: bob.role,
-          createdAt: bob.createdAt,
-          updatedAt: bob.updatedAt,
-        }),
-      })
-
-      // Check if the documents are saved
-      const found = await UserModel.find({})
-      expect(found).toHaveLength(3)
-
-      const [foundJohn, foundAlice, foundBob] = found
-
-      expect(foundJohn.name).toBe('John')
-      expect(foundJohn.role).toBe('user')
-
-      expect(foundAlice.name).toBe('Alice')
-      expect(foundAlice.role).toBe('user')
-
-      expect(foundBob.name).toBe('Bob')
-      expect(foundBob.role).toBe('user')
-    })
-  })
-
-  describe('upsert cases', () => {
-    it('should update() + upsert and emit one create event', async () => {
-      if (isMongooseLessThan7) {
-        // @ts-expect-error update() not available in Mongoose v6 and below
-        await UserModel.update({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
-      } else {
-        await UserModel.findOneAndUpdate({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
-      }
-
-      const user = await UserModel.findOne({ name: 'John', role: 'admin' })
-      expect(user).not.toBeNull()
-
-      const history = await HistoryModel.find({})
-      expect(history).toHaveLength(0)
-
-      expect(em.emit).toHaveBeenCalledOnce()
-      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
-        doc: expect.objectContaining({
-          _id: user?._id,
-          name: user?.name,
-          role: user?.role,
-          // Upsert does not set createdAt and updatedAt
-        }),
-      })
-
-      // Check if the document is saved
-      const found = await UserModel.findOne({})
-      expect(found).not.toBeNull()
-      expect(found?.name).toBe('John')
-      expect(found?.role).toBe('admin')
-    })
-
-    it('should updateOne() + upsert and emit one create event', async () => {
-      await UserModel.updateOne({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
-
-      const user = await UserModel.findOne({ name: 'John', role: 'admin' })
-      expect(user).not.toBeNull()
-
-      const history = await HistoryModel.find({})
-      expect(history).toHaveLength(0)
-
-      expect(em.emit).toHaveBeenCalledOnce()
-      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
-        doc: expect.objectContaining({
-          _id: user?._id,
-          name: user?.name,
-          role: user?.role,
-          // Upsert does not set createdAt and updatedAt
-        }),
-      })
-
-      // Check if the document is saved
-      const found = await UserModel.findOne({})
-      expect(found).not.toBeNull()
-      expect(found?.name).toBe('John')
-      expect(found?.role).toBe('admin')
-    })
-
-    it('should replaceOne() + upsert and emit one create event', async () => {
-      await UserModel.replaceOne({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
-
-      const user = await UserModel.findOne({ name: 'John', role: 'admin' })
-      expect(user).not.toBeNull()
-
-      const history = await HistoryModel.find({})
-      expect(history).toHaveLength(0)
-
-      expect(em.emit).toHaveBeenCalledOnce()
-      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
-        doc: expect.objectContaining({
-          _id: user?._id,
-          name: user?.name,
-          role: user?.role,
-          // Upsert does not set createdAt and updatedAt
-        }),
-      })
-
-      // Check if the document is saved
-      const found = await UserModel.findOne({})
-      expect(found).not.toBeNull()
-      expect(found?.name).toBe('John')
-      expect(found?.role).toBe('admin')
-    })
-
-    it('should updateMany() + upsert and emit one create event', async () => {
-      await UserModel.updateMany({ name: { $in: ['John', 'Alice', 'Bob'] } }, { name: 'Steve', role: 'admin' }, { upsert: true })
-
-      const users = await UserModel.findOne({ name: 'Steve', role: 'admin' })
-
-      const history = await HistoryModel.find({})
-      expect(history).toHaveLength(0)
-
-      expect(em.emit).toHaveBeenCalledOnce()
-      expect(em.emit).toHaveBeenNthCalledWith(1, USER_CREATED, {
-        doc: expect.objectContaining({
-          _id: users?._id,
-          name: users?.name,
-          role: users?.role,
-          // Upsert does not set createdAt and updatedAt
-        }),
-      })
-
-      // Check if the document is saved
-      const found = await UserModel.findById(users?._id)
-      expect(found).not.toBeNull()
-      expect(found?.name).toBe('Steve')
-      expect(found?.role).toBe('admin')
-    })
-
-    it('should findOneAndUpdate() + upsert and emit one create event', async () => {
-      await UserModel.findOneAndUpdate({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
-
-      const user = await UserModel.findOne({ name: 'John', role: 'admin' })
-      expect(user).not.toBeNull()
-
-      const history = await HistoryModel.find({})
-      expect(history).toHaveLength(0)
-
-      expect(em.emit).toHaveBeenCalledOnce()
-      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
-        doc: expect.objectContaining({
-          _id: user?._id,
-          name: user?.name,
-          role: user?.role,
-          // Upsert does not set createdAt and updatedAt
-        }),
-      })
-
-      // Check if the document is saved
-      const found = await UserModel.findOne({})
-      expect(found).not.toBeNull()
-      expect(found?.name).toBe('John')
-      expect(found?.role).toBe('admin')
-    })
-
-    it('should findOneAndReplace() + upsert and emit one create event', async () => {
-      await UserModel.findOneAndReplace({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
-
-      const user = await UserModel.findOne({ name: 'John', role: 'admin' })
-      expect(user).not.toBeNull()
-
-      const history = await HistoryModel.find({})
-      expect(history).toHaveLength(0)
-
-      expect(em.emit).toHaveBeenCalledOnce()
-      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
-        doc: expect.objectContaining({
-          _id: user?._id,
-          name: user?.name,
-          role: user?.role,
-          // Upsert does not set createdAt and updatedAt
-        }),
-      })
-
-      // Check if the document is saved
-      const found = await UserModel.findOne({})
-      expect(found).not.toBeNull()
-      expect(found?.name).toBe('John')
-      expect(found?.role).toBe('admin')
-    })
-
-    it('should findByIdAndUpdate() + upsert and emit one create event', async () => {
-      const _id = new Types.ObjectId()
-      await UserModel.findByIdAndUpdate(_id, { name: 'John', role: 'admin' }, { upsert: true })
-
-      const user = await UserModel.findOne({ name: 'John', role: 'admin' })
-      expect(user).not.toBeNull()
-
-      const history = await HistoryModel.find({})
-      expect(history).toHaveLength(0)
-
-      expect(em.emit).toHaveBeenCalledOnce()
-      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
-        doc: expect.objectContaining({
-          _id: user?._id,
-          name: user?.name,
-          role: user?.role,
-        }),
-      })
-
-      // Check if the document is saved
-      const found = await UserModel.findOne({})
-      expect(found).not.toBeNull()
-      expect(found?.name).toBe('John')
-      expect(found?.role).toBe('admin')
-    })
-
-    it('should findOneAndUpdate() with $set + upsert and emit one create event', async () => {
-      const _id = new Types.ObjectId()
-      const john = await UserModel.create({ _id, name: 'John', role: 'admin' })
-
-      if (isMongooseLessThan7) {
-        // @ts-expect-error update() not available in Mongoose v6 and below
-        await UserModel.update({ name: 'Alex', role: 'user' }, { $set: { name: 'Alex', role: 'user' } }, { upsert: true, setDefaultsOnInsert: false, overwriteDiscriminatorKey: true }).exec()
-      } else {
-        await UserModel.findOneAndUpdate({ name: 'Alex', role: 'user' }, { $set: { name: 'Alex', role: 'user' } }, { upsert: true, setDefaultsOnInsert: false, overwriteDiscriminatorKey: true }).exec()
-      }
-
-      const alex = await UserModel.findOne({ name: 'Alex', role: 'user' })
-      expect(alex).not.toBeNull()
-
-      const history = await HistoryModel.find({})
-      expect(history).toHaveLength(0)
-
-      expect(em.emit).toHaveBeenCalledTimes(2)
-      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
-        doc: expect.objectContaining({
-          name: john?.name,
-          role: john?.role,
-        }),
-      })
-      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
-        doc: expect.objectContaining({
-          name: alex?.name,
-          role: alex?.role,
-        }),
-      })
-    })
-  })
-})