coh-content-db 2.0.0-rc.11 → 2.0.0-rc.13

package/src/test/api/badge-data.test.ts

@@ -5,6 +5,7 @@ export const TEST_BADGE: BadgeData = {
   key: 'test-badge',
   type: 'achievement',
   name: [{ value: 'Test Badge' }, { alignment: 'praetorian', value: 'My Badge for Praetorians' }],
+  releaseDate: '2020-03-01',
   morality: ['hero', 'praetorian'],
 }
 

package/src/test/api/bundle-data.fixture.ts

@@ -1,6 +1,7 @@
 import { defineFixture } from 'efate'
 import { BundleData } from '../../main'
+import { bundleHeaderDataFixture } from './bundle-header-data.fixture'
 
-export const bundleDataFixture = defineFixture<BundleData>(() => {
-  // no mandatory fields
+export const bundleDataFixture = defineFixture<BundleData>((t) => {
+  t.header.fromFixture(bundleHeaderDataFixture)
 })

package/src/test/api/bundle-header-data.fixture.ts

@@ -1,6 +1,8 @@
 import { defineFixture } from 'efate'
 import { BundleHeaderData } from '../../main'
 
-export const bundleHeaderDataFixture = defineFixture<BundleHeaderData>(() => {
-  // no mandatory fields
+export const bundleHeaderDataFixture = defineFixture<BundleHeaderData>((t) => {
+  t.name.as(index => `Bundle ${index}`)
+  t.version.as(index => `${index}.${index}.${index}`)
+  t.lastUpdateTime.as(() => new Date().toISOString())
 })

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

@@ -542,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,24 @@ 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'))
+    })
+
+    test('should not accept an invalid date', () => {
+      expect(() =>
+        new Badge(badgeDataFixture.create({ releaseDate: '2025-??-08' })),
+      ).toThrow('Invalid date')
+    })
   })
 
   describe('morality', () => {
@@ -55,6 +73,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 +102,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()
@@ -346,4 +374,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/bundle-header.test.ts

@@ -14,6 +14,31 @@ describe(BundleHeader.name, () => {
     })
   })
 
+  describe('version', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ version: 'foo' }))
+      expect(header.version).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('version').create())
+      expect(header.version).toBeUndefined()
+    })
+  })
+
+  describe('releaseDate', () => {
+    test('should be set from the data', () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ lastUpdateTime: '2025-04-21T01:02:03Z' }))
+      expect(header.lastUpdateTime).toStrictEqual(new Date('2025-04-21T01:02:03Z'))
+    })
+
+    test('should not accept an invalid date', () => {
+      expect(() =>
+        new BundleHeader(bundleHeaderDataFixture.create({ lastUpdateTime: 'blah' })),
+      ).toThrow('Invalid date')
+    })
+  })
+
   describe('description', () => {
     test(`should be set from the data`, () => {
       const header = new BundleHeader(bundleHeaderDataFixture.create({ description: 'foo' }))
@@ -61,16 +86,4 @@ describe(BundleHeader.name, () => {
       expect(header.links).toHaveLength(0)
     })
   })
-
-  describe('version', () => {
-    test(`should be set from the data`, () => {
-      const header = new BundleHeader(bundleHeaderDataFixture.create({ version: 'foo' }))
-      expect(header.version).toEqual('foo')
-    })
-
-    test(`should be optional`, () => {
-      const header = new BundleHeader(bundleHeaderDataFixture.omit('version').create())
-      expect(header.version).toBeUndefined()
-    })
-  })
 })

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

@@ -14,12 +14,12 @@ describe(CohContentDatabase.name, () => {
   })
 
   describe('header', () => {
-    test(`should accept an undefined field`, () => {
-      const database = new CohContentDatabase(
-        bundleDataFixture.omit('header').create(),
-      )
-      expect(database.header).toBeDefined()
-      expect(database.header?.name).toBeUndefined()
+    test(`should not accept an undefined field`, () => {
+      expect(() =>
+        new CohContentDatabase(
+          bundleDataFixture.omit('header').create(),
+        ),
+      ).toThrow('Missing header data')
     })
 
     test(`should load values from bundle`, () => {

package/src/test/integration.test.ts

@@ -4,13 +4,13 @@ import { TEST_BADGE } from './api/badge-data.test'
 /**
  * If you change this test, update the example in the README as well
  */
-export const TEST_BUNDLE: BundleData = {
-  header: { name: 'My Content Bundle' },
+export const MyBundle: BundleData = {
+  header: { name: 'My Content Bundle', version: '1.0.0', lastUpdateTime: '2025-04-21T00:00:00Z' },
   badges: [TEST_BADGE],
 }
 
 describe('BundleData', () => {
   test('should be a usable interface', () => {
-    expect(TEST_BUNDLE).not.toBeUndefined()
+    expect(MyBundle).not.toBeUndefined()
   })
 })

package/src/test/to-date.test.ts

@@ -0,0 +1,15 @@
+import { toDate } from '../main/to-date'
+
+describe(toDate.name, () => {
+  test('should return a valid date', () => {
+    expect(toDate('2025-02-01')).toStrictEqual(new Date('2025-02-01'))
+  })
+
+  test('should return a valid time', () => {
+    expect(toDate('2025-04-21T02:57:52.402Z')).toStrictEqual(new Date('2025-04-21T02:57:52.402Z'))
+  })
+
+  test('should throw on invalid ISO string', () => {
+    expect(() => toDate('foo')).toThrow('Invalid date')
+  })
+})