coh-content-db 1.4.1 → 2.0.0-rc.1

package/src/test/api/badge-data.test.ts

@@ -0,0 +1,15 @@
+import { BadgeData } from '../../main'
+
+// If you change this test, update the example in the README as well
+export const TEST_BADGE: BadgeData = {
+  key: 'test-badge',
+  type: 'ACHIEVEMENT',
+  name: [{ value: 'Test Badge' }, { alignment: 'P', value: 'My Badge for Praetorians' }],
+  alignment: ['H', 'V', 'P'],
+}
+
+describe('BadgeData', () => {
+  test('should be a usable interface', () => {
+    expect(TEST_BADGE).not.toBeNull()
+  })
+})

package/src/test/api/badge-partial-data.fixture.ts

@@ -0,0 +1,17 @@
+import { defineFixture } from 'efate'
+import { BADGE_PARTIAL_TYPE, BadgePartialData, ENHANCEMENT_CATEGORY, PLAQUE_TYPE } from '../../main'
+
+export const badgePartialDataFixture = defineFixture<BadgePartialData>((t) => {
+  t.key.as(index => `badge-partial-${index}`)
+  t.type.pickFrom([...BADGE_PARTIAL_TYPE])
+  t.mapKey?.asString()
+  t.loc?.asArray()
+  t.plaqueType?.pickFrom([...PLAQUE_TYPE])
+  t.inscription?.asLoremIpsum()
+  t.vidiotMapKey?.asString()
+  t.badgeKey?.as(index => `badge-${index}`)
+  t.inventionLevel?.asNumber()
+  t.inventionTypes?.pickFrom([...ENHANCEMENT_CATEGORY])
+  t.inventionCount?.asNumber()
+  t.notes?.asLoremIpsum()
+})

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

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

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

@@ -0,0 +1,35 @@
+import { BADGE_TYPE, BadgeType } from '../../main'
+
+describe('BADGE_TYPE', () => {
+  test('should be an array', () => {
+    expect(Array.isArray(BADGE_TYPE)).toBeTruthy()
+  })
+
+  test('should not be empty', () => {
+    expect(BADGE_TYPE).not.toHaveLength(0)
+  })
+
+  test('should contain only strings', () => {
+    for (const entry of BADGE_TYPE) {
+      expect(typeof entry).toBe('string')
+    }
+  })
+
+  test('should contain all known basic badge types', () => {
+    const expected = [
+      'EXPLORATION', 'HISTORY', 'ACCOMPLISHMENT', 'ACHIEVEMENT', 'ACCOLADE',
+      'GLADIATOR', 'VETERAN', 'PVP', 'INVENTION', 'DEFEAT',
+      'EVENT', 'OUROBOROS', 'CONSIGNMENT', 'DAY_JOB', 'AE',
+    ]
+    for (const category of expected) {
+      expect(BADGE_TYPE).toContain(category)
+    }
+  })
+})
+
+describe('BadgeType', () => {
+  test('should be a usable type', () => {
+    const field: BadgeType = 'EXPLORATION'
+    expect(field).toBe('EXPLORATION')
+  })
+})

package/src/test/api/enhancement-category.test.ts

@@ -0,0 +1,35 @@
+import { ENHANCEMENT_CATEGORY, EnhancementCategory } from '../../main'
+
+describe('ENHANCEMENT_CATEGORY', () => {
+  test('should be an array', () => {
+    expect(Array.isArray(ENHANCEMENT_CATEGORY)).toBeTruthy()
+  })
+
+  test('should not be empty', () => {
+    expect(ENHANCEMENT_CATEGORY).not.toHaveLength(0)
+  })
+
+  test('should contain only strings', () => {
+    for (const entry of ENHANCEMENT_CATEGORY) {
+      expect(typeof entry).toBe('string')
+    }
+  })
+
+  test('should contain all known default enhancement categories', () => {
+    const expected = [
+      'DEFENSE_DEBUFF', 'TO_HIT_DEBUFF', 'TAUNT', 'CONFUSE', 'HEALING', 'DEFENSE_BUFF', 'RESIST_DAMAGE', 'INTANGIBILITY', 'SLEEP', 'SLOW', 'HOLD', 'STUN', 'IMMOBILIZE',
+      'FEAR', 'ENDURANCE_MODIFICATION', 'ENDURANCE_REDUCTION', 'RECHARGE_REDUCTION', 'INTERRUPT_DURATION', 'ACCURACY', 'TO_HIT_BUFF', 'DAMAGE', 'KNOCKBACK', 'RUN_SPEED',
+      'JUMP', 'FLY_SPEED', 'RANGE',
+    ]
+    for (const category of expected) {
+      expect(ENHANCEMENT_CATEGORY).toContain(category)
+    }
+  })
+})
+
+describe('EnhancementCategory', () => {
+  test('should be a usable type', () => {
+    const field: EnhancementCategory = 'RUN_SPEED'
+    expect(field).toBe('RUN_SPEED')
+  })
+})

