coh-content-db 2.0.0-rc.6 → 2.0.0-rc.8

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

@@ -17,68 +17,33 @@ describe(BadgeRequirement.name, () => {
 
   describe('type', () => {
     test('should be set from the data', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ type: 'BADGE' }))
-      expect(requirement.type).toEqual('BADGE')
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ type: 'badge' }))
+      expect(requirement.type).toEqual('badge')
     })
   })
 
-  describe('zoneKey', () => {
+  describe('location', () => {
     test('should be set from the data', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ zoneKey: 'zone123' }))
-      expect(requirement.zoneKey).toEqual('zone123')
+      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 be optional', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('zoneKey').create())
-      expect(requirement.zoneKey).toBeUndefined()
-    })
-  })
-
-  describe('loc', () => {
-    test('should be set from the data', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ loc: [1, 2, 3] }))
-      expect(requirement.loc).toStrictEqual([1, 2, 3])
-    })
-
-    test('should be optional', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('loc').create())
-      expect(requirement.loc).toBeUndefined()
-    })
-  })
-
-  describe('plaqueType', () => {
-    test('should be set from the data', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ plaqueType: 'MONUMENT' }))
-      expect(requirement.plaqueType).toEqual('MONUMENT')
-    })
-
-    test('should be optional', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('plaqueType').create())
-      expect(requirement.plaqueType).toBeUndefined()
-    })
-  })
-
-  describe('plaqueInscription', () => {
-    test('should be set from the data', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ plaqueInscription: 'foo' }))
-      expect(requirement.plaqueInscription).toEqual('foo')
-    })
-
-    test('should be optional', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('plaqueInscription').create())
-      expect(requirement.plaqueInscription).toBeUndefined()
-    })
-  })
-
-  describe('vidiotMapKey', () => {
-    test('should be set from the data', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ vidiotMapKey: 'A1' }))
-      expect(requirement.vidiotMapKey).toEqual('A1')
+    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('vidiotMapKey').create())
-      expect(requirement.vidiotMapKey).toBeUndefined()
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('location').create())
+      expect(requirement.location).toBeUndefined()
     })
   })
 
@@ -94,27 +59,27 @@ describe(BadgeRequirement.name, () => {
     })
   })
 
-  describe('missionName', () => {
+  describe('missionKey', () => {
     test('should be set from the data', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ missionName: 'foo' }))
-      expect(requirement.missionName).toEqual('foo')
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ missionKey: 'foo' }))
+      expect(requirement.missionKey).toEqual('foo')
     })
 
     test('should be optional', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('missionName').create())
-      expect(requirement.missionName).toBeUndefined()
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('missionKey').create())
+      expect(requirement.missionKey).toBeUndefined()
     })
   })
 
-  describe('contactKey', () => {
+  describe('monumentText', () => {
     test('should be set from the data', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ contactKey: 'foo' }))
-      expect(requirement.contactKey).toEqual('foo')
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ monumentText: 'foo' }))
+      expect(requirement.monumentText).toEqual('foo')
     })
 
     test('should be optional', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('contactKey').create())
-      expect(requirement.contactKey).toBeUndefined()
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('monumentText').create())
+      expect(requirement.monumentText).toBeUndefined()
     })
   })
 
@@ -132,8 +97,8 @@ describe(BadgeRequirement.name, () => {
 
   describe('inventionTypes', () => {
     test('should be set from the data', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ inventionTypes: ['ACCURACY', 'CONFUSE'] }))
-      expect(requirement.inventionTypes).toStrictEqual(['ACCURACY', 'CONFUSE'])
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ inventionTypes: ['accuracy', 'confuse'] }))
+      expect(requirement.inventionTypes).toStrictEqual(['accuracy', 'confuse'])
     })
 
     test('should be optional', () => {
@@ -142,15 +107,15 @@ describe(BadgeRequirement.name, () => {
     })
   })
 
-  describe('inventionCount', () => {
+  describe('count', () => {
     test('should be set from the data', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ inventionCount: 5 }))
-      expect(requirement.inventionCount).toEqual(5)
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ count: 5 }))
+      expect(requirement.count).toEqual(5)
     })
 
     test('should be optional', () => {
-      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('inventionCount').create())
-      expect(requirement.inventionCount).toBeUndefined()
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('count').create())
+      expect(requirement.count).toBeUndefined()
     })
   })
 

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

@@ -1,4 +1,4 @@
-import { Badge } from '../../main'
+import { Badge, compareByDefaultName, compareByZoneKey } from '../../main'
 import { badgeDataFixture } from '../api/badge-data.fixture'
 import { badgeRequirementDataFixture } from '../api/badge-requirement-data.fixture'
 
@@ -18,8 +18,8 @@ describe(Badge.name, () => {
 
   describe('type', () => {
     test('should be set from the data', () => {
-      const badge = new Badge(badgeDataFixture.create({ type: 'ACHIEVEMENT' }))
-      expect(badge.type).toEqual('ACHIEVEMENT')
+      const badge = new Badge(badgeDataFixture.create({ type: 'achievement' }))
+      expect(badge.type).toEqual('achievement')
     })
   })
 
@@ -30,12 +30,22 @@ describe(Badge.name, () => {
     })
   })
 
-  describe('alignment', () => {
+  describe('morality', () => {
     test('should be set from the data', () => {
-      const badge = new Badge(badgeDataFixture.create({ alignment: ['H', 'V'] }))
-      expect(badge.alignment.hero).toBeTruthy()
-      expect(badge.alignment.villain).toBeTruthy()
-      expect(badge.alignment.praetorian).toBeFalsy()
+      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()
     })
   })
 
@@ -99,30 +109,6 @@ describe(Badge.name, () => {
     })
   })
 
-  describe('zoneKey', () => {
-    test('should be set from the data', () => {
-      const badge = new Badge(badgeDataFixture.create({ zoneKey: 'foo' }))
-      expect(badge.zoneKey).toEqual('foo')
-    })
-
-    test('should be optional', () => {
-      const badge = new Badge(badgeDataFixture.omit('zoneKey').create())
-      expect(badge.zoneKey).toBeUndefined()
-    })
-  })
-
-  describe('loc', () => {
-    test('should be set from the data', () => {
-      const badge = new Badge(badgeDataFixture.create({ loc: [1, 2, 3] }))
-      expect(badge.loc).toStrictEqual([1, 2, 3])
-    })
-
-    test('should be optional', () => {
-      const badge = new Badge(badgeDataFixture.omit('loc').create())
-      expect(badge.loc).toBeUndefined()
-    })
-  })
-
   describe('effect', () => {
     test('should be set from the data', () => {
       const badge = new Badge(badgeDataFixture.create({ effect: 'foo' }))
@@ -135,27 +121,20 @@ describe(Badge.name, () => {
     })
   })
 
-  describe('vidiotMapKey', () => {
+  describe('setTitle', () => {
     test('should be set from the data', () => {
-      const badge = new Badge(badgeDataFixture.create({ vidiotMapKey: 'foo' }))
-      expect(badge.vidiotMapKey).toEqual('foo')
+      const badge = new Badge(badgeDataFixture.create({ setTitleId: [123, 456] }))
+      expect(badge.setTitleId).toStrictEqual([123, 456])
     })
 
-    test('should be optional', () => {
-      const badge = new Badge(badgeDataFixture.omit('vidiotMapKey').create())
-      expect(badge.vidiotMapKey).toBeUndefined()
-    })
-  })
-
-  describe('setTitle', () => {
-    test('should be set from the data', () => {
-      const badge = new Badge(badgeDataFixture.create({ setTitle: { id: 123, praetorianId: 456 } }))
-      expect(badge.setTitle).toStrictEqual({ id: 123, praetorianId: 456 })
+    test('should treat the praetorian id as optional', () => {
+      const badge = new Badge(badgeDataFixture.create({ setTitleId: [123] }))
+      expect(badge.setTitleId).toStrictEqual([123])
     })
 
     test('should be optional', () => {
-      const badge = new Badge(badgeDataFixture.omit('setTitle').create())
-      expect(badge.setTitle).toBeUndefined()
+      const badge = new Badge(badgeDataFixture.omit('setTitleId').create())
+      expect(badge.setTitleId).toBeUndefined()
     })
   })
 
@@ -172,34 +151,22 @@ describe(Badge.name, () => {
   })
 
   describe('requirements', () => {
-    test(`should throw an error on duplicate key in same group`, () => {
+    test(`should throw an error on duplicate key`, () => {
       const data = badgeDataFixture.create({
         key: 'badge',
-        requirements: [[
+        requirements: [
           badgeRequirementDataFixture.create({ key: 'foo' }),
           badgeRequirementDataFixture.create({ key: 'foo' }),
-        ]],
+        ],
       })
-      expect(() => new Badge(data)).toThrow('Duplicate badge requirement key [badge:foo] in group [1]')
-    })
-
-    test(`should not throw an error on duplicate key in different group`, () => {
-      const data = badgeDataFixture.create({
-        key: 'badge',
-        requirements: [[
-          badgeRequirementDataFixture.create({ key: 'foo' }),
-        ], [
-          badgeRequirementDataFixture.create({ key: 'foo' }),
-        ]],
-      })
-      new Badge(data)
+      expect(() => new Badge(data)).toThrow('Duplicate badge requirement key [badge:foo]')
     })
   })
 
   describe('getRequirement', () => {
     test(`should retrieve requirement from the index`, () => {
       const data = badgeDataFixture.create({
-        requirements: [[badgeRequirementDataFixture.create({ key: 'foo' })]],
+        requirements: [badgeRequirementDataFixture.create({ key: 'foo' })],
       })
 
       expect(new Badge(data).getRequirement('foo')).not.toBeUndefined()
@@ -213,4 +180,158 @@ describe(Badge.name, () => {
       expect(() => new Badge(data).getRequirement('foo')).toThrow('Unknown badge requirement key [foo]')
     })
   })
+
+  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'])
+    })
+  })
+
+  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(compareByDefaultName.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(compareByDefaultName(badgeA, badgeB)).toBeLessThan(0)
+      expect([badgeB, badgeA].sort(compareByDefaultName)).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(compareByDefaultName(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(compareByDefaultName(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].sort(compareByDefaultName)).toStrictEqual([badgeA, badgeB])
+      expect([badgeB, badgeA].sort(compareByDefaultName)).toStrictEqual([badgeA, badgeB])
+    })
+  })
+
+  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].sort(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].sort(compareByZoneKey)).toStrictEqual([badgeA, badgeB])
+      expect([badgeB, badgeA].sort(compareByZoneKey)).toStrictEqual([badgeA, badgeB])
+    })
+  })
 })

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

@@ -64,4 +64,21 @@ describe(BundleMetadata.name, () => {
       expect(bundle.changelog).toHaveLength(0)
     })
   })
+
+  describe('version', () => {
+    test(`should be read from the latest changelog entry`, () => {
+      const bundle = new BundleMetadata(contentBundleFixture.create({
+        changelog: [
+          { version: 'foo', date: new Date('2025-03-12'), description: 'Foo' },
+          { version: 'latest', date: new Date('2025-04-12'), description: 'Bar' },
+        ],
+      }))
+      expect(bundle.version).toBe('latest')
+    })
+
+    test(`should be undefined if there is no changelog`, () => {
+      const bundle = new BundleMetadata(contentBundleFixture.omit('changelog').create())
+      expect(bundle.version).toBeUndefined()
+    })
+  })
 })