coh-content-db 2.0.0-rc.9 → 2.0.0

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

@@ -7,53 +7,27 @@ import { missionDataFixture } from '../api/mission-data.fixture'
 import { bundleDataFixture } from '../api/bundle-data.fixture'
 
 describe(CohContentDatabase.name, () => {
-  describe('load', () => {
+  describe('Constructor', () => {
     test('should load a basic bundle', () => {
-      const database = new CohContentDatabase()
-      database.load({})
-    })
-
-    test('should reset the database if load is called again', () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({
-        header: { name: 'Homecoming' },
-        servers: ['Test'],
-        archetypes: [archetypeDataFixture.create()],
-        zones: [zoneDataFixture.create()],
-        contacts: [contactDataFixture.create()],
-        missions: [missionDataFixture.create()],
-        badges: [badgeDataFixture.create()],
-      }))
-
-      expect(database.header?.name).toEqual('Homecoming')
-      expect(database.servers).toHaveLength(1)
-      expect(database.archetypes).toHaveLength(1)
-      expect(database.zones).toHaveLength(1)
-      expect(database.contacts).toHaveLength(1)
-      expect(database.missions).toHaveLength(1)
-      expect(database.badges).toHaveLength(1)
-
-      database.load(bundleDataFixture.create({ header: { name: 'Reset' } }))
-      expect(database.header?.name).toEqual('Reset')
-      expect(database.servers).toHaveLength(0)
-      expect(database.archetypes).toHaveLength(0)
-      expect(database.zones).toHaveLength(0)
-      expect(database.contacts).toHaveLength(0)
-      expect(database.missions).toHaveLength(0)
-      expect(database.badges).toHaveLength(0)
+      new CohContentDatabase(bundleDataFixture.create())
     })
   })
 
   describe('header', () => {
-    test(`should be undefined if not initialized`, () => {
-      const database = new CohContentDatabase()
-      expect(database.header).toBeUndefined()
+    test(`should not accept an undefined field`, () => {
+      expect(() =>
+        new CohContentDatabase(
+          bundleDataFixture.omit('header').create(),
+        ),
+      ).toThrow('Missing header data')
     })
 
     test(`should load values from bundle`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture
-        .create({ header: { name: 'Homecoming' } }))
+      const database = new CohContentDatabase(
+        bundleDataFixture.create(
+          { header: { name: 'Homecoming' } },
+        ),
+      )
 
       expect(database.header?.name).toBe('Homecoming')
     })
@@ -61,153 +35,127 @@ describe(CohContentDatabase.name, () => {
 
   describe('servers', () => {
     test(`should accept an undefined field`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture
-        .omit('servers')
-        .create())
-
-      expect(database.servers).toHaveLength(0)
-    })
-
-    test(`should be empty if uninitialized`, () => {
-      const database = new CohContentDatabase()
+      const database = new CohContentDatabase(
+        bundleDataFixture.omit('servers').create(),
+      )
       expect(database.servers).toHaveLength(0)
     })
 
     test(`should load values from bundle`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture
-        .create({ servers: ['Foo', 'Bar'] }))
-
+      const database = new CohContentDatabase(
+        bundleDataFixture
+          .create({ servers: ['Foo', 'Bar'] }),
+      )
       expect(database.servers).toStrictEqual(['Foo', 'Bar'])
     })
   })
 
   describe('archetypes', () => {
-    test(`should throw an error on duplicate key`, () => {
-      const database = new CohContentDatabase()
-      expect(() => database.load(bundleDataFixture.create({
-        archetypes: [
-          archetypeDataFixture.create({ key: 'foo' }),
-          archetypeDataFixture.create({ key: 'foo' }),
-        ],
-      }))).toThrow(`Duplicate key [foo]`)
-    })
-
     test(`should accept an undefined field`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture
+      const database = new CohContentDatabase(bundleDataFixture
         .omit('archetypes')
         .create())
       expect(database.archetypes).toHaveLength(0)
     })
 
     test(`should load data from bundle`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture
-        .create({ archetypes: [archetypeDataFixture.create({ key: 'foo' })] }))
+      const database = new CohContentDatabase(
+        bundleDataFixture
+          .create({ archetypes: [archetypeDataFixture.create({ key: 'foo' })] }),
+      )
       expect(database.getArchetype('foo')).not.toBeUndefined()
     })
   })
 
   describe('badges', () => {
-    test(`should throw an error on duplicate key`, () => {
-      const database = new CohContentDatabase()
-      expect(() => database.load(bundleDataFixture.create({
-        badges: [
-          badgeDataFixture.create({ key: 'foo' }),
-          badgeDataFixture.create({ key: 'foo' }),
-        ],
-      }))).toThrow('Duplicate key [foo]')
-    })
-
     test(`should accept an undefined field`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture
-        .omit('badges')
-        .create())
+      const database = new CohContentDatabase(
+        bundleDataFixture.omit('badges').create(),
+      )
       expect(database.badges).toHaveLength(0)
     })
-  })
 
-  describe('zones', () => {
-    test(`should throw an error on duplicate zone`, () => {
-      const database = new CohContentDatabase()
-      expect(() => database.load(bundleDataFixture.create({
-        zones: [
-          zoneDataFixture.create({ key: 'foo' }),
-          zoneDataFixture.create({ key: 'foo' }),
-        ],
-      }))).toThrow(`Duplicate key [foo]`)
+    test(`should load data from bundle`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture
+          .create({ badges: [badgeDataFixture.create({ key: 'foo' })] }),
+      )
+      expect(database.getBadge('foo')).not.toBeUndefined()
     })
+  })
 
+  describe('zones', () => {
     test(`should accept an undefined field`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture
-        .omit('zones')
-        .create())
+      const database = new CohContentDatabase(
+        bundleDataFixture.omit('zones').create(),
+      )
       expect(database.zones).toHaveLength(0)
     })
-  })
 
-  describe('contacts', () => {
-    test(`should throw an error on duplicate contact`, () => {
-      const database = new CohContentDatabase()
-      expect(() => database.load(bundleDataFixture.create({
-        contacts: [
-          contactDataFixture.create({ key: 'foo' }),
-          contactDataFixture.create({ key: 'foo' }),
-        ],
-      }))).toThrow(`Duplicate key [foo]`)
+    test(`should load data from bundle`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture
+          .create({ zones: [zoneDataFixture.create({ key: 'foo' })] }),
+      )
+      expect(database.getZone('foo')).not.toBeUndefined()
     })
+  })
 
+  describe('contacts', () => {
     test(`should accept an undefined field`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture
-        .omit('contacts')
-        .create())
+      const database = new CohContentDatabase(
+        bundleDataFixture.omit('contacts').create(),
+      )
       expect(database.contacts).toHaveLength(0)
     })
-  })
 
-  describe('missions', () => {
-    test(`should throw an error on duplicate mission`, () => {
-      const database = new CohContentDatabase()
-      expect(() => database.load(bundleDataFixture.create({
-        missions: [
-          missionDataFixture.create({ key: 'foo' }),
-          missionDataFixture.create({ key: 'foo' }),
-        ],
-      }))).toThrow(`Duplicate key [foo]`)
+    test(`should load data from bundle`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture
+          .create({ contacts: [contactDataFixture.create({ key: 'foo' })] }),
+      )
+      expect(database.getContact('foo')).not.toBeUndefined()
     })
+  })
 
+  describe('missions', () => {
     test(`should accept an undefined field`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture
-        .omit('missions')
-        .create())
+      const database = new CohContentDatabase(
+        bundleDataFixture.omit('missions').create(),
+      )
       expect(database.missions).toHaveLength(0)
     })
+
+    test(`should load data from bundle`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture
+          .create({ missions: [missionDataFixture.create({ key: 'foo' })] }),
+      )
+      expect(database.getMission('foo')).not.toBeUndefined()
+    })
   })
 
   describe('getArchetype', () => {
     test(`should retrieve archetype from the index`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({
-        archetypes: [archetypeDataFixture.create({ key: 'foo' })],
-      }))
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({
+          archetypes: [archetypeDataFixture.create({ key: 'foo' })],
+        }),
+      )
       expect(database.getArchetype('foo')).not.toBeUndefined()
     })
 
     test(`should return undefined for unknown archetype`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({ archetypes: [] }))
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ archetypes: [] }),
+      )
       expect(database.getArchetype('foo')).toBeUndefined()
     })
 
     test(`should return undefined for undefined key`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({ archetypes: [] }))
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ archetypes: [] }),
+      )
       const key = undefined
       expect(database.getArchetype(key)).toBeUndefined()
     })
@@ -215,23 +163,23 @@ describe(CohContentDatabase.name, () => {
 
   describe('getZone', () => {
     test(`should retrieve zone from the index`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({
-        zones: [zoneDataFixture.create({ key: 'foo' })],
-      }))
-
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({
+          zones: [zoneDataFixture.create({ key: 'foo' })],
+        }),
+      )
       expect(database.getZone('foo')).not.toBeUndefined()
     })
 
     test(`should return undefined for unknown zone`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({ zones: [] }))
+      const database = new CohContentDatabase(bundleDataFixture.create({ zones: [] }))
       expect(database.getZone('foo')).toBeUndefined()
     })
 
     test(`should return undefined for undefined key`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({ zones: [] }))
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ zones: [] }),
+      )
       const key = undefined
       expect(database.getZone(key)).toBeUndefined()
     })
@@ -239,22 +187,25 @@ describe(CohContentDatabase.name, () => {
 
   describe('getContact', () => {
     test(`should retrieve contact from the index`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({
-        contacts: [contactDataFixture.create({ key: 'foo' })],
-      }))
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({
+          contacts: [contactDataFixture.create({ key: 'foo' })],
+        }),
+      )
       expect(database.getContact('foo')).not.toBeUndefined()
     })
 
     test(`should return undefined for unknown contact`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({ contacts: [] }))
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ contacts: [] }),
+      )
       expect(database.getContact('foo')).toBeUndefined()
     })
 
     test(`should return undefined for undefined key`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({ contacts: [] }))
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ contacts: [] }),
+      )
       const key = undefined
       expect(database.getContact(key)).toBeUndefined()
     })
@@ -262,22 +213,25 @@ describe(CohContentDatabase.name, () => {
 
   describe('getMission', () => {
     test(`should retrieve mission from the index`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({
-        missions: [missionDataFixture.create({ key: 'foo' })],
-      }))
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({
+          missions: [missionDataFixture.create({ key: 'foo' })],
+        }),
+      )
       expect(database.getMission('foo')).not.toBeUndefined()
     })
 
     test(`should return undefined for unknown mission`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({ missions: [] }))
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ missions: [] }),
+      )
       expect(database.getMission('foo')).toBeUndefined()
     })
 
     test(`should return undefined for undefined key`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({ missions: [] }))
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ missions: [] }),
+      )
       const key = undefined
       expect(database.getMission(key)).toBeUndefined()
     })
@@ -285,22 +239,25 @@ describe(CohContentDatabase.name, () => {
 
   describe('getBadge', () => {
     test(`should retrieve badge from the index`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({
-        badges: [badgeDataFixture.create({ key: 'foo' })],
-      }))
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({
+          badges: [badgeDataFixture.create({ key: 'foo' })],
+        }),
+      )
       expect(database.getBadge('foo')).not.toBeUndefined()
     })
 
     test(`should return undefined for unknown badge`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({ badges: [] }))
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ badges: [] }),
+      )
       expect(database.getBadge('foo')).toBeUndefined()
     })
 
     test(`should return undefined for undefined key`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({ badges: [] }))
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ badges: [] }),
+      )
       const key = undefined
       expect(database.getBadge(key)).toBeUndefined()
     })
@@ -308,16 +265,18 @@ describe(CohContentDatabase.name, () => {
 
   describe('searchBadges', () => {
     test(`should search the badge list`, () => {
-      const database = new CohContentDatabase()
-      database.load(bundleDataFixture.create({
-        badges: [
-          badgeDataFixture.create({ key: 'foo', name: [{ value: 'Foo' }] }),
-          badgeDataFixture.create({ key: 'bar', name: [{ value: 'Bar' }] }),
-        ],
-      }))
-
-      const result = database.searchBadges({ query: { str: 'oo' } })
-      expect(result.totalItems).toBe(1)
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({
+          badges: [
+            badgeDataFixture.create({ key: 'foo', name: [{ value: 'Foo' }] }),
+            badgeDataFixture.create({ key: 'bar', name: [{ value: 'Bar' }] }),
+          ],
+        }),
+      )
+
+      const result = database.searchBadges({ query: { str: 'oo', fields: ['name'] } })
+      expect(result.matchedItemCount).toBe(1)
+      expect(result.totalItemCount).toBe(2)
       expect(result.items.map(x => x.key)).toStrictEqual(['foo'])
     })
   })

package/src/test/db/contact.test.ts

@@ -62,7 +62,8 @@ describe(Contact.name, () => {
   describe('levelRange', () => {
     test(`should be set from the data`, () => {
       const contact = new Contact(contactDataFixture.create({ levelRange: [1, 2] }))
-      expect(contact.levelRange).toStrictEqual([1, 2])
+      expect(contact?.levelRange?.min).toEqual(1)
+      expect(contact?.levelRange?.max).toEqual(2)
     })
 
     test(`should be optional`, () => {

package/src/test/db/level-range.test.ts

@@ -0,0 +1,47 @@
+import { LevelRange } from '../../main'
+
+describe(LevelRange.name, () => {
+  describe('Constructor', () => {
+    test('should accept a full array (5-10)', () => {
+      const range = new LevelRange([5, 10])
+      expect(range).toBeDefined()
+      expect(range.min).toEqual(5)
+      expect(range.max).toEqual(10)
+    })
+
+    test('should accept a partial array (15+)', () => {
+      const range = new LevelRange([15])
+      expect(range).toBeDefined()
+      expect(range.min).toEqual(15)
+      expect(range.max).toBeUndefined()
+    })
+
+    test('should not coalesce a explicit max of 50 (20-50)', () => {
+      const range = new LevelRange([20, 50])
+      expect(range).toBeDefined()
+      expect(range.min).toEqual(20)
+      expect(range.max).toEqual(50)
+    })
+
+    test('should accept a single-level range (1-1)', () => {
+      const range = new LevelRange([1, 1])
+      expect(range).toBeDefined()
+      expect(range.min).toEqual(1)
+      expect(range.max).toEqual(1)
+    })
+
+    test('should accept a zero value (0-0)', () => {
+      const range = new LevelRange([0, 0])
+      expect(range).toBeDefined()
+      expect(range.min).toEqual(0)
+      expect(range.max).toEqual(0)
+    })
+
+    test('should accept a number (5+)', () => {
+      const range = new LevelRange(5)
+      expect(range).toBeDefined()
+      expect(range.min).toEqual(5)
+      expect(range.max).toBeUndefined()
+    })
+  })
+})

package/src/test/db/mission.test.ts

@@ -56,8 +56,9 @@ describe(Mission.name, () => {
 
   describe('levelRange', () => {
     test(`should be set from the data`, () => {
-      const mission = new Mission(missionDataFixture.create({ levelRange: [1, 2] }))
-      expect(mission.levelRange).toStrictEqual([1, 2])
+      const mission = new Mission(missionDataFixture.create({ levelRange: 25 }))
+      expect(mission?.levelRange?.min).toEqual(25)
+      expect(mission?.levelRange?.max).toBeUndefined()
     })
 
     test(`should be optional`, () => {
@@ -105,13 +106,14 @@ describe(Mission.name, () => {
 
     describe('levelRange', () => {
       test(`should be set from the data`, () => {
-        const mission = new Mission(missionDataFixture.create({ flashback: { levelRange: [1, 2] } }))
-        expect(mission.flashback?.levelRange).toStrictEqual([1, 2])
+        const mission = new Mission(missionDataFixture.create({ flashback: { levelRange: [1, 20] } }))
+        expect(mission.flashback?.levelRange?.min).toEqual(1)
+        expect(mission.flashback?.levelRange?.max).toEqual(20)
       })
 
-      test(`should default to the mission value`, () => {
+      test(`should *not* default to the mission value due to Ouro level grouping`, () => {
         const mission = new Mission(missionDataFixture.create({ levelRange: [1, 2], flashback: missionFlashbackDataFixture.omit('levelRange').create() }))
-        expect(mission.flashback?.levelRange).toStrictEqual([1, 2])
+        expect(mission.flashback?.levelRange).toBeUndefined()
       })
 
       test(`should be optional`, () => {

package/src/test/db/morality-list.test.ts

@@ -29,7 +29,7 @@ describe(MoralityList.name, () => {
       expect(new MoralityList().items).toStrictEqual(['hero', 'vigilante', 'villain', 'rogue', 'resistance', 'loyalist'])
     })
 
-    test('should treat empty as no values', () => {
+    test('should treat explicit empty as no values', () => {
       expect(new MoralityList([]).items).toStrictEqual([])
     })
   })

package/src/test/db/set-title-ids.test.ts

@@ -0,0 +1,19 @@
+import { SetTitleIds } from '../../main'
+
+describe(SetTitleIds.name, () => {
+  describe('Constructor', () => {
+    test('should accept both primal and praetorian values', () => {
+      const ids = new SetTitleIds([5, 10])
+      expect(ids).toBeDefined()
+      expect(ids.primal).toEqual(5)
+      expect(ids.praetorian).toEqual(10)
+    })
+
+    test('should accept primal only', () => {
+      const ids = new SetTitleIds([1])
+      expect(ids).toBeDefined()
+      expect(ids.primal).toEqual(1)
+      expect(ids.praetorian).toBeUndefined()
+    })
+  })
+})