package/src/test/api/game-map-data.fixture.ts

@@ -0,0 +1,10 @@
+import { GameMapData } from '../../main'
+import { defineFixture } from 'efate'
+import { vidiotMapFixture } from './vidiot-map.fixture'
+
+export const gameMapDataFixture = defineFixture<GameMapData>((t) => {
+  t.key.as(index => `map-${index}`)
+  t.name.as(index => `Map ${index}`)
+  t.links?.asArray([{ href: 'https://nouri.org' }])
+  t.vidiotMaps?.arrayOfFixture({ fixture: vidiotMapFixture })
+})

package/src/test/api/plaque-type.test.ts

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

package/src/test/api/server-group-data.fixture.ts

@@ -0,0 +1,23 @@
+import { defineFixture } from 'efate'
+import { Change, ServerGroupData } from '../../main'
+import { archetypeDataFixture } from './archetype-data.fixture'
+import { gameMapDataFixture } from './game-map-data.fixture'
+import { badgeDataFixture } from './badge-data.fixture'
+
+export const serverGroupDataFixture = defineFixture<ServerGroupData>((t) => {
+  t.key.as(index => `server-group-${index}`)
+  t.name.as(index => `Server Group ${index}`)
+  t.description?.asLoremIpsum()
+  t.repository?.as(index => `https://nouri.org?id=${index}`)
+  t.servers?.asArray()
+  t.archetypes?.arrayOfFixture({ fixture: archetypeDataFixture })
+  t.maps?.arrayOfFixture({ fixture: gameMapDataFixture })
+  t.badges?.arrayOfFixture({ fixture: badgeDataFixture })
+  t.changelog?.arrayOfFixture({
+    fixture: defineFixture<Change>((t) => {
+      t.version.as(index => `${index}`)
+      t.date.as(() => new Date())
+      t.description?.asLoremIpsum()
+    }),
+  })
+})

package/src/test/api/server-group-data.test.ts

@@ -0,0 +1,15 @@
+import { ServerGroupData } from '../../main'
+import { TEST_BADGE } from './badge-data.test'
+
+// If you change this test, update the example in the README as well
+export const TEST_SERVER_GROUP: ServerGroupData = {
+  key: 'my-server-group',
+  name: 'My Server Group',
+  badges: [TEST_BADGE],
+}
+
+describe('ServerGroupData', () => {
+  test('should be a usable interface', () => {
+    expect(TEST_SERVER_GROUP).not.toBeNull()
+  })
+})

package/src/test/api/sex.test.ts

@@ -0,0 +1,31 @@
+import { Sex, SEX } from '../../main'
+
+describe('SEX', () => {
+  test('should be an array', () => {
+    expect(Array.isArray(SEX)).toBeTruthy()
+  })
+
+  test('should not be empty', () => {
+    expect(SEX).not.toHaveLength(0)
+  })
+
+  test('should contain only strings', () => {
+    for (const entry of SEX) {
+      expect(typeof entry).toBe('string')
+    }
+  })
+
+  test('should contain all known sexes', () => {
+    const expected = ['M', 'F']
+    for (const category of expected) {
+      expect(SEX).toContain(category)
+    }
+  })
+})
+
+describe('Sex', () => {
+  test('should be a usable type', () => {
+    const field: Sex = 'M'
+    expect(field).toBe('M')
+  })
+})

package/src/test/api/vidiot-map-point-of-interest.fixture.ts

@@ -0,0 +1,10 @@
+import { defineFixture } from 'efate'
+import { VidiotMapPointOfInterest } from '../../main'
+
+export const vidiotMapPointOfInterestFixture = defineFixture<VidiotMapPointOfInterest>((t) => {
+  t.pos?.as(index => [index, index])
+  t.notes?.asLoremIpsum()
+  t.mapKey?.as(index => `map-${index}`)
+  t.badgeKey?.as(index => `badge-${index}`)
+  t.badgePartialKey?.as(index => `partial-${index}`)
+})

package/src/test/api/vidiot-map.fixture.ts

