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

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

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

@@ -1,6 +1,6 @@
 import { Badge } 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,208 @@ describe(Badge.name, () => {
     })
   })
 
-  describe('partials', () => {
-    test(`should throw an error on duplicate key`, () => {
+  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' })
+    })
+  })
+
+  describe('alignment', () => {
+    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()
+    })
+  })
+
+  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 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 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('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' }))
+      expect(badge.effect).toEqual('foo')
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('effect').create())
+      expect(badge.effect).toBeUndefined()
+    })
+  })
+
+  describe('vidiotMapKey', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ vidiotMapKey: 'foo' }))
+      expect(badge.vidiotMapKey).toEqual('foo')
+    })
+
+    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 be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('setTitle').create())
+      expect(badge.setTitle).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 in same group`, () => {
+      const data = badgeDataFixture.create({
+        key: 'badge',
+        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({
-        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 badge partial key [foo]')
+      new Badge(data)
     })
   })
 
-  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.toBeUndefined()
+      expect(new Badge(data).getRequirement('foo')).not.toBeUndefined()
     })
 
-    test(`should throw error for unknown partial`, () => {
+    test(`should throw error 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')).toThrow('Unknown badge requirement key [foo]')
     })
   })
 })

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

@@ -2,7 +2,8 @@ import { CohContentDatabase } from '../../main'
 import { contentBundleFixture } from '../api/content-bundle.fixture'
 import { archetypeDataFixture } from '../api/archetype-data.fixture'
 import { badgeDataFixture } from '../api/badge-data.fixture'
-import { gameMapDataFixture } from '../api/game-map-data.fixture'
+import { zoneDataFixture } from '../api/zone-data.fixture'
+import { contactDataFixture } from '../api/contact-data.fixture'
 
 describe(CohContentDatabase.name, () => {
   test('should load a basic bundle', () => {
@@ -32,7 +33,7 @@ describe(CohContentDatabase.name, () => {
           archetypeDataFixture.create({ key: 'foo' }),
         ],
       })
-      expect(() => new CohContentDatabase(data)).toThrow('Duplicate archetype key [foo]')
+      expect(() => new CohContentDatabase(data)).toThrow(`Duplicate archetype key 'foo'`)
     })
 
     test(`should accept an undefined field`, () => {
@@ -68,22 +69,41 @@ describe(CohContentDatabase.name, () => {
     })
   })
 
-  describe('maps', () => {
-    test(`should throw an error on duplicate map`, () => {
+  describe('zones', () => {
+    test(`should throw an error on duplicate zone`, () => {
       const data = contentBundleFixture.create({
-        maps: [
-          gameMapDataFixture.create({ key: 'foo' }),
-          gameMapDataFixture.create({ key: 'foo' }),
+        zones: [
+          zoneDataFixture.create({ key: 'foo' }),
+          zoneDataFixture.create({ key: 'foo' }),
         ],
       })
-      expect(() => new CohContentDatabase(data)).toThrow('Duplicate map key [foo]')
+      expect(() => new CohContentDatabase(data)).toThrow(`Duplicate zone key 'foo'`)
     })
 
     test(`should accept an undefined field`, () => {
       const data = contentBundleFixture
-        .omit('maps')
+        .omit('zones')
         .create()
-      expect(() => new CohContentDatabase(data).maps).toHaveLength(0)
+      expect(() => new CohContentDatabase(data).zones).toHaveLength(0)
+    })
+  })
+
+  describe('contacts', () => {
+    test(`should throw an error on duplicate contact`, () => {
+      const data = contentBundleFixture.create({
+        contacts: [
+          contactDataFixture.create({ key: 'foo' }),
+          contactDataFixture.create({ key: 'foo' }),
+        ],
+      })
+      expect(() => new CohContentDatabase(data)).toThrow(`Duplicate contact key 'foo'`)
+    })
+
+    test(`should accept an undefined field`, () => {
+      const data = contentBundleFixture
+        .omit('contacts')
+        .create()
+      expect(() => new CohContentDatabase(data).contacts).toHaveLength(0)
     })
   })
 
@@ -101,25 +121,79 @@ describe(CohContentDatabase.name, () => {
         archetypes: [],
       })
 
-      expect(() => new CohContentDatabase(data).getArchetype('foo')).toThrow('Unknown archetype key [foo]')
+      expect(() => new CohContentDatabase(data).getArchetype('foo')).toThrow(`Unknown archetype key 'foo'`)
+    })
+  })
+
+  describe('getZone', () => {
+    test(`should retrieve zone from the index`, () => {
+      const data = contentBundleFixture.create({
+        zones: [zoneDataFixture.create({ key: 'foo' })],
+      })
+
+      expect(new CohContentDatabase(data).getZone('foo')).not.toBeUndefined()
+    })
+
+    test(`should throw error for unknown zone`, () => {
+      const data = contentBundleFixture.create({
+        zones: [],
+      })
+
+      expect(() => new CohContentDatabase(data).getZone('foo')).toThrow(`Unknown zone key 'foo'`)
+    })
+  })
+
+  describe('zoneExists', () => {
+    test(`should return true for a zone that exists`, () => {
+      const data = contentBundleFixture.create({
+        zones: [zoneDataFixture.create({ key: 'foo' })],
+      })
+
+      expect(new CohContentDatabase(data).zoneExists('foo')).toBeTruthy()
+    })
+
+    test(`should return false for a zone that does not exist`, () => {
+      const data = contentBundleFixture.create({
+        zones: [],
+      })
+
+      expect(new CohContentDatabase(data).zoneExists('foo')).toBeFalsy()
     })
   })
 
-  describe('getMap', () => {
-    test(`should retrieve map from the index`, () => {
+  describe('getContact', () => {
+    test(`should retrieve contact from the index`, () => {
       const data = contentBundleFixture.create({
-        maps: [gameMapDataFixture.create({ key: 'foo' })],
+        contacts: [contactDataFixture.create({ key: 'foo' })],
       })
 
-      expect(new CohContentDatabase(data).getMap('foo')).not.toBeUndefined()
+      expect(new CohContentDatabase(data).getContact('foo')).not.toBeUndefined()
     })
 
-    test(`should throw error for unknown map`, () => {
+    test(`should throw error for unknown contact`, () => {
       const data = contentBundleFixture.create({
-        maps: [],
+        contacts: [],
       })
 
-      expect(() => new CohContentDatabase(data).getMap('foo')).toThrow('Unknown map key [foo]')
+      expect(() => new CohContentDatabase(data).getContact('foo')).toThrow(`Unknown contact key 'foo'`)
+    })
+  })
+
+  describe('contactExists', () => {
+    test(`should return true for a contact that exists`, () => {
+      const data = contentBundleFixture.create({
+        contacts: [contactDataFixture.create({ key: 'foo' })],
+      })
+
+      expect(new CohContentDatabase(data).contactExists('foo')).toBeTruthy()
+    })
+
+    test(`should return false for a contact that does not exist`, () => {
+      const data = contentBundleFixture.create({
+        contacts: [],
+      })
+
+      expect(new CohContentDatabase(data).contactExists('foo')).toBeFalsy()
     })
   })
 
@@ -140,4 +214,37 @@ describe(CohContentDatabase.name, () => {
       expect(() => new CohContentDatabase(data).getBadge('foo')).toThrow('Unknown badge key [foo]')
     })
   })
+
+  describe('badgeExists', () => {
+    test(`should return true for a badge that exists`, () => {
+      const data = contentBundleFixture.create({
+        badges: [badgeDataFixture.create({ key: 'foo' })],
+      })
+
+      expect(new CohContentDatabase(data).badgeExists('foo')).toBeTruthy()
+    })
+
+    test(`should return false for a badge that does not exist`, () => {
+      const data = contentBundleFixture.create({
+        badges: [],
+      })
+
+      expect(new CohContentDatabase(data).badgeExists('foo')).toBeFalsy()
+    })
+  })
+
+  describe('searchBadges', () => {
+    test(`should search the badge list`, () => {
+      const data = contentBundleFixture.create({
+        badges: [
+          badgeDataFixture.create({ key: 'foo', name: [{ value: 'Foo' }] }),
+          badgeDataFixture.create({ key: 'bar', name: [{ value: 'Bar' }] }),
+        ],
+      })
+
+      const result = new CohContentDatabase(data).searchBadges({ query: { str: 'oo' } })
+      expect(result.totalItems).toBe(1)
+      expect(result.items.map(x => x.key)).toStrictEqual(['foo'])
+    })
+  })
 })