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

package/src/test/api/badge-requirement-type.test.ts

@@ -0,0 +1,31 @@
+import { BADGE_REQUIREMENT_TYPE, BadgeRequirementType } from '../../main'
+
+describe('BADGE_REQUIREMENT_TYPE', () => {
+  test('should be an array', () => {
+    expect(Array.isArray(BADGE_REQUIREMENT_TYPE)).toBeTruthy()
+  })
+
+  test('should not be empty', () => {
+    expect(BADGE_REQUIREMENT_TYPE).not.toHaveLength(0)
+  })
+
+  test('should contain only strings', () => {
+    for (const entry of BADGE_REQUIREMENT_TYPE) {
+      expect(typeof entry).toBe('string')
+    }
+  })
+
+  test('should contain all known badge requirement types', () => {
+    const expected = ['PLAQUE', 'BADGE', 'INVENTION', 'INVENTION_PLUS_ONE']
+    for (const category of expected) {
+      expect(BADGE_REQUIREMENT_TYPE).toContain(category)
+    }
+  })
+})
+
+describe('BadgeRequirementType', () => {
+  test('should be a usable type', () => {
+    const field: BadgeRequirementType = 'PLAQUE'
+    expect(field).toBe('PLAQUE')
+  })
+})

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

@@ -0,0 +1,13 @@
+import { defineFixture } from 'efate'
+import { ContactData } from '../../main'
+
+export const contactDataFixture = defineFixture<ContactData>((t) => {
+  t.key.as(index => `contact-${index}`)
+  t.name.as(index => [{ value: `Contact ${index}` }])
+  t.title?.as(index => [{ value: `Contact title ${index}` }])
+  t.zoneKey?.asString()
+  t.loc?.as(index => [index, index, index])
+  t.levelRange?.as(index => [index, index])
+  t.notes?.asLoremIpsum()
+  t.links?.as(() => [{ href: 'https://nouri.org' }])
+})

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

@@ -1,7 +1,7 @@
 import { defineFixture } from 'efate'
 import { Change, ContentBundle } from '../../main'
 import { archetypeDataFixture } from './archetype-data.fixture'
-import { gameMapDataFixture } from './game-map-data.fixture'
+import { zoneDataFixture } from './zone-data.fixture'
 import { badgeDataFixture } from './badge-data.fixture'
 
 export const contentBundleFixture = defineFixture<ContentBundle>((t) => {
@@ -10,7 +10,7 @@ export const contentBundleFixture = defineFixture<ContentBundle>((t) => {
   t.repository?.as(index => `https://nouri.org?id=${index}`)
   t.servers?.asArray()
   t.archetypes?.arrayOfFixture({ fixture: archetypeDataFixture })
-  t.maps?.arrayOfFixture({ fixture: gameMapDataFixture })
+  t.zones?.arrayOfFixture({ fixture: zoneDataFixture })
   t.badges?.arrayOfFixture({ fixture: badgeDataFixture })
   t.changelog?.arrayOfFixture({
     fixture: defineFixture<Change>((t) => {

package/src/test/api/content-bundle.test.ts

@@ -7,7 +7,7 @@ export const TEST_BUNDLE: ContentBundle = {
   badges: [TEST_BADGE],
 }
 
-describe('ServerGroupData', () => {
+describe('ContentBundle', () => {
   test('should be a usable interface', () => {
     expect(TEST_BUNDLE).not.toBeUndefined()
   })

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

@@ -0,0 +1,8 @@
+import { ZoneData } from '../../main'
+import { defineFixture } from 'efate'
+
+export const zoneDataFixture = defineFixture<ZoneData>((t) => {
+  t.key.as(index => `zone-${index}`)
+  t.name.as(index => `Zone ${index}`)
+  t.links?.as(() => [{ href: 'https://nouri.org' }])
+})

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

@@ -1,11 +1,11 @@
 import { badgeDataFixture } from '../api/badge-data.fixture'
-import { Badge, BadgeIndex, GameMap } from '../../main'
-import { gameMapDataFixture } from '../api/game-map-data.fixture'
+import { Badge, BadgeIndex, Zone } from '../../main'
+import { zoneDataFixture } from '../api/zone-data.fixture'
 
-const TEST_MAPS = [
-  new GameMap(gameMapDataFixture.create({ key: 'atlas-park', name: 'Atlas Park' })),
-  new GameMap(gameMapDataFixture.create({ key: 'perez-park', name: 'Perez Park' })),
-  new GameMap(gameMapDataFixture.create({ key: 'abandoned-sewer-network', name: 'Abandoned Sewer Network' })),
+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' })),
 ]
 
 describe(BadgeIndex.name, () => {
@@ -31,6 +31,18 @@ describe(BadgeIndex.name, () => {
     })
   })
 
+  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 false for a badge that does not exist`, () => {
+      expect(new BadgeIndex([]).badgeExists('foo')).toBeFalsy()
+    })
+  })
+
   describe('searchBadges', () => {
     test(`should return everything for an empty query`, () => {
       const data = [
@@ -200,15 +212,15 @@ describe(BadgeIndex.name, () => {
 
       test(`should filter on badge type`, () => {
         const data = [
-          new Badge(badgeDataFixture.create({ key: 'badge-1', mapKey: 'atlas-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-2', mapKey: 'perez-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-3', mapKey: 'abandoned-sewer-network' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-4', mapKey: 'atlas-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-5', mapKey: 'perez-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-6', mapKey: undefined })),
+          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 })),
         ]
 
-        const result = new BadgeIndex(data).searchBadges({ filter: { mapKey: 'perez-park' } })
+        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'])
       })
@@ -359,6 +371,26 @@ describe(BadgeIndex.name, () => {
         const result = new BadgeIndex(data).searchBadges()
         expect(result.totalPages).toBe(1)
       })
+
+      test(`should return the last page if a page is requested past the max`, () => {
+        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' })),
+          new Badge(badgeDataFixture.create({ key: 'badge-5' })),
+        ]
+
+        const result = new BadgeIndex(data).searchBadges({ pageSize: 2, page: 10 })
+        const keys = result.items.map(x => x.key)
+        expect(keys).toStrictEqual(['badge-5'])
+        expect(result.page).toBe(3)
+      })
+
+      test(`should return the first page if a page is requested lower than 1`, () => {
+        const result = new BadgeIndex([]).searchBadges({ page: -10 })
+        expect(result.page).toBe(1)
+      })
     })
 
     describe('sort', () => {
@@ -370,7 +402,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-4' })),
         ]
 
-        const result = new BadgeIndex(data, TEST_MAPS).searchBadges()
+        const result = new BadgeIndex(data, TEST_Zones).searchBadges()
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-1', 'badge-2', 'badge-3', 'badge-4'])
@@ -384,7 +416,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-4' })),
         ]
 
-        const result = new BadgeIndex(data, TEST_MAPS).searchBadges({ sort: { dir: 'DESC' } })
+        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { dir: 'DESC' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-4', 'badge-3', 'badge-2', 'badge-1'])
@@ -397,7 +429,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-3', name: [{ value: 'AAB' }] })),
         ]
 
-        const result = new BadgeIndex(data, TEST_MAPS).searchBadges({ sort: { by: 'BADGE_NAME' } })
+        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { by: 'BADGE_NAME' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-3', 'badge-1', 'badge-2'])
@@ -410,7 +442,7 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-3', name: [{ value: 'AAB' }] })),
         ]
 
-        const result = new BadgeIndex(data, TEST_MAPS).searchBadges({ sort: { by: 'BADGE_NAME', dir: 'DESC' } })
+        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { by: 'BADGE_NAME', dir: 'DESC' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-2', 'badge-1', 'badge-3'])
@@ -423,62 +455,62 @@ describe(BadgeIndex.name, () => {
           new Badge(badgeDataFixture.create({ key: 'badge-3', name: [{ value: 'AAB' }] })),
         ]
 
-        const result = new BadgeIndex(data, TEST_MAPS).searchBadges({ sort: { by: 'BADGE_NAME' } })
+        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { by: 'BADGE_NAME' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-3', 'badge-1', 'badge-2'])
       })
 
-      test(`should sort by map name`, () => {
+      test(`should sort by zone name`, () => {
         const data = [
-          new Badge(badgeDataFixture.create({ key: 'badge-1', mapKey: 'atlas-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-2', mapKey: 'perez-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-3', mapKey: 'abandoned-sewer-network' })),
+          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' })),
         ]
 
-        const result = new BadgeIndex(data, TEST_MAPS).searchBadges({ sort: { by: 'MAP_NAME' } })
+        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { by: 'ZONE_NAME' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-3', 'badge-1', 'badge-2'])
       })
 
-      test(`should sort by map name descending`, () => {
+      test(`should sort by zone name descending`, () => {
         const data = [
-          new Badge(badgeDataFixture.create({ key: 'badge-1', mapKey: 'atlas-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-2', mapKey: 'perez-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-3', mapKey: 'abandoned-sewer-network' })),
+          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' })),
         ]
 
-        const result = new BadgeIndex(data, TEST_MAPS).searchBadges({ sort: { by: 'MAP_NAME', dir: 'DESC' } })
+        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { by: 'ZONE_NAME', dir: 'DESC' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-2', 'badge-1', 'badge-3'])
       })
 
-      test(`should maintain canonical as secondary sort when sorting by map name`, () => {
+      test(`should maintain canonical as secondary sort when sorting by zone name`, () => {
         const data = [
-          new Badge(badgeDataFixture.create({ key: 'badge-1', mapKey: 'atlas-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-2', mapKey: 'perez-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-3', mapKey: 'atlas-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-4', mapKey: 'abandoned-sewer-network' })),
+          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' })),
         ]
 
-        const result = new BadgeIndex(data, TEST_MAPS).searchBadges({ sort: { by: 'MAP_NAME' } })
+        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { by: 'ZONE_NAME' } })
 
         const keys = result.items.map(x => x.key)
         expect(keys).toStrictEqual(['badge-4', 'badge-1', 'badge-3', 'badge-2'])
       })
 
-      test(`should sort unknown map names to the end`, () => {
+      test(`should sort unknown zone names to the end`, () => {
         const data = [
-          new Badge(badgeDataFixture.create({ key: 'badge-1', mapKey: 'atlas-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-2', mapKey: 'unknown' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-3', mapKey: 'perez-park' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-4', mapKey: 'unexpected' })),
-          new Badge(badgeDataFixture.create({ key: 'badge-5', mapKey: 'abandoned-sewer-network' })),
+          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' })),
         ]
 
-        const result = new BadgeIndex(data, TEST_MAPS).searchBadges({ sort: { by: 'MAP_NAME' } })
+        const result = new BadgeIndex(data, TEST_Zones).searchBadges({ sort: { by: 'ZONE_NAME' } })
 
         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

@@ -0,0 +1,180 @@
+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('zoneKey', () => {
+    test('should be set from the data', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ zoneKey: 'zone123' }))
+      expect(requirement.zoneKey).toEqual('zone123')
+    })
+
+    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 be optional', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('vidiotMapKey').create())
+      expect(requirement.vidiotMapKey).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('missionName', () => {
+    test('should be set from the data', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ missionName: 'foo' }))
+      expect(requirement.missionName).toEqual('foo')
+    })
+
+    test('should be optional', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('missionName').create())
+      expect(requirement.missionName).toBeUndefined()
+    })
+  })
+
+  describe('contactKey', () => {
+    test('should be set from the data', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ contactKey: 'foo' }))
+      expect(requirement.contactKey).toEqual('foo')
+    })
+
+    test('should be optional', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('contactKey').create())
+      expect(requirement.contactKey).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('inventionCount', () => {
+    test('should be set from the data', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.create({ inventionCount: 5 }))
+      expect(requirement.inventionCount).toEqual(5)
+    })
+
+    test('should be optional', () => {
+      const requirement = new BadgeRequirement(badgeRequirementDataFixture.omit('inventionCount').create())
+      expect(requirement.inventionCount).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)
+    })
+  })
+})