coh-content-db 2.0.0-rc.10 → 2.0.0-rc.12

package/src/test/db/badge-index.test.ts

@@ -53,7 +53,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'miss-1', name: [{ value: 'Bar 4' }] })),
         ])
 
-        const result = index.search({ query: { str: 'Foo', on: { name: true } } })
+        const result = index.search({ query: { str: 'Foo', fields: ['name'] } })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['match-1', 'match-2', 'match-3'])
       })
@@ -67,7 +67,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'miss-2', badgeText: undefined })),
         ])
 
-        const result = index.search({ query: { str: 'Foo', on: { badgeText: true } } })
+        const result = index.search({ query: { str: 'Foo', fields: ['badge-text'] } })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['match-1', 'match-2', 'match-3'])
       })
@@ -80,7 +80,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'miss-2', acquisition: undefined })),
         ])
 
-        const result = index.search({ query: { str: 'Foo', on: { acquisition: true } } })
+        const result = index.search({ query: { str: 'Foo', fields: ['acquisition'] } })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['match-1', 'match-2'])
       })
@@ -93,7 +93,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'miss-2', effect: undefined })),
         ])
 
-        const result = index.search({ query: { str: 'Foo', on: { effect: true } } })
+        const result = index.search({ query: { str: 'Foo', fields: ['effect'] } })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['match-1', 'match-2'])
       })
@@ -106,7 +106,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'miss-2', notes: undefined })),
         ])
 
-        const result = index.search({ query: { str: 'Foo', on: { notes: true } } })
+        const result = index.search({ query: { str: 'Foo', fields: ['notes'] } })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['match-1', 'match-2'])
       })
@@ -119,7 +119,22 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'miss-2', setTitleId: undefined })),
         ])
 
-        const result = index.search({ query: { str: '123', on: { setTitle: true } } })
+        const result = index.search({ query: { str: '123', fields: ['set-title-id'] } })
+
+        expect(result.items).toHaveLength(2)
+        const keys = result.items.map(x => x.key)
+        expect(keys).toStrictEqual(['match-1', 'match-2'])
+      })
+
+      test(`should match on multiple fields`, () => {
+        const index = new BadgeIndex([
+          new Badge(badgeDataFixture.create({ key: 'match-1', name: 'foo' })),
+          new Badge(badgeDataFixture.create({ key: 'match-2', notes: 'foo' })),
+          new Badge(badgeDataFixture.create({ key: 'miss-1', name: 'bar' })),
+          new Badge(badgeDataFixture.create({ key: 'miss-2', notes: 'bar' })),
+        ])
+
+        const result = index.search({ query: { str: 'foo', fields: ['name', 'notes'] } })
 
         expect(result.items).toHaveLength(2)
         const keys = result.items.map(x => x.key)
@@ -133,7 +148,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'miss-1', acquisition: 'Bar 1' })),
         ])
 
-        const result = index.search({ query: { str: 'Fo', on: { acquisition: true } } })
+        const result = index.search({ query: { str: 'Fo', fields: ['acquisition'] } })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['match-1', 'match-2'])
       })
@@ -145,7 +160,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'miss-1', acquisition: 'Bar 1' })),
         ])
 
-        const result = index.search({ query: { str: 'foo', on: { acquisition: true } } })
+        const result = index.search({ query: { str: 'foo', fields: ['acquisition'] } })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['match-1', 'match-2'])
       })
@@ -162,6 +177,19 @@ describe(BadgeIndex.name, () => {
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['match-1'])
       })
+
+      test(`should return everything if no query fields are set`, () => {
+        const index = new BadgeIndex([
+          new Badge(badgeDataFixture.create({ key: 'match-1', name: [{ value: 'Foo 1' }] })),
+          new Badge(badgeDataFixture.create({ key: 'match-2', acquisition: 'Foo 2' })),
+          new Badge(badgeDataFixture.create({ key: 'match-3', name: [{ value: 'Bar 1' }] })),
+        ])
+
+        const result = index.search({ query: { str: 'no-hit', fields: [] } })
+
+        const keys = result.items.map(x => x.key)
+        expect(keys).toStrictEqual(['match-1', 'match-2', 'match-3'])
+      })
     })
 
     describe('filter', () => {
@@ -514,6 +542,30 @@ describe(BadgeIndex.name, () => {
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-5', 'badge-1', 'badge-3', 'badge-2', 'badge-4'])
       })
+
+      test(`should sort by release date`, () => {
+        const index = new BadgeIndex([
+          new Badge(badgeDataFixture.create({ key: 'badge-1', releaseDate: '2025-02-03' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-2', releaseDate: '2025-02-03' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-3', releaseDate: '2020-01-01' })),
+        ])
+
+        const result = index.search({ sort: { by: 'release-date' } })
+        const keys = result.items.map(x => x.key)
+        expect(keys).toStrictEqual(['badge-3', 'badge-1', 'badge-2'])
+      })
+
+      test(`should sort by release date descending`, () => {
+        const index = new BadgeIndex([
+          new Badge(badgeDataFixture.create({ key: 'badge-1', releaseDate: '2025-02-03' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-2', releaseDate: '2020-01-01' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-3', releaseDate: '2025-02-03' })),
+        ])
+
+        const result = index.search({ sort: { by: 'release-date', dir: 'desc' } })
+        const keys = result.items.map(x => x.key)
+        expect(keys).toStrictEqual(['badge-1', 'badge-3', 'badge-2'])
+      })
     })
   })
 })

package/src/test/db/badge.test.ts

@@ -1,4 +1,4 @@
-import { Badge, compareByDefaultName, compareByZoneKey } from '../../main'
+import { Badge, compareByDefaultName, compareByReleaseDate, compareByZoneKey } from '../../main'
 import { badgeDataFixture } from '../api/badge-data.fixture'
 import { badgeRequirementDataFixture } from '../api/badge-requirement-data.fixture'
 
@@ -28,6 +28,18 @@ describe(Badge.name, () => {
       const badge = new Badge(badgeDataFixture.create({ name: [{ value: 'foo' }] }))
       expect(badge.name.default).toEqual({ value: 'foo' })
     })
+
+    test('should accept a string', () => {
+      const badge = new Badge(badgeDataFixture.create({ name: 'foo' }))
+      expect(badge.name.default).toEqual({ value: 'foo' })
+    })
+  })
+
+  describe('releaseDate', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ releaseDate: '2025-08-08' }))
+      expect(badge.releaseDate).toEqual(new Date('2025-08-08'))
+    })
   })
 
   describe('morality', () => {
@@ -55,6 +67,11 @@ describe(Badge.name, () => {
       expect(badge.badgeText.default).toEqual({ value: 'foo' })
     })
 
+    test('should accept a string', () => {
+      const badge = new Badge(badgeDataFixture.create({ badgeText: 'foo' }))
+      expect(badge.badgeText.default).toEqual({ value: 'foo' })
+    })
+
     test('should be optional', () => {
       const badge = new Badge(badgeDataFixture.omit('badgeText').create())
       expect(badge.badgeText.default).toBeUndefined()
@@ -79,6 +96,11 @@ describe(Badge.name, () => {
       expect(badge.icon.default).toEqual({ value: 'foo' })
     })
 
+    test('should accept a string', () => {
+      const badge = new Badge(badgeDataFixture.create({ icon: 'foo' }))
+      expect(badge.icon.default).toEqual({ value: 'foo' })
+    })
+
     test('should be optional', () => {
       const badge = new Badge(badgeDataFixture.omit('icon').create())
       expect(badge.icon.default).toBeUndefined()
@@ -159,7 +181,19 @@ describe(Badge.name, () => {
           badgeRequirementDataFixture.create({ key: 'foo' }),
         ],
       })
-      expect(() => new Badge(data)).toThrow('Duplicate badge requirement key [badge:foo]')
+      expect(() => new Badge(data)).toThrow('Duplicate key [foo]')
+    })
+
+    test(`should return requirement list`, () => {
+      const data = badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ key: 'foo' }),
+          badgeRequirementDataFixture.create({ key: 'bar' }),
+        ],
+      })
+      const badge = new Badge(data)
+
+      expect(badge.requirements.map(x => x.key)).toStrictEqual(['foo', 'bar'])
     })
   })
 
@@ -172,12 +206,12 @@ describe(Badge.name, () => {
       expect(new Badge(data).getRequirement('foo')).not.toBeUndefined()
     })
 
-    test(`should throw error for unknown requirement`, () => {
+    test(`should return undefined for unknown requirement`, () => {
       const data = badgeDataFixture.create({
         requirements: [],
       })
 
-      expect(() => new Badge(data).getRequirement('foo')).toThrow('Unknown badge requirement key [foo]')
+      expect(new Badge(data).getRequirement('foo')).toBeUndefined()
     })
   })
 
@@ -334,4 +368,35 @@ describe(Badge.name, () => {
       expect([badgeB, badgeA].sort(compareByZoneKey)).toStrictEqual([badgeA, badgeB])
     })
   })
+
+  describe(compareByReleaseDate.name, () => {
+    test(`should compare two badges by releaseDate`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ releaseDate: '2024-01-01' }))
+      const badgeB = new Badge(badgeDataFixture.create({ releaseDate: '2025-01-01' }))
+      expect(compareByReleaseDate(badgeA, badgeB)).toBeLessThan(0)
+      expect([badgeB, badgeA].sort(compareByReleaseDate)).toStrictEqual([badgeA, badgeB])
+    })
+
+    test(`should return 0 for equal releaseDates`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ releaseDate: '2025-01-01' }))
+      const badgeB = new Badge(badgeDataFixture.create({ releaseDate: '2025-01-01' }))
+      expect(compareByReleaseDate(badgeA, badgeB)).toEqual(0)
+    })
+
+    test(`should equate two undefined values`, () => {
+      const badgeA = undefined
+      const badgeB = undefined
+      expect(compareByReleaseDate(badgeA, badgeB)).toEqual(0)
+    })
+
+    test(`should compare undefined value as higher`, () => {
+      const badgeA = undefined
+      const badgeB = new Badge(badgeDataFixture.create({ releaseDate: '2025-01-01' }))
+      expect(compareByReleaseDate(badgeA, badgeB)).toBeGreaterThan(0)
+      expect([badgeA, badgeB].sort(compareByReleaseDate)).toStrictEqual([badgeB, badgeA])
+
+      expect(compareByReleaseDate(badgeB, badgeA)).toBeLessThan(0)
+      expect([badgeB, badgeA].sort(compareByReleaseDate)).toStrictEqual([badgeB, badgeA])
+    })
+  })
 })

package/src/test/db/coh-content-database.test.ts

@@ -274,7 +274,7 @@ describe(CohContentDatabase.name, () => {
         }),
       )
 
-      const result = database.searchBadges({ query: { str: 'oo' } })
+      const result = database.searchBadges({ query: { str: 'oo', fields: ['name'] } })
       expect(result.totalItems).toBe(1)
       expect(result.items.map(x => x.key)).toStrictEqual(['foo'])
     })