feathers-adapter-vitest 0.0.2

package/src/methods.ts

@@ -0,0 +1,887 @@
+import assert from 'node:assert'
+import type { AdapterMethodsTest } from './declarations.js'
+import { describe, beforeEach, afterEach, beforeAll } from 'vitest'
+import type { Application } from '@feathersjs/feathers'
+
+type MethodTestOptions = {
+  app: Application
+  test: AdapterMethodsTest
+  serviceName: string
+  idProp: string
+}
+
+export default (options: MethodTestOptions) => {
+  const { test, app, serviceName, idProp } = options
+
+  describe(' Methods', () => {
+    let doug: any
+    let service: any
+
+    beforeEach(async () => {
+      service = app.service(serviceName)
+      doug = await app.service(serviceName).create({
+        name: 'Doug',
+        age: 32,
+      })
+    })
+
+    afterEach(async () => {
+      try {
+        await app.service(serviceName).remove(doug[idProp])
+      } catch {
+        // Ignore errors
+      }
+    })
+
+    describe('get', () => {
+      test('.get', async () => {
+        const data = await service.get(doug[idProp])
+
+        assert.strictEqual(
+          data[idProp].toString(),
+          doug[idProp].toString(),
+          `${idProp} id matches`,
+        )
+        assert.strictEqual(data.name, 'Doug', 'data.name matches')
+        assert.strictEqual(data.age, 32, 'data.age matches')
+      })
+
+      test('.get + $select', async () => {
+        const data = await service.get(doug[idProp], {
+          query: { $select: ['name'] },
+        })
+
+        assert.strictEqual(
+          data[idProp].toString(),
+          doug[idProp].toString(),
+          `${idProp} id property matches`,
+        )
+        assert.strictEqual(data.name, 'Doug', 'data.name matches')
+        assert.ok(!data.age, 'data.age is falsy')
+      })
+
+      test('.get + id + query', async () => {
+        try {
+          await service.get(doug[idProp], {
+            query: { name: 'Tester' },
+          })
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'NotFound',
+            'Got a NotFound Feathers error',
+          )
+        }
+      })
+
+      test('.get + NotFound', async () => {
+        try {
+          await service.get('568225fbfe21222432e836ff')
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'NotFound',
+            'Error is a NotFound Feathers error',
+          )
+        }
+      })
+
+      test('.get + id + query id', async () => {
+        const alice = await service.create({
+          name: 'Alice',
+          age: 12,
+        })
+
+        try {
+          await service.get(doug[idProp], {
+            query: { [idProp]: alice[idProp] },
+          })
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'NotFound',
+            'Got a NotFound Feathers error',
+          )
+        }
+
+        await service.remove(alice[idProp])
+      })
+    })
+
+    describe('find', () => {
+      test('.find', async () => {
+        const data = await service.find()
+
+        assert.ok(Array.isArray(data), 'Data is an array')
+        assert.strictEqual(data.length, 1, 'Got one entry')
+      })
+    })
+
+    describe('remove', () => {
+      test('.remove', async () => {
+        const data = await service.remove(doug[idProp])
+
+        assert.strictEqual(data.name, 'Doug', 'data.name matches')
+      })
+
+      test('.remove + $select', async () => {
+        const data = await service.remove(doug[idProp], {
+          query: { $select: ['name'] },
+        })
+
+        assert.strictEqual(
+          data[idProp].toString(),
+          doug[idProp].toString(),
+          `${idProp} id property matches`,
+        )
+        assert.strictEqual(data.name, 'Doug', 'data.name matches')
+        assert.ok(!data.age, 'data.age is falsy')
+      })
+
+      test('.remove + id + query', async () => {
+        try {
+          await service.remove(doug[idProp], {
+            query: { name: 'Tester' },
+          })
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'NotFound',
+            'Got a NotFound Feathers error',
+          )
+        }
+      })
+
+      test('.remove + multi', async () => {
+        try {
+          await service.remove(null)
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'MethodNotAllowed',
+            'Removing multiple without option set throws MethodNotAllowed',
+          )
+        }
+
+        service.options.multi = ['remove']
+
+        await service.create({ name: 'Dave', age: 29, created: true })
+        await service.create({
+          name: 'David',
+          age: 3,
+          created: true,
+        })
+
+        const data = await service.remove(null, {
+          query: { created: true },
+        })
+
+        assert.strictEqual(data.length, 2)
+
+        const names = data.map((person: any) => person.name)
+
+        assert.ok(names.includes('Dave'), 'Dave removed')
+        assert.ok(names.includes('David'), 'David removed')
+      })
+
+      test('.remove + multi no pagination', async () => {
+        try {
+          await service.remove(doug[idProp])
+        } catch {
+          // Ignore errors
+        }
+
+        const count = 14
+        const defaultPaginate = 10
+
+        assert.ok(
+          count > defaultPaginate,
+          'count is bigger than default pagination',
+        )
+
+        const multiBefore = service.options.multi
+        const paginateBefore = service.options.paginate
+
+        try {
+          service.options.multi = true
+          service.options.paginate = {
+            default: defaultPaginate,
+            max: 100,
+          }
+
+          const emptyItems = await service.find({ paginate: false })
+          assert.strictEqual(emptyItems.length, 0, 'no items before')
+
+          const createdItems = await service.create(
+            Array.from(Array(count)).map((_, i) => ({
+              name: `name-${i}`,
+              age: 3,
+              created: true,
+            })),
+          )
+          assert.strictEqual(
+            createdItems.length,
+            count,
+            `created ${count} items`,
+          )
+
+          const foundItems = await service.find({ paginate: false })
+          assert.strictEqual(foundItems.length, count, `created ${count} items`)
+
+          const foundPaginatedItems = await service.find({})
+          assert.strictEqual(
+            foundPaginatedItems.data.length,
+            defaultPaginate,
+            'found paginated items',
+          )
+
+          const allItems = await service.remove(null, {
+            query: { created: true },
+          })
+
+          assert.strictEqual(
+            allItems.length,
+            count,
+            `removed all ${count} items`,
+          )
+        } finally {
+          await service.remove(null, {
+            query: { created: true },
+            paginate: false,
+          })
+
+          service.options.multi = multiBefore
+          service.options.paginate = paginateBefore
+        }
+      })
+
+      test('.remove + id + query id', async () => {
+        const alice = await service.create({
+          name: 'Alice',
+          age: 12,
+        })
+
+        try {
+          await service.remove(doug[idProp], {
+            query: { [idProp]: alice[idProp] },
+          })
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'NotFound',
+            'Got a NotFound Feathers error',
+          )
+        }
+
+        await service.remove(alice[idProp])
+      })
+    })
+
+    describe('update', () => {
+      test('.update', async () => {
+        const originalData = { [idProp]: doug[idProp], name: 'Dougler' }
+        const originalCopy = Object.assign({}, originalData)
+
+        const data = await service.update(doug[idProp], originalData)
+
+        assert.deepStrictEqual(
+          originalData,
+          originalCopy,
+          'data was not modified',
+        )
+        assert.strictEqual(
+          data[idProp].toString(),
+          doug[idProp].toString(),
+          `${idProp} id matches`,
+        )
+        assert.strictEqual(data.name, 'Dougler', 'data.name matches')
+        assert.ok(!data.age, 'data.age is falsy')
+      })
+
+      test('.update + $select', async () => {
+        const originalData = {
+          [idProp]: doug[idProp],
+          name: 'Dougler',
+          age: 10,
+        }
+
+        const data = await service.update(doug[idProp], originalData, {
+          query: { $select: ['name'] },
+        })
+
+        assert.strictEqual(
+          data[idProp].toString(),
+          doug[idProp].toString(),
+          `${idProp} id property matches`,
+        )
+        assert.strictEqual(data.name, 'Dougler', 'data.name matches')
+        assert.ok(!data.age, 'data.age is falsy')
+      })
+
+      test('.update + id + query', async () => {
+        try {
+          await service.update(
+            doug[idProp],
+            {
+              name: 'Dougler',
+            },
+            {
+              query: { name: 'Tester' },
+            },
+          )
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'NotFound',
+            'Got a NotFound Feathers error',
+          )
+        }
+      })
+
+      test('.update + NotFound', async () => {
+        try {
+          await service.update('568225fbfe21222432e836ff', {
+            name: 'NotFound',
+          })
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'NotFound',
+            'Error is a NotFound Feathers error',
+          )
+        }
+      })
+
+      test('.update + query + NotFound', async () => {
+        const dave = await service.create({ name: 'Dave' })
+        try {
+          await service.update(
+            dave[idProp],
+            { name: 'UpdatedDave' },
+            { query: { name: 'NotDave' } },
+          )
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'NotFound',
+            'Error is a NotFound Feathers error',
+          )
+        }
+        await service.remove(dave[idProp])
+      })
+
+      test('.update + id + query id', async () => {
+        const alice = await service.create({
+          name: 'Alice',
+          age: 12,
+        })
+
+        try {
+          await service.update(
+            doug[idProp],
+            {
+              name: 'Dougler',
+              age: 33,
+            },
+            {
+              query: { [idProp]: alice[idProp] },
+            },
+          )
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'NotFound',
+            'Got a NotFound Feathers error',
+          )
+        }
+
+        await service.remove(alice[idProp])
+      })
+    })
+
+    describe('patch', () => {
+      test('.patch', async () => {
+        const originalData = { [idProp]: doug[idProp], name: 'PatchDoug' }
+        const originalCopy = Object.assign({}, originalData)
+
+        const data = await service.patch(doug[idProp], originalData)
+
+        assert.deepStrictEqual(
+          originalData,
+          originalCopy,
+          'original data was not modified',
+        )
+        assert.strictEqual(
+          data[idProp].toString(),
+          doug[idProp].toString(),
+          `${idProp} id matches`,
+        )
+        assert.strictEqual(data.name, 'PatchDoug', 'data.name matches')
+        assert.strictEqual(data.age, 32, 'data.age matches')
+      })
+
+      test('.patch + $select', async () => {
+        const originalData = { [idProp]: doug[idProp], name: 'PatchDoug' }
+
+        const data = await service.patch(doug[idProp], originalData, {
+          query: { $select: ['name'] },
+        })
+
+        assert.strictEqual(
+          data[idProp].toString(),
+          doug[idProp].toString(),
+          `${idProp} id property matches`,
+        )
+        assert.strictEqual(data.name, 'PatchDoug', 'data.name matches')
+        assert.ok(!data.age, 'data.age is falsy')
+      })
+
+      test('.patch + id + query', async () => {
+        try {
+          await service.patch(
+            doug[idProp],
+            {
+              name: 'id patched doug',
+            },
+            {
+              query: { name: 'Tester' },
+            },
+          )
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'NotFound',
+            'Got a NotFound Feathers error',
+          )
+        }
+      })
+
+      test('.patch multiple', async () => {
+        try {
+          await service.patch(null, {})
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'MethodNotAllowed',
+            'Removing multiple without option set throws MethodNotAllowed',
+          )
+        }
+
+        const params = {
+          query: { created: true },
+        }
+        const dave = await service.create({
+          name: 'Dave',
+          age: 29,
+          created: true,
+        })
+        const david = await service.create({
+          name: 'David',
+          age: 3,
+          created: true,
+        })
+
+        service.options.multi = ['patch']
+
+        const data = await service.patch(
+          null,
+          {
+            age: 2,
+          },
+          params,
+        )
+
+        assert.strictEqual(data.length, 2, 'returned two entries')
+        assert.strictEqual(data[0].age, 2, 'First entry age was updated')
+        assert.strictEqual(data[1].age, 2, 'Second entry age was updated')
+
+        await service.remove(dave[idProp])
+        await service.remove(david[idProp])
+      })
+
+      test('.patch multiple no pagination', async () => {
+        try {
+          await service.remove(doug[idProp])
+        } catch {
+          // Ignore errors
+        }
+
+        const count = 14
+        const defaultPaginate = 10
+
+        assert.ok(
+          count > defaultPaginate,
+          'count is bigger than default pagination',
+        )
+
+        const multiBefore = service.options.multi
+        const paginateBefore = service.options.paginate
+
+        let ids: any[] | undefined = undefined
+
+        try {
+          service.options.multi = true
+          service.options.paginate = {
+            default: defaultPaginate,
+            max: 100,
+          }
+
+          const emptyItems = await service.find({ paginate: false })
+          assert.strictEqual(emptyItems.length, 0, 'no items before')
+
+          const createdItems = await service.create(
+            Array.from(Array(count)).map((_, i) => ({
+              name: `name-${i}`,
+              age: 3,
+              created: true,
+            })),
+          )
+          assert.strictEqual(
+            createdItems.length,
+            count,
+            `created ${count} items`,
+          )
+          ids = createdItems.map((item: any) => item[idProp])
+
+          const foundItems = await service.find({ paginate: false })
+          assert.strictEqual(foundItems.length, count, `created ${count} items`)
+
+          const foundPaginatedItems = await service.find({})
+          assert.strictEqual(
+            foundPaginatedItems.data.length,
+            defaultPaginate,
+            'found paginated data',
+          )
+
+          const allItems = await service.patch(
+            null,
+            { age: 4 },
+            { query: { created: true } },
+          )
+
+          assert.strictEqual(
+            allItems.length,
+            count,
+            `patched all ${count} items`,
+          )
+        } finally {
+          service.options.multi = multiBefore
+          service.options.paginate = paginateBefore
+          if (ids) {
+            await Promise.all(ids.map((id) => service.remove(id)))
+          }
+        }
+      })
+
+      test('.patch multi query same', async () => {
+        const service = app.service(serviceName)
+        // @ts-expect-error options may not exist
+        const multiBefore = service.options?.multi
+
+        // @ts-expect-error options may not exist
+        service.options ??= {}
+
+        // @ts-expect-error options may not exist
+        service.options.multi = true
+
+        const params = {
+          query: { age: { $lt: 10 } },
+        }
+        const dave = await service.create({
+          name: 'Dave',
+          age: 8,
+          created: true,
+        })
+        const david = await service.create({
+          name: 'David',
+          age: 4,
+          created: true,
+        })
+
+        const data = await service.patch(
+          null,
+          {
+            age: 2,
+          },
+          params,
+        )
+
+        assert.strictEqual(data.length, 2, 'returned two entries')
+        assert.strictEqual(data[0].age, 2, 'First entry age was updated')
+        assert.strictEqual(data[1].age, 2, 'Second entry age was updated')
+
+        await service.remove(dave[idProp])
+        await service.remove(david[idProp])
+
+        // @ts-expect-error options may not exist
+        service.options.multi = multiBefore
+      })
+
+      test('.patch multi query changed', async () => {
+        const service = app.service(serviceName)
+        // @ts-expect-error options may not exist
+        const multiBefore = service.options.multi
+
+        // @ts-expect-error options may not exist
+        service.options.multi = true
+
+        const params = {
+          query: { age: 10 },
+        }
+        const dave = await service.create({
+          name: 'Dave',
+          age: 10,
+          created: true,
+        })
+        const david = await service.create({
+          name: 'David',
+          age: 10,
+          created: true,
+        })
+
+        const data = await service.patch(
+          null,
+          {
+            age: 2,
+          },
+          params,
+        )
+
+        assert.strictEqual(data.length, 2, 'returned two entries')
+        assert.strictEqual(data[0].age, 2, 'First entry age was updated')
+        assert.strictEqual(data[1].age, 2, 'Second entry age was updated')
+
+        await service.remove(dave[idProp])
+        await service.remove(david[idProp])
+
+        // @ts-expect-error options may not exist
+        service.options.multi = multiBefore
+      })
+
+      test('.patch + NotFound', async () => {
+        try {
+          await service.patch('568225fbfe21222432e836ff', {
+            name: 'PatchDoug',
+          })
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'NotFound',
+            'Error is a NotFound Feathers error',
+          )
+        }
+      })
+
+      test('.patch + query + NotFound', async () => {
+        const dave = await service.create({ name: 'Dave' })
+        try {
+          await service.patch(
+            dave[idProp],
+            { name: 'PatchedDave' },
+            { query: { name: 'NotDave' } },
+          )
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'NotFound',
+            'Error is a NotFound Feathers error',
+          )
+        }
+        await service.remove(dave[idProp])
+      })
+
+      test('.patch + id + query id', async () => {
+        const alice = await service.create({
+          name: 'Alice',
+          age: 12,
+        })
+
+        try {
+          await service.patch(
+            doug[idProp],
+            {
+              age: 33,
+            },
+            {
+              query: { [idProp]: alice[idProp] },
+            },
+          )
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'NotFound',
+            'Got a NotFound Feathers error',
+          )
+        }
+
+        await service.remove(alice[idProp])
+      })
+    })
+
+    describe('create', () => {
+      test('.create', async () => {
+        const originalData = {
+          name: 'Bill',
+          age: 40,
+        }
+        const originalCopy = Object.assign({}, originalData)
+
+        const data = await service.create(originalData)
+
+        assert.deepStrictEqual(
+          originalData,
+          originalCopy,
+          'original data was not modified',
+        )
+        assert.ok(data instanceof Object, 'data is an object')
+        assert.strictEqual(data.name, 'Bill', 'data.name matches')
+
+        await service.remove(data[idProp])
+      })
+
+      test('.create ignores query', async () => {
+        const originalData = {
+          name: 'Billy',
+          age: 42,
+        }
+        const data = await service.create(originalData, {
+          query: {
+            name: 'Dave',
+          },
+        })
+
+        assert.strictEqual(data.name, 'Billy', 'data.name matches')
+
+        await service.remove(data[idProp])
+      })
+
+      test('.create + $select', async () => {
+        const originalData = {
+          name: 'William',
+          age: 23,
+        }
+
+        const data = await service.create(originalData, {
+          query: { $select: ['name'] },
+        })
+
+        assert.ok(idProp in data, 'data has id')
+        assert.strictEqual(data.name, 'William', 'data.name matches')
+        assert.ok(!data.age, 'data.age is falsy')
+
+        await service.remove(data[idProp])
+      })
+
+      test('.create multi', async () => {
+        try {
+          await service.create([], {})
+          throw new Error('Should never get here')
+        } catch (error: any) {
+          assert.strictEqual(
+            error.name,
+            'MethodNotAllowed',
+            'Removing multiple without option set throws MethodNotAllowed',
+          )
+        }
+
+        const items = [
+          {
+            name: 'Gerald',
+            age: 18,
+          },
+          {
+            name: 'Herald',
+            age: 18,
+          },
+        ]
+
+        service.options.multi = ['create', 'patch']
+
+        const data = await service.create(items)
+
+        assert.ok(Array.isArray(data), 'data is an array')
+        assert.ok(typeof data[0][idProp] !== 'undefined', 'id is set')
+        assert.strictEqual(data[0].name, 'Gerald', 'first name matches')
+        assert.ok(typeof data[1][idProp] !== 'undefined', 'id is set')
+        assert.strictEqual(data[1].name, 'Herald', 'second name macthes')
+
+        await service.remove(data[0][idProp])
+        await service.remove(data[1][idProp])
+      })
+    })
+
+    describe("doesn't call public methods internally", () => {
+      let throwing: any
+
+      beforeAll(() => {
+        throwing = Object.assign(Object.create(app.service(serviceName)), {
+          get store() {
+            // @ts-expect-error just ignore it for now
+            return app.service(serviceName).store
+          },
+
+          find() {
+            throw new Error('find method called')
+          },
+          get() {
+            throw new Error('get method called')
+          },
+          create() {
+            throw new Error('create method called')
+          },
+          update() {
+            throw new Error('update method called')
+          },
+          patch() {
+            throw new Error('patch method called')
+          },
+          remove() {
+            throw new Error('remove method called')
+          },
+        })
+      })
+
+      test('internal .find', () =>
+        (app as any).service(serviceName).find.call(throwing))
+
+      test('internal .get', () => service.get.call(throwing, doug[idProp]))
+
+      test('internal .create', async () => {
+        const bob = await service.create.call(throwing, {
+          name: 'Bob',
+          age: 25,
+        })
+
+        await service.remove(bob[idProp])
+      })
+
+      test('internal .update', () =>
+        service.update.call(throwing, doug[idProp], {
+          name: 'Dougler',
+        }))
+
+      test('internal .patch', () =>
+        service.patch.call(throwing, doug[idProp], {
+          name: 'PatchDoug',
+        }))
+
+      test('internal .remove', () =>
+        service.remove.call(throwing, doug[idProp]))
+    })
+  })
+}