@@ -0,0 +1,9 @@
+import { defineFixture } from 'efate'
+import { VidiotMap } from '../../main'
+import { vidiotMapPointOfInterestFixture } from './vidiot-map-point-of-interest.fixture'
+
+export const vidiotMapFixture = defineFixture<VidiotMap>((t) => {
+  t.imageUrl.as(index => `https://nouri.org?id=${index}`)
+  t.name?.as(index => `Vidiot Map ${index}`)
+  t.pointsOfInterest?.arrayOfFixture({ fixture: vidiotMapPointOfInterestFixture })
+})

package/src/test/changelog.test.ts

@@ -0,0 +1,36 @@
+import { CHANGELOG } from '../main'
+
+describe('CHANGELOG', () => {
+  test('should be extant', () => {
+    expect(CHANGELOG).not.toBeNull()
+    expect(CHANGELOG).not.toBeUndefined()
+  })
+
+  test('should be an array', () => {
+    expect(Array.isArray(CHANGELOG)).toBeTruthy()
+  })
+
+  test('should have only semver versions', () => {
+    // semver.org - https://regex101.com/r/vkijKf/1/
+    const pattern = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/
+
+    for (const change of CHANGELOG) {
+      expect(pattern.test(change.version)).toBeTruthy()
+    }
+  })
+
+  test('should have dates', () => {
+    for (const change of CHANGELOG) {
+      const date = change.date
+      expect(date).not.toBeNull()
+      expect(date).not.toBeUndefined()
+    }
+  })
+
+  test('should have descriptions', () => {
+    for (const change of CHANGELOG) {
+      expect(change).not.toBeNull()
+      expect(change).not.toBeUndefined()
+    }
+  })
+})

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

@@ -0,0 +1,223 @@
+import { Alternates } from '../../main/db/alternates'
+
+describe(Alternates.name, () => {
+  describe('Constructor', () => {
+    test('should accept a list of alternate values', () => {
+      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' },
+      ])
+    })
+  })
+
+  describe('getValue', () => {
+    test('should return undefined if there are no values', () => {
+      expect(new Alternates([]).getValue()).toBeUndefined()
+    })
+
+    test('should return the least-specific value when no classifiers are provided', () => {
+      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()).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' },
+        { value: 'Default' },
+        { sex: 'M', value: 'Male' },
+        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+      ]).getValue()).toBe('Default')
+    })
+
+    test('should return the most specific match', () => {
+      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')
+    })
+
+    test('should return the most specific match, regardless of insert order', () => {
+      expect(new Alternates([
+        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+        { sex: 'M', value: 'Male' },
+        { alignment: 'H', value: 'Hero' },
+        { alignment: 'V', sex: 'M', value: 'Male Villain' },
+        { value: 'Default' },
+      ]).getValue('V', 'M')).toBe('Male Villain')
+    })
+
+    test('should return undefined if there is no default', () => {
+      expect(new Alternates([
+        { sex: 'M', value: 'Male' },
+        { alignment: 'H', value: 'Hero' },
+        { alignment: 'V', sex: 'M', value: 'Male Villain' },
+        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+      ]).getValue()).toBeUndefined()
+    })
+  })
+
+  describe('default', () => {
+    test('should return undefined if there are no values', () => {
+      expect(new Alternates([]).default).toBeUndefined()
+    })
+
+    test('should return the lowest priority value', () => {
+      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' },
+      ]).default).toBe('Default')
+
+      expect(new Alternates([
+        { alignment: 'V', sex: 'M', value: 'Male Villain' },
+        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+        { sex: 'M', value: 'Male' },
+        { value: 'Default' },
+        { alignment: 'H', value: 'Hero' },
+      ]).default).toBe('Default')
+
+      expect(new Alternates([
+        { alignment: 'V', sex: 'M', value: 'Male Villain' },
+        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+        { sex: 'M', value: 'Male' },
+        { alignment: 'H', value: 'Hero' },
+      ]).default).toBe('Male')
+    })
+  })
+
+  describe('canonical', () => {
+    test('should be empty if there are no values', () => {
+      expect(new Alternates([]).canonical).toHaveLength(0)
+    })
+
+    test('should return values sorted in canonical order', () => {
+      const result = new Alternates([
+        { alignment: 'H', sex: 'F', value: 'Female Hero' },
+        { alignment: 'P', value: 'Praetorian' },
+        { sex: 'F', value: 'Female' },
+        { alignment: 'H', sex: 'A', value: 'A Hero' },
+        { alignment: 'Y', sex: 'A', value: 'A Y' },
+        { alignment: 'V', sex: 'M', value: 'Male Villain' },
+        { alignment: 'V', sex: 'B', value: 'B Villain' },
+        { alignment: 'P', sex: 'M', value: 'Male Praetorian' },
+        { alignment: 'H', value: 'Hero' },
+        { alignment: 'V', sex: 'A', value: 'A Villain' },
+        { sex: 'A', value: 'A Sex' },
+        { alignment: 'X', sex: 'F', value: 'Female X' },
+        { alignment: 'H', sex: 'M', value: 'Male Hero' },
+        { alignment: 'X', value: 'X' },
+        { alignment: 'P', sex: 'B', value: 'B Praetorian' },
+        { alignment: 'P', sex: 'A', value: 'A Praetorian' },
+        { alignment: 'X', sex: 'M', value: 'Male X' },
+        { sex: 'M', value: 'Male' },
+        { alignment: 'X', sex: 'B', value: 'B X' },
+        { alignment: 'H', sex: 'B', value: 'B Hero' },
+        { alignment: 'V', value: 'Villain' },
+        { alignment: 'Y', sex: 'M', value: 'Male Y' },
+        { alignment: 'V', sex: 'F', value: 'Female Villain' },
+        { sex: 'B', value: 'B Sex' },
+        { alignment: 'Y', sex: 'B', value: 'B Y' },
+        { alignment: 'P', sex: 'F', value: 'Female Praetorian' },
+        { alignment: 'X', sex: 'A', value: 'A X' },
+        { value: 'Default' },
+        { alignment: 'Y', sex: 'F', value: 'Female Y' },
+      ]).canonical
+
+      expect(result).toStrictEqual([
+        { value: 'Default' },
+        { sex: 'M', value: 'Male' },
+        { sex: 'F', value: 'Female' },
+        { sex: 'A', value: 'A Sex' },
+        { sex: 'B', value: 'B Sex' },
+        { alignment: 'H', value: 'Hero' },
+        { alignment: 'V', value: 'Villain' },
+        { alignment: 'P', value: 'Praetorian' },
+        { alignment: 'X', value: 'X' },
+        { alignment: 'H', sex: 'M', value: 'Male Hero' },
+        { alignment: 'H', sex: 'F', value: 'Female Hero' },
+        { alignment: 'H', sex: 'A', value: 'A Hero' },
+        { alignment: 'H', sex: 'B', value: 'B Hero' },
+        { alignment: 'V', sex: 'M', value: 'Male Villain' },
+        { alignment: 'V', sex: 'F', value: 'Female Villain' },
+        { alignment: 'V', sex: 'A', value: 'A Villain' },
+        { alignment: 'V', sex: 'B', value: 'B Villain' },
+        { alignment: 'P', sex: 'M', value: 'Male Praetorian' },
+        { alignment: 'P', sex: 'F', value: 'Female Praetorian' },
+        { alignment: 'P', sex: 'A', value: 'A Praetorian' },
+        { alignment: 'P', sex: 'B', value: 'B Praetorian' },
+        { alignment: 'X', sex: 'M', value: 'Male X' },
+        { alignment: 'X', sex: 'F', value: 'Female X' },
+        { alignment: 'X', sex: 'A', value: 'A X' },
+        { alignment: 'X', sex: 'B', value: 'B X' },
+        { alignment: 'Y', sex: 'M', value: 'Male Y' },
+        { alignment: 'Y', sex: 'F', value: 'Female Y' },
+        { alignment: 'Y', sex: 'A', value: 'A Y' },
+        { alignment: 'Y', sex: 'B', value: 'B Y' },
+      ])
+    })
+
+    test('should sort unspecified values by alpha', () => {
+      expect(new Alternates([
+        { value: 'A' },
+        { value: 'C' },
+        { value: 'B' },
+      ]).canonical).toStrictEqual([
+        { value: 'A' },
+        { value: 'B' },
+        { value: 'C' },
+      ])
+    })
+
+    test('should sort identical values similarly', () => {
+      expect(new Alternates([
+        { value: 'A' },
+        { value: 'B' },
+        { value: 'C' },
+        { value: 'B' },
+      ]).canonical).toStrictEqual([
+        { value: 'A' },
+        { value: 'B' },
+        { value: 'B' },
+        { value: 'C' },
+      ])
+    })
+
+    test('should sort unknown alignments by alpha', () => {
+      expect(new Alternates([
+        { alignment: 'A', value: 'A' },
+        { alignment: 'C', value: 'C' },
+        { alignment: 'B', value: 'B' },
+      ]).canonical).toStrictEqual([
+        { alignment: 'A', value: 'A' },
+        { alignment: 'B', value: 'B' },
+        { alignment: 'C', value: 'C' },
+      ])
+    })
+
+    test('should sort unknown sex by alpha', () => {
+      expect(new Alternates([
+        { sex: 'A', value: 'A' },
+        { sex: 'C', value: 'C' },
+        { sex: 'B', value: 'B' },
+      ]).canonical).toStrictEqual([
+        { sex: 'A', value: 'A' },
+        { sex: 'B', value: 'B' },
+        { sex: 'C', value: 'C' },
+      ])
+    })
+  })
+})

package/src/test/db/archetype.test.ts

@@ -0,0 +1,38 @@
+import { Archetype } from '../../main'
+import { archetypeDataFixture } from '../api/archetype-data.fixture'
+
+describe(Archetype.name, () => {
+  describe('Constructor', () => {
+    test('should accept the test fixture', () => {
+      new Archetype(archetypeDataFixture.create())
+    })
+  })
+
+  describe('key', () => {
+    test('should be set from data', () => {
+      const data = archetypeDataFixture.create({ key: 'foo' })
+      expect(new Archetype(data).key).toBe('foo')
+    })
+  })
+
+  describe('name', () => {
+    test('should be set from data', () => {
+      const data = archetypeDataFixture.create({ name: 'foo' })
+      expect(new Archetype(data).name).toBe('foo')
+    })
+  })
+
+  describe('description', () => {
+    test('should be set from data', () => {
+      const data = archetypeDataFixture.create({ description: 'foo' })
+      expect(new Archetype(data).description).toBe('foo')
+    })
+
+    test('should be undefined if missing in data', () => {
+      const data = archetypeDataFixture
+        .omit('description')
+        .create()
+      expect(new Archetype(data).description).toBeUndefined()
+    })
+  })
+})

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

@@ -0,0 +1,41 @@
+import { Badge } from '../../main'
+import { badgeDataFixture } from '../api/badge-data.fixture'
+import { badgePartialDataFixture } from '../api/badge-partial-data.fixture'
+
+describe(Badge.name, () => {
+  describe('Constructor', () => {
+    test(`should accept the test fixture`, () => {
+      new Badge(badgeDataFixture.create())
+    })
+  })
+
+  describe('partials', () => {
+    test(`should throw an error on duplicate key`, () => {
+      const data = badgeDataFixture.create({
+        partials: [
+          badgePartialDataFixture.create({ key: 'foo' }),
+          badgePartialDataFixture.create({ key: 'foo' }),
+        ],
+      })
+      expect(() => new Badge(data)).toThrow('Duplicate badge partial key [foo]')
+    })
+  })
+
+  describe('getBadgePartial', () => {
+    test(`should retrieve partial from the index`, () => {
+      const data = badgeDataFixture.create({
+        partials: [badgePartialDataFixture.create({ key: 'foo' })],
+      })
+
+      expect(new Badge(data).getPartial('foo')).not.toBeNull()
+    })
+
+    test(`should throw error for unknown partial`, () => {
+      const data = badgeDataFixture.create({
+        partials: [],
+      })
+
+      expect(() => new Badge(data).getPartial('foo')).toThrow('Unknown badge partial key [foo]')
+    })
+  })
+})

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

@@ -0,0 +1,42 @@
+import { CohContentDatabase } from '../../main'
+import { serverGroupDataFixture } from '../api/server-group-data.fixture'
+
+describe(CohContentDatabase.name, () => {
+  test('should be instantiable', () => {
+    expect(new CohContentDatabase()).not.toBeNull()
+  })
+
+  describe(CohContentDatabase.prototype.loadServerGroupData.name, () => {
+    test('should load an empty server group', () => {
+      const database = new CohContentDatabase()
+      database.loadServerGroupData(serverGroupDataFixture.create())
+    })
+  })
+
+  describe(CohContentDatabase.prototype.listServerGroups.name, () => {
+    test('should load two server groups', () => {
+      const database = new CohContentDatabase()
+      database.loadServerGroupData(serverGroupDataFixture.create({ key: 'sg1' }))
+      database.loadServerGroupData(serverGroupDataFixture.create({ key: 'sg2' }))
+
+      const sgs = database.listServerGroups()
+
+      expect(sgs).toHaveLength(2)
+
+      for (const entry of sgs) {
+        expect(['sg1', 'sg2']).toContain(entry.key)
+      }
+    })
+  })
+
+  describe(CohContentDatabase.prototype.getServerGroup.name, () => {
+    test('should load a server group by key', () => {
+      const database = new CohContentDatabase()
+      database.loadServerGroupData(serverGroupDataFixture.create({ key: 'sg1' }))
+
+      const sg = database.getServerGroup('sg1')
+      expect(sg).not.toBeNull()
+      expect(sg?.key).toEqual('sg1')
+    })
+  })
+})