coh-content-db 2.0.0-rc.2 → 2.0.0-rc.21

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

@@ -0,0 +1,145 @@
+import { BadgeRequirement } from '../../main'
+import { badgeRequirementDataFixture } from '../api/badge-requirement-data.fixture'
+
+describe(BadgeRequirement.name, () => {
+  describe('Constructor', () => {
+    test('should accept the test fixture', () => {
+      new BadgeRequirement(badgeRequirementDataFixture.create())
+    })
+  })
+
+  describe('key', () => {
+    test('should be set from the data', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ key: 'foo' }))
+      expect(requirement.key).toEqual('foo')
+    })
+  })
+
+  describe('type', () => {
+    test('should be set from the data', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ type: 'badge' }))
+      expect(requirement.type).toEqual('badge')
+    })
+  })
+
+  describe('location', () => {
+    test('should be set from the data', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ location: { zoneKey: 'foo', coords: [1, 2, 3] } }))
+      expect(requirement.location).toStrictEqual([{ zoneKey: 'foo', coords: [1, 2, 3] }])
+    })
+
+    test('should accept an array', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({
+        location: [
+          { zoneKey: 'foo', coords: [1, 2, 3] },
+          { zoneKey: 'bar', coords: [4, 5, 6] },
+        ],
+      }))
+      expect(requirement.location).toStrictEqual([
+        { zoneKey: 'foo', coords: [1, 2, 3] },
+        { zoneKey: 'bar', coords: [4, 5, 6] },
+      ])
+    })
+
+    test('should be optional', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('location').create())
+      expect(requirement.location).toBeUndefined()
+    })
+  })
+
+  describe('badgeKey', () => {
+    test('should be set from the data', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ badgeKey: 'foo' }))
+      expect(requirement.badgeKey).toEqual('foo')
+    })
+
+    test('should be optional', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('badgeKey').create())
+      expect(requirement.badgeKey).toBeUndefined()
+    })
+  })
+
+  describe('missionKey', () => {
+    test('should be set from the data', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ missionKey: 'foo' }))
+      expect(requirement.missionKey).toEqual('foo')
+    })
+
+    test('should be optional', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('missionKey').create())
+      expect(requirement.missionKey).toBeUndefined()
+    })
+  })
+
+  describe('monumentText', () => {
+    test('should be set from the data', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ monumentText: 'foo' }))
+      expect(requirement.monumentText).toEqual('foo')
+    })
+
+    test('should be optional', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('monumentText').create())
+      expect(requirement.monumentText).toBeUndefined()
+    })
+  })
+
+  describe('inventionLevel', () => {
+    test('should be set from the data', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ inventionLevel: 10 }))
+      expect(requirement.inventionLevel).toEqual(10)
+    })
+
+    test('should be optional', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('inventionLevel').create())
+      expect(requirement.inventionLevel).toBeUndefined()
+    })
+  })
+
+  describe('inventionTypes', () => {
+    test('should be set from the data', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ inventionTypes: ['accuracy', 'confuse'] }))
+      expect(requirement.inventionTypes).toStrictEqual(['accuracy', 'confuse'])
+    })
+
+    test('should be optional', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('inventionTypes').create())
+      expect(requirement.inventionTypes).toBeUndefined()
+    })
+  })
+
+  describe('count', () => {
+    test('should be set from the data', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ count: 5 }))
+      expect(requirement.count).toEqual(5)
+    })
+
+    test('should be optional', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('count').create())
+      expect(requirement.count).toBeUndefined()
+    })
+  })
+
+  describe('notes', () => {
+    test('should be set from the data', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ notes: 'some notes' }))
+      expect(requirement.notes).toEqual('some notes')
+    })
+
+    test('should be optional', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('notes').create())
+      expect(requirement.notes).toBeUndefined()
+    })
+  })
+
+  describe('links', () => {
+    test('should be set from the data', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ links: [{ title: 'foo', href: 'bar' }] }))
+      expect(requirement.links).toStrictEqual([{ title: 'foo', href: 'bar' }])
+    })
+
+    test('should be optional', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('links').create())
+      expect(requirement.links).toHaveLength(0)
+    })
+  })
+})

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

@@ -1,6 +1,6 @@
-import { Badge } from '../../main'
+import { Badge, compareByName, compareByReleaseDate, compareByZoneKey } from '../../main'
 import { badgeDataFixture } from '../api/badge-data.fixture'
-import { badgePartialDataFixture } from '../api/badge-partial-data.fixture'
+import { badgeRequirementDataFixture } from '../api/badge-requirement-data.fixture'
 
 describe(Badge.name, () => {
   describe('Constructor', () => {
@@ -9,33 +9,435 @@ describe(Badge.name, () => {
     })
   })
 
-  describe('partials', () => {
+  describe('key', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ key: 'badge123' }))
+      expect(badge.key).toEqual('badge123')
+    })
+  })
+
+  describe('type', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ type: 'achievement' }))
+      expect(badge.type).toEqual('achievement')
+    })
+  })
+
+  describe('name', () => {
+    test('should be set from the data', () => {
+      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', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ morality: ['hero', 'villain'] }))
+      expect(badge.morality.hero).toBeTruthy()
+      expect(badge.morality.villain).toBeTruthy()
+    })
+
+    test('should accept a single string', () => {
+      const badge = new Badge(badgeDataFixture.create({ morality: 'hero' }))
+      expect(badge.morality.hero).toBeTruthy()
+      expect(badge.morality.villain).toBeFalsy()
+    })
+
+    test('should be optional, defaulting to all', () => {
+      const badge = new Badge(badgeDataFixture.omit('morality').create())
+      expect(badge.morality.all).toBeTruthy()
+    })
+  })
+
+  describe('badgeText', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ badgeText: [{ value: 'foo' }] }))
+      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()
+    })
+  })
+
+  describe('acquisition', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ acquisition: 'Quest Reward' }))
+      expect(badge.acquisition).toEqual('Quest Reward')
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('acquisition').create())
+      expect(badge.acquisition).toBeUndefined()
+    })
+  })
+
+  describe('icon', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ icon: [{ value: 'foo' }] }))
+      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()
+    })
+  })
+
+  describe('notes', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ notes: 'foo' }))
+      expect(badge.notes).toEqual('foo')
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('notes').create())
+      expect(badge.notes).toBeUndefined()
+    })
+  })
+
+  describe('links', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ links: [{ title: 'foo', href: 'bar' }] }))
+      expect(badge.links).toStrictEqual([{ title: 'foo', href: 'bar' }])
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('links').create())
+      expect(badge.links).toHaveLength(0)
+    })
+  })
+
+  describe('effect', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ effect: 'foo' }))
+      expect(badge.effect).toEqual('foo')
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('effect').create())
+      expect(badge.effect).toBeUndefined()
+    })
+  })
+
+  describe('setTitle', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ setTitleId: [123, 456] }))
+      expect(badge.setTitleId?.primal).toEqual(123)
+      expect(badge.setTitleId?.praetorian).toEqual(456)
+    })
+
+    test('should treat the praetorian id as optional', () => {
+      const badge = new Badge(badgeDataFixture.create({ setTitleId: [123] }))
+      expect(badge.setTitleId?.primal).toEqual(123)
+      expect(badge.setTitleId?.praetorian).toBeUndefined()
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('setTitleId').create())
+      expect(badge.setTitleId).toBeUndefined()
+    })
+  })
+
+  describe('ignoreInTotals', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ ignoreInTotals: true }))
+      expect(badge.ignoreInTotals).toEqual(true)
+    })
+
+    test('should default to false', () => {
+      const badge = new Badge(badgeDataFixture.omit('ignoreInTotals').create())
+      expect(badge.ignoreInTotals).toEqual(false)
+    })
+  })
+
+  describe('requirements', () => {
     test(`should throw an error on duplicate key`, () => {
       const data = badgeDataFixture.create({
-        partials: [
-          badgePartialDataFixture.create({ key: 'foo' }),
-          badgePartialDataFixture.create({ key: 'foo' }),
+        key: 'badge',
+        requirements: [
+          badgeRequirementDataFixture.create({ key: 'foo' }),
+          badgeRequirementDataFixture.create({ key: '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' }),
         ],
       })
-      expect(() => new Badge(data)).toThrow('Duplicate badge partial key [foo]')
+      const badge = new Badge(data)
+
+      expect(badge.requirements.map(x => x.key)).toStrictEqual(['foo', 'bar'])
     })
   })
 
-  describe('getBadgePartial', () => {
-    test(`should retrieve partial from the index`, () => {
+  describe('getRequirement', () => {
+    test(`should retrieve requirement from the index`, () => {
       const data = badgeDataFixture.create({
-        partials: [badgePartialDataFixture.create({ key: 'foo' })],
+        requirements: [badgeRequirementDataFixture.create({ key: 'foo' })],
       })
 
-      expect(new Badge(data).getPartial('foo')).not.toBeNull()
+      expect(new Badge(data).getRequirement('foo')).not.toBeUndefined()
     })
 
-    test(`should throw error for unknown partial`, () => {
+    test(`should return undefined for unknown requirement`, () => {
       const data = badgeDataFixture.create({
-        partials: [],
+        requirements: [],
       })
 
-      expect(() => new Badge(data).getPartial('foo')).toThrow('Unknown badge partial key [foo]')
+      expect(new Badge(data).getRequirement('foo')).toBeUndefined()
+    })
+  })
+
+  describe('zoneKeys', () => {
+    test(`should return the list of keys`, () => {
+      const badge = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'c' } }),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'b' } }),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'c' } }),
+        ],
+      }))
+      expect(badge.zoneKeys).toStrictEqual(['a', 'c', 'b'])
+    })
+
+    test(`should return undefined if there no zones`, () => {
+      const badge = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.omit('location').create(),
+        ],
+      }))
+      expect(badge.zoneKey).toBeUndefined()
+    })
+
+    test(`should ignore requirements with no location`, () => {
+      const badge = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'c' } }),
+          badgeRequirementDataFixture.omit('location').create(),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'c' } }),
+        ],
+      }))
+      expect(badge.zoneKeys).toStrictEqual(['a', 'c'])
+    })
+
+    test(`should ignore locations with no zone key`, () => {
+      const badge = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+          badgeRequirementDataFixture.create({ location: { coords: [1, 2, 3] } }),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'c' } }),
+        ],
+      }))
+      expect(badge.zoneKeys).toStrictEqual(['a', 'c'])
+    })
+  })
+
+  describe('zoneKey', () => {
+    test(`should return the key for a single zone`, () => {
+      const badge = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+        ],
+      }))
+      expect(badge.zoneKey).toBe('a')
+    })
+
+    test(`should return undefined if there no zones`, () => {
+      const badge = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.omit('location').create(),
+        ],
+      }))
+      expect(badge.zoneKey).toBeUndefined()
+    })
+
+    test(`should return undefined if there are multiple zones`, () => {
+      const badge = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'c' } }),
+        ],
+      }))
+      expect(badge.zoneKey).toBeUndefined()
+    })
+  })
+
+  describe(compareByName.name, () => {
+    test(`should compare two badges by name`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ name: 'A' }))
+      const badgeB = new Badge(badgeDataFixture.create({ name: 'B' }))
+      expect(compareByName(badgeA, badgeB)).toBeLessThan(0)
+      expect([badgeB, badgeA].toSorted(compareByName)).toStrictEqual([badgeA, badgeB])
+    })
+
+    test(`should return 0 for equal names`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ name: 'A' }))
+      const badgeB = new Badge(badgeDataFixture.create({ name: 'A' }))
+      expect(compareByName(badgeA, badgeB)).toEqual(0)
+    })
+
+    test(`should compare two undefined values`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ name: [] }))
+      const badgeB = new Badge(badgeDataFixture.create({ name: [] }))
+      expect(compareByName(badgeA, badgeB)).toEqual(0)
+    })
+
+    test(`should sort undefined values last`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ name: 'A' }))
+      const badgeB = new Badge(badgeDataFixture.create({ name: [] }))
+      expect([badgeA, badgeB].toSorted(compareByName)).toStrictEqual([badgeA, badgeB])
+      expect([badgeB, badgeA].toSorted(compareByName)).toStrictEqual([badgeA, badgeB])
+    })
+
+    test(`should take morality context into account`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ name: [{ value: 'ZZZ' }, { alignment: 'villain', value: 'AAA' }] }))
+      const badgeB = new Badge(badgeDataFixture.create({ name: 'B' }))
+      expect([badgeA, badgeB].toSorted((a, b) => compareByName(a, b, { morality: 'villain' }))).toStrictEqual([badgeA, badgeB])
+      expect([badgeA, badgeB].toSorted((a, b) => compareByName(a, b, {}))).toStrictEqual([badgeB, badgeA])
+    })
+
+    test(`should take sex context into account`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ name: [{ value: 'ZZZ' }, { sex: 'F', value: 'AAA' }] }))
+      const badgeB = new Badge(badgeDataFixture.create({ name: 'B' }))
+      expect([badgeA, badgeB].toSorted((a, b) => compareByName(a, b, { sex: 'F' }))).toStrictEqual([badgeA, badgeB])
+      expect([badgeA, badgeB].toSorted((a, b) => compareByName(a, b, {}))).toStrictEqual([badgeB, badgeA])
+    })
+
+    test(`should take full variant context into account`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ name: [{ value: 'A' }, { sex: 'F', value: 'B' }] }))
+      const badgeB = new Badge(badgeDataFixture.create({ name: [{ value: 'B' }, { alignment: 'praetorian', sex: 'F', value: 'A' }] }))
+      const badgeC = new Badge(badgeDataFixture.create({ name: 'C' }))
+      expect([badgeA, badgeB, badgeC].toSorted((a, b) => compareByName(a, b, { morality: 'resistance', sex: 'F' }))).toStrictEqual([badgeB, badgeA, badgeC])
+      expect([badgeA, badgeB, badgeC].toSorted((a, b) => compareByName(a, b, {}))).toStrictEqual([badgeA, badgeB, badgeC])
+    })
+  })
+
+  describe(compareByZoneKey.name, () => {
+    test(`should compare two badges by zoneKey`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+        ],
+      }))
+      const badgeB = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'b' } }),
+        ],
+      }))
+      expect(compareByZoneKey(badgeA, badgeB)).toBeLessThan(0)
+      expect([badgeB, badgeA].toSorted(compareByZoneKey)).toStrictEqual([badgeA, badgeB])
+    })
+
+    test(`should return 0 for equal zoneKeys`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+        ],
+      }))
+      const badgeB = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+        ],
+      }))
+      expect(compareByZoneKey(badgeA, badgeB)).toEqual(0)
+    })
+
+    test(`should equate two undefined values`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.omit('location').create(),
+        ],
+      }))
+      const badgeB = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.omit('location').create(),
+        ],
+      }))
+      expect(compareByZoneKey(badgeA, badgeB)).toEqual(0)
+    })
+
+    test(`should sort badges with multiple values last`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+        ],
+      }))
+      const badgeB = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'b' } }),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'c' } }),
+        ],
+      }))
+      expect([badgeA, badgeB].toSorted(compareByZoneKey)).toStrictEqual([badgeA, badgeB])
+      expect([badgeB, badgeA].toSorted(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].toSorted(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].toSorted(compareByReleaseDate)).toStrictEqual([badgeB, badgeA])
+
+      expect(compareByReleaseDate(badgeB, badgeA)).toBeLessThan(0)
+      expect([badgeB, badgeA].toSorted(compareByReleaseDate)).toStrictEqual([badgeB, badgeA])
     })
   })
 })

package/src/test/db/bundle-header.test.ts

@@ -0,0 +1,89 @@
+import { BundleHeader } from '../../main'
+import { bundleHeaderDataFixture } from '../api/bundle-header-data.fixture'
+
+describe(BundleHeader.name, () => {
+  describe('name', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ name: 'foo' }))
+      expect(header.name).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('name').create())
+      expect(header.name).toBeUndefined()
+    })
+  })
+
+  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' }))
+      expect(header.description).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('description').create())
+      expect(header.description).toBeUndefined()
+    })
+  })
+
+  describe('repositoryUrl', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ repositoryUrl: 'foo' }))
+      expect(header.repositoryUrl).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('repositoryUrl').create())
+      expect(header.repositoryUrl).toBeUndefined()
+    })
+  })
+
+  describe('changelogUrl', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ changelogUrl: 'foo' }))
+      expect(header.changelogUrl).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('changelogUrl').create())
+      expect(header.changelogUrl).toBeUndefined()
+    })
+  })
+
+  describe('links', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ links: [{ title: 'foo', href: 'bar' }] }))
+      expect(header.links).toStrictEqual([{ title: 'foo', href: 'bar' }])
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('links').create())
+      expect(header.links).toHaveLength(0)
+    })
+  })
+})