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

package/src/test/db/alternates.test.ts

@@ -6,11 +6,15 @@ describe(Alternates.name, () => {
       new Alternates([
         { value: 'Default' },
         { sex: 'M', value: 'Male' },
-        { alignment: 'H', value: 'Hero' },
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+        { alignment: 'hero', value: 'Hero' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
       ])
     })
+
+    test('should accept a single value', () => {
+      expect(new Alternates('foo').default?.value).toBe('foo')
+    })
   })
 
   describe('getValue', () => {
@@ -22,19 +26,19 @@ describe(Alternates.name, () => {
       expect(new Alternates([
         { value: 'Default' },
         { sex: 'M', value: 'Male' },
-        { alignment: 'H', value: 'Hero' },
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+        { alignment: 'hero', value: 'Hero' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
       ]).getValue()).toBe('Default')
     })
 
     test('should return the least-specific value when no classifiers are provided, regardless of insert order', () => {
       expect(new Alternates([
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'H', value: 'Hero' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'hero', value: 'Hero' },
         { value: 'Default' },
         { sex: 'M', value: 'Male' },
-        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
       ]).getValue()).toBe('Default')
     })
 
@@ -42,37 +46,37 @@ describe(Alternates.name, () => {
       expect(new Alternates([
         { value: 'Default' },
         { sex: 'M', value: 'Male' },
-        { alignment: 'H', value: 'Hero' },
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
-      ]).getValue('V', 'M')).toBe('Male Villain')
+        { alignment: 'hero', value: 'Hero' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
+      ]).getValue('villain', 'M')).toBe('Male Villain')
     })
 
     test('should return the most specific match, regardless of insert order', () => {
       expect(new Alternates([
-        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
         { sex: 'M', value: 'Male' },
-        { alignment: 'H', value: 'Hero' },
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
+        { alignment: 'hero', value: 'Hero' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
         { value: 'Default' },
-      ]).getValue('V', 'M')).toBe('Male Villain')
+      ]).getValue('villain', 'M')).toBe('Male Villain')
     })
 
     test('should return the lowest canonical value if there is no default', () => {
       expect(new Alternates([
-        { alignment: 'H', value: 'Hero' },
+        { alignment: 'hero', value: 'Hero' },
         { sex: 'M', value: 'Male' },
-        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
       ]).getValue()).toBe('Male')
     })
 
     test('should return the lowest canonical value if a specific is requested that does not exist', () => {
       expect(new Alternates([
-        { alignment: 'H', value: 'Hero' },
-        { alignment: 'V', value: 'Villain' },
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+        { alignment: 'hero', value: 'Hero' },
+        { alignment: 'villain', value: 'Villain' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
       ]).getValue(undefined, 'F')).toBe('Hero')
     })
   })
@@ -86,24 +90,24 @@ describe(Alternates.name, () => {
       expect(new Alternates([
         { value: 'Default' },
         { sex: 'M', value: 'Male' },
-        { alignment: 'H', value: 'Hero' },
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+        { alignment: 'hero', value: 'Hero' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
       ]).default?.value).toBe('Default')
 
       expect(new Alternates([
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
         { sex: 'M', value: 'Male' },
         { value: 'Default' },
-        { alignment: 'H', value: 'Hero' },
+        { alignment: 'hero', value: 'Hero' },
       ]).default?.value).toBe('Default')
 
       expect(new Alternates([
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
         { sex: 'M', value: 'Male' },
-        { alignment: 'H', value: 'Hero' },
+        { alignment: 'hero', value: 'Hero' },
       ]).default?.value).toBe('Male')
     })
   })
@@ -115,17 +119,17 @@ describe(Alternates.name, () => {
 
     test('should return values sorted in canonical order', () => {
       const result = new Alternates([
-        { alignment: 'H', sex: 'F', value: 'Female Hero' },
-        { alignment: 'P', value: 'Praetorian' },
+        { alignment: 'hero', sex: 'F', value: 'Female Hero' },
+        { alignment: 'praetorian', value: 'Praetorian' },
         { sex: 'F', value: 'Female' },
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'P', sex: 'M', value: 'Male Praetorian' },
-        { alignment: 'H', value: 'Hero' },
-        { alignment: 'H', sex: 'M', value: 'Male Hero' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'praetorian', sex: 'M', value: 'Male Praetorian' },
+        { alignment: 'hero', value: 'Hero' },
+        { alignment: 'hero', sex: 'M', value: 'Male Hero' },
         { sex: 'M', value: 'Male' },
-        { alignment: 'V', value: 'Villain' },
-        { alignment: 'V', sex: 'F', value: 'Female Villain' },
-        { alignment: 'P', sex: 'F', value: 'Female Praetorian' },
+        { alignment: 'villain', value: 'Villain' },
+        { alignment: 'villain', sex: 'F', value: 'Female Villain' },
+        { alignment: 'praetorian', sex: 'F', value: 'Female Praetorian' },
         { value: 'Default' },
       ]).canonical
 
@@ -133,15 +137,15 @@ describe(Alternates.name, () => {
         { value: 'Default' },
         { sex: 'M', value: 'Male' },
         { sex: 'F', value: 'Female' },
-        { alignment: 'H', value: 'Hero' },
-        { alignment: 'V', value: 'Villain' },
-        { alignment: 'P', value: 'Praetorian' },
-        { alignment: 'H', sex: 'M', value: 'Male Hero' },
-        { alignment: 'H', sex: 'F', value: 'Female Hero' },
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'V', sex: 'F', value: 'Female Villain' },
-        { alignment: 'P', sex: 'M', value: 'Male Praetorian' },
-        { alignment: 'P', sex: 'F', value: 'Female Praetorian' },
+        { alignment: 'hero', value: 'Hero' },
+        { alignment: 'villain', value: 'Villain' },
+        { alignment: 'praetorian', value: 'Praetorian' },
+        { alignment: 'hero', sex: 'M', value: 'Male Hero' },
+        { alignment: 'hero', sex: 'F', value: 'Female Hero' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'villain', sex: 'F', value: 'Female Villain' },
+        { alignment: 'praetorian', sex: 'M', value: 'Male Praetorian' },
+        { alignment: 'praetorian', sex: 'F', value: 'Female Praetorian' },
       ])
     })
 
@@ -159,15 +163,15 @@ describe(Alternates.name, () => {
 
     test('should sort identical values by value alpha', () => {
       expect(new Alternates([
-        { alignment: 'V', value: 'B' },
+        { alignment: 'villain', value: 'B' },
         { sex: 'M', value: 'D' },
-        { alignment: 'V', value: 'A' },
+        { alignment: 'villain', value: 'A' },
         { sex: 'M', value: 'C' },
       ]).canonical).toStrictEqual([
         { sex: 'M', value: 'C' },
         { sex: 'M', value: 'D' },
-        { alignment: 'V', value: 'A' },
-        { alignment: 'V', value: 'B' },
+        { alignment: 'villain', value: 'A' },
+        { alignment: 'villain', value: 'B' },
       ])
     })
   })
@@ -177,7 +181,7 @@ describe(Alternates.name, () => {
       expect(new Alternates([
         { sex: 'M', value: 'A' },
         { sex: 'F', value: 'B' },
-        { alignment: 'H', value: 'C' },
+        { alignment: 'hero', value: 'C' },
       ]).toString(', ')).toBe('A, B, C')
     })
   })

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

@@ -1,12 +1,6 @@
 import { badgeDataFixture } from '../api/badge-data.fixture'
-import { Badge, BadgeIndex, Zone } from '../../main'
-import { zoneDataFixture } from '../api/zone-data.fixture'
-
-const TEST_Zones = [
-  new Zone(zoneDataFixture.create({ key: 'atlas-park', name: 'Atlas Park' })),
-  new Zone(zoneDataFixture.create({ key: 'perez-park', name: 'Perez Park' })),
-  new Zone(zoneDataFixture.create({ key: 'abandoned-sewer-network', name: 'Abandoned Sewer Network' })),
-]
+import { Badge, BadgeIndex } from '../../main'
+import { badgeRequirementDataFixture } from '../api/badge-requirement-data.fixture'
 
 describe(BadgeIndex.name, () => {
   describe('Constructor', () => {
@@ -26,20 +20,12 @@ describe(BadgeIndex.name, () => {
       expect(new BadgeIndex(data).getBadge('foo')).not.toBeUndefined()
     })
 
-    test(`should throw error for unknown badge`, () => {
-      expect(() => new BadgeIndex([]).getBadge('foo')).toThrow('Unknown badge key [foo]')
-    })
-  })
-
-  describe('badgeExists', () => {
-    test(`should return true for a badge that exists`, () => {
-      const data = [new Badge(badgeDataFixture.create({ key: 'foo' }))]
-
-      expect(new BadgeIndex(data).badgeExists('foo')).toBeTruthy()
+    test(`should return undefined for unknown badge`, () => {
+      expect(new BadgeIndex([]).getBadge('foo')).toBeUndefined()
     })
 
-    test(`should return false for a badge that does not exist`, () => {
-      expect(new BadgeIndex([]).badgeExists('foo')).toBeFalsy()
+    test(`should return undefined for undefined key`, () => {
+      expect(new BadgeIndex([]).getBadge()).toBeUndefined()
     })
   })
 
@@ -128,10 +114,10 @@ describe(BadgeIndex.name, () => {
 
       test(`should match on setTitle`, () => {
         const data = [
-          new Badge(badgeDataFixture.create({ key: 'match-1', setTitle: { id: 123 } })),
-          new Badge(badgeDataFixture.create({ key: 'match-2', setTitle: { id: 456, praetorianId: 123 } })),
-          new Badge(badgeDataFixture.create({ key: 'miss-1', setTitle: { id: 456 } })),
-          new Badge(badgeDataFixture.create({ key: 'miss-2', setTitle: undefined })),
+          new Badge(badgeDataFixture.create({ key: 'match-1', setTitleId: [123] })),
+          new Badge(badgeDataFixture.create({ key: 'match-2', setTitleId: [456, 123] })),
+          new Badge(badgeDataFixture.create({ key: 'miss-1', setTitleId: [456] })),
+          new Badge(badgeDataFixture.create({ key: 'miss-2', setTitleId: undefined })),
         ]
 
         const result = new BadgeIndex(data).searchBadges({ query: { str: '123', on: { setTitle: true } } })
@@ -197,45 +183,50 @@ describe(BadgeIndex.name, () => {
 
       test(`should filter on badge type`, () => {
         const data = [
-          new Badge(badgeDataFixture.create({ key: 'badge-1', type: 'EXPLORATION' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-2', type: 'EXPLORATION' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-3', type: 'HISTORY' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-4', type: 'HISTORY' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-5', type: 'ACCOLADE' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-6', type: 'ACCOLADE' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-1', type: 'exploration' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-2', type: 'exploration' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-3', type: 'history' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-4', type: 'history' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-5', type: 'accolade' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-6', type: 'accolade' })),
         ]
 
-        const result = new BadgeIndex(data).searchBadges({ filter: { type: 'HISTORY' } })
+        const result = new BadgeIndex(data).searchBadges({ filter: { type: 'history' } })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-3', 'badge-4'])
       })
 
-      test(`should filter on badge type`, () => {
+      test(`should filter on badge zone`, () => {
         const data = [
-          new Badge(badgeDataFixture.create({ key: 'badge-1', zoneKey: 'atlas-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-2', zoneKey: 'perez-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-3', zoneKey: 'abandoned-sewer-network' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-4', zoneKey: 'atlas-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-5', zoneKey: 'perez-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-6', zoneKey: undefined })),
+          new Badge(badgeDataFixture.create({ key: 'badge-1', requirements: [{ location: { zoneKey: 'atlas-park' } }] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-2', requirements: [{ location: { zoneKey: 'perez-park' } }] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-3', requirements: [{ location: { zoneKey: 'abandoned-sewer-network' } }] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-4', requirements: [{ location: { zoneKey: 'atlas-park' } }] })),
+          new Badge(badgeDataFixture.create({
+            key: 'badge-5', requirements: [
+              badgeRequirementDataFixture.create({ location: { zoneKey: 'atlas-park' } }),
+              badgeRequirementDataFixture.create({ location: { zoneKey: 'perez-park' } }),
+            ],
+          })),
+          new Badge(badgeDataFixture.create({ key: 'badge-6', requirements: [{ location: undefined }] })),
         ]
 
         const result = new BadgeIndex(data).searchBadges({ filter: { zoneKey: 'perez-park' } })
         const keys = result.items.map(x => x.key)
-        expect(keys).toStrictEqual(['badge-2', 'badge-5'])
+        expect(keys).toStrictEqual(['badge-2'])
       })
 
-      test(`should filter on badge type`, () => {
+      test(`should filter on alignment`, () => {
         const data = [
-          new Badge(badgeDataFixture.create({ key: 'badge-1', alignment: ['H'] })),
-          new Badge(badgeDataFixture.create({ key: 'badge-2', alignment: ['V'] })),
-          new Badge(badgeDataFixture.create({ key: 'badge-3', alignment: ['P'] })),
-          new Badge(badgeDataFixture.create({ key: 'badge-4', alignment: ['H', 'V'] })),
-          new Badge(badgeDataFixture.create({ key: 'badge-5', alignment: ['V', 'P'] })),
-          new Badge(badgeDataFixture.create({ key: 'badge-6', alignment: ['H', 'V', 'P'] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-1', morality: ['hero'] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-2', morality: ['villain'] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-3', morality: ['loyalist'] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-4', morality: ['hero', 'villain'] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-5', morality: ['villain', 'loyalist'] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-6', morality: ['hero', 'villain', 'loyalist'] })),
         ]
 
-        const result = new BadgeIndex(data).searchBadges({ filter: { alignment: 'H' } })
+        const result = new BadgeIndex(data).searchBadges({ filter: { morality: 'hero' } })
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-1', 'badge-4', 'badge-6'])
       })
@@ -402,7 +393,21 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-4' })),
         ]
 
-        const result = new BadgeIndex(data, TEST_Zones).searchBadges()
+        const result = new BadgeIndex(data).searchBadges()
+
+        const keys = result.items.map(x => x.key)
+        expect(keys).toStrictEqual(['badge-1', 'badge-2', 'badge-3', 'badge-4'])
+      })
+
+      test(`should not modify sort if order is canonical`, () => {
+        const data = [
+          new Badge(badgeDataFixture.create({ key: 'badge-1' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-2' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-3' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-4' })),
+        ]
+
+        const result = new BadgeIndex(data).searchBadges({ sort: { by: 'canonical' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-1', 'badge-2', 'badge-3', 'badge-4'])
@@ -416,7 +421,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-4' })),
         ]
 
-        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { dir: 'DESC' } })
+        const result = new BadgeIndex(data).searchBadges({ sort: { dir: 'desc' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-4', 'badge-3', 'badge-2', 'badge-1'])
@@ -429,7 +434,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-3', name: [{ value: 'AAB' }] })),
         ]
 
-        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { by: 'BADGE_NAME' } })
+        const result = new BadgeIndex(data).searchBadges({ sort: { by: 'badge-name' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-3', 'badge-1', 'badge-2'])
@@ -442,7 +447,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-3', name: [{ value: 'AAB' }] })),
         ]
 
-        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { by: 'BADGE_NAME', dir: 'DESC' } })
+        const result = new BadgeIndex(data).searchBadges({ sort: { by: 'badge-name', dir: 'desc' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-2', 'badge-1', 'badge-3'])
@@ -455,7 +460,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-3', name: [{ value: 'AAB' }] })),
         ]
 
-        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { by: 'BADGE_NAME' } })
+        const result = new BadgeIndex(data).searchBadges({ sort: { by: 'badge-name' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-3', 'badge-1', 'badge-2'])
@@ -463,12 +468,12 @@ describe(BadgeIndex.name, () => {
 
       test(`should sort by zone name`, () => {
         const data = [
-          new Badge(badgeDataFixture.create({ key: 'badge-1', zoneKey: 'atlas-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-2', zoneKey: 'perez-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-3', zoneKey: 'abandoned-sewer-network' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-1', requirements: [{ location: { zoneKey: 'atlas-park' } }] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-2', requirements: [{ location: { zoneKey: 'perez-park' } }] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-3', requirements: [{ location: { zoneKey: 'abandoned-sewer-network' } }] })),
         ]
 
-        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { by: 'ZONE_NAME' } })
+        const result = new BadgeIndex(data).searchBadges({ sort: { by: 'zone-key' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-3', 'badge-1', 'badge-2'])
@@ -476,12 +481,12 @@ describe(BadgeIndex.name, () => {
 
       test(`should sort by zone name descending`, () => {
         const data = [
-          new Badge(badgeDataFixture.create({ key: 'badge-1', zoneKey: 'atlas-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-2', zoneKey: 'perez-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-3', zoneKey: 'abandoned-sewer-network' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-1', requirements: [{ location: { zoneKey: 'atlas-park' } }] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-2', requirements: [{ location: { zoneKey: 'perez-park' } }] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-3', requirements: [{ location: { zoneKey: 'abandoned-sewer-network' } }] })),
         ]
 
-        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { by: 'ZONE_NAME', dir: 'DESC' } })
+        const result = new BadgeIndex(data).searchBadges({ sort: { by: 'zone-key', dir: 'desc' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-2', 'badge-1', 'badge-3'])
@@ -489,28 +494,33 @@ describe(BadgeIndex.name, () => {
 
       test(`should maintain canonical as secondary sort when sorting by zone name`, () => {
         const data = [
-          new Badge(badgeDataFixture.create({ key: 'badge-1', zoneKey: 'atlas-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-2', zoneKey: 'perez-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-3', zoneKey: 'atlas-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-4', zoneKey: 'abandoned-sewer-network' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-1', requirements: [{ location: { zoneKey: 'atlas-park' } }] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-2', requirements: [{ location: { zoneKey: 'perez-park' } }] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-3', requirements: [{ location: { zoneKey: 'atlas-park' } }] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-4', requirements: [{ location: { zoneKey: 'abandoned-sewer-network' } }] })),
         ]
 
-        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { by: 'ZONE_NAME' } })
+        const result = new BadgeIndex(data).searchBadges({ sort: { by: 'zone-key' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-4', 'badge-1', 'badge-3', 'badge-2'])
       })
 
-      test(`should sort unknown zone names to the end`, () => {
+      test(`should sort undefined or multiple zone names to the end`, () => {
         const data = [
-          new Badge(badgeDataFixture.create({ key: 'badge-1', zoneKey: 'atlas-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-2', zoneKey: 'unknown' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-3', zoneKey: 'perez-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-4', zoneKey: 'unexpected' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-5', zoneKey: 'abandoned-sewer-network' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-1', requirements: [{ location: { zoneKey: 'atlas-park' } }] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-2', requirements: [{ location: undefined }] })),
+          new Badge(badgeDataFixture.create({ key: 'badge-3', requirements: [{ location: { zoneKey: 'perez-park' } }] })),
+          new Badge(badgeDataFixture.create({
+            key: 'badge-4', requirements: [
+              badgeRequirementDataFixture.create({ location: { zoneKey: 'atlas-park' } }),
+              badgeRequirementDataFixture.create({ location: { zoneKey: 'perez-park' } }),
+            ],
+          })),
+          new Badge(badgeDataFixture.create({ key: 'badge-5', requirements: [{ location: { zoneKey: 'abandoned-sewer-network' } }] })),
         ]
 
-        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { by: 'ZONE_NAME' } })
+        const result = new BadgeIndex(data).searchBadges({ sort: { by: 'zone-key' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-5', 'badge-1', 'badge-3', 'badge-2', 'badge-4'])

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()
     })
   })