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

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

@@ -0,0 +1,200 @@
+import { AlignmentList } from '../../main'
+
+describe(AlignmentList.name, () => {
+  describe('items', () => {
+    test('should return the basic set', () => {
+      expect(new AlignmentList(['hero', 'villain']).items).toStrictEqual(['hero', 'villain'])
+    })
+
+    test('should collapse extended values', () => {
+      expect(new AlignmentList(['primal']).items).toStrictEqual(['hero', 'villain'])
+    })
+
+    test('should not duplicate overlaps', () => {
+      expect(new AlignmentList(['primal', 'all', 'hero']).items).toStrictEqual(['hero', 'villain', 'praetorian'])
+    })
+
+    test('should have deterministic order', () => {
+      expect(new AlignmentList(['hero', 'villain']).items).toStrictEqual(['hero', 'villain'])
+      expect(new AlignmentList(['villain', 'hero']).items).toStrictEqual(['hero', 'villain'])
+      expect(new AlignmentList(['primal', 'all', 'hero']).items).toStrictEqual(['hero', 'villain', 'praetorian'])
+      expect(new AlignmentList(['hero', 'primal', 'all']).items).toStrictEqual(['hero', 'villain', 'praetorian'])
+      expect(new AlignmentList(['all', 'hero', 'primal']).items).toStrictEqual(['hero', 'villain', 'praetorian'])
+    })
+
+    test('should treat undefined as all values', () => {
+      expect(new AlignmentList().items).toStrictEqual(['hero', 'villain', 'praetorian'])
+    })
+
+    test('should treat empty as no values', () => {
+      expect(new AlignmentList([]).items).toStrictEqual([])
+    })
+  })
+
+  describe('values', () => {
+    test('should all be true when undefined', () => {
+      const alignments = new AlignmentList()
+      expect(alignments.hero).toBeTruthy()
+      expect(alignments.villain).toBeTruthy()
+      expect(alignments.praetorian).toBeTruthy()
+      expect(alignments.primal).toBeTruthy()
+      expect(alignments.all).toBeTruthy()
+    })
+
+    test('should all be false when empty', () => {
+      const alignments = new AlignmentList([])
+      expect(alignments.hero).toBeFalsy()
+      expect(alignments.villain).toBeFalsy()
+      expect(alignments.praetorian).toBeFalsy()
+      expect(alignments.primal).toBeFalsy()
+      expect(alignments.all).toBeFalsy()
+    })
+  })
+
+  describe('hero', () => {
+    test('should detect a hero', () => {
+      expect(new AlignmentList(['hero', 'villain']).hero).toBeTruthy()
+    })
+
+    test('should detect primal', () => {
+      expect(new AlignmentList(['primal']).hero).toBeTruthy()
+    })
+
+    test('should detect all', () => {
+      expect(new AlignmentList(['all']).hero).toBeTruthy()
+    })
+
+    test('should not falsely detect a hero', () => {
+      expect(new AlignmentList(['villain']).hero).toBeFalsy()
+    })
+  })
+
+  describe('villain', () => {
+    test('should detect a villain', () => {
+      expect(new AlignmentList(['hero', 'villain']).villain).toBeTruthy()
+    })
+
+    test('should detect primal', () => {
+      expect(new AlignmentList(['primal']).villain).toBeTruthy()
+    })
+
+    test('should detect all', () => {
+      expect(new AlignmentList(['all']).villain).toBeTruthy()
+    })
+
+    test('should not falsely detect a villain', () => {
+      expect(new AlignmentList(['hero']).villain).toBeFalsy()
+    })
+  })
+
+  describe('praetorian', () => {
+    test('should detect a praetorian', () => {
+      expect(new AlignmentList(['hero', 'praetorian']).praetorian).toBeTruthy()
+    })
+
+    test('should not detect primal', () => {
+      expect(new AlignmentList(['primal']).praetorian).toBeFalsy()
+    })
+
+    test('should detect all', () => {
+      expect(new AlignmentList(['all']).praetorian).toBeTruthy()
+    })
+
+    test('should not falsely detect a praetorian', () => {
+      expect(new AlignmentList(['villain']).praetorian).toBeFalsy()
+    })
+  })
+
+  describe('primal', () => {
+    test('should detect hero and villain', () => {
+      expect(new AlignmentList(['hero', 'villain']).primal).toBeTruthy()
+    })
+
+    test('should detect primal', () => {
+      expect(new AlignmentList(['primal']).primal).toBeTruthy()
+    })
+
+    test('should detect all', () => {
+      expect(new AlignmentList(['all']).primal).toBeTruthy()
+    })
+
+    test('should not falsely detect a primal', () => {
+      expect(new AlignmentList(['villain']).primal).toBeFalsy()
+      expect(new AlignmentList(['praetorian']).primal).toBeFalsy()
+    })
+  })
+
+  describe('all', () => {
+    test('should detect when all are present', () => {
+      expect(new AlignmentList(['hero', 'villain', 'praetorian']).all).toBeTruthy()
+    })
+
+    test('should detect primal and praetorian', () => {
+      expect(new AlignmentList(['primal', 'praetorian']).all).toBeTruthy()
+    })
+
+    test('should detect all', () => {
+      expect(new AlignmentList(['all']).all).toBeTruthy()
+    })
+
+    test('should not falsely detect all', () => {
+      expect(new AlignmentList(['villain']).all).toBeFalsy()
+      expect(new AlignmentList(['praetorian']).all).toBeFalsy()
+      expect(new AlignmentList(['primal']).all).toBeFalsy()
+    })
+  })
+
+  describe('has', () => {
+    test('should return true if present', () => {
+      expect(new AlignmentList(['villain']).has('villain')).toBeTruthy()
+    })
+
+    test('should return false if absent', () => {
+      expect(new AlignmentList(['hero']).has('villain')).toBeFalsy()
+      expect(new AlignmentList(['hero', 'praetorian']).has('primal')).toBeFalsy()
+    })
+
+    test('should return false if undefined', () => {
+      expect(new AlignmentList(['hero']).has()).toBeFalsy()
+    })
+
+    test('should test hero correctly', () => {
+      expect(new AlignmentList(['hero']).has('hero')).toBeTruthy()
+      expect(new AlignmentList(['primal']).has('hero')).toBeTruthy()
+      expect(new AlignmentList(['all']).has('hero')).toBeTruthy()
+
+      expect(new AlignmentList(['villain']).has('hero')).toBeFalsy()
+    })
+
+    test('should test villain correctly', () => {
+      expect(new AlignmentList(['villain']).has('villain')).toBeTruthy()
+      expect(new AlignmentList(['primal']).has('villain')).toBeTruthy()
+      expect(new AlignmentList(['all']).has('villain')).toBeTruthy()
+
+      expect(new AlignmentList(['hero']).has('villain')).toBeFalsy()
+    })
+
+    test('should test praetorian correctly', () => {
+      expect(new AlignmentList(['praetorian']).has('praetorian')).toBeTruthy()
+      expect(new AlignmentList(['all']).has('praetorian')).toBeTruthy()
+
+      expect(new AlignmentList(['villain']).has('praetorian')).toBeFalsy()
+    })
+
+    test('should test primal correctly', () => {
+      expect(new AlignmentList(['hero', 'villain']).has('primal')).toBeTruthy()
+      expect(new AlignmentList(['primal']).has('primal')).toBeTruthy()
+      expect(new AlignmentList(['all']).has('primal')).toBeTruthy()
+
+      expect(new AlignmentList(['praetorian']).has('primal')).toBeFalsy()
+    })
+
+    test('should test all correctly', () => {
+      expect(new AlignmentList(['hero', 'villain', 'praetorian']).has('all')).toBeTruthy()
+      expect(new AlignmentList(['primal', 'praetorian']).has('all')).toBeTruthy()
+      expect(new AlignmentList(['all']).has('all')).toBeTruthy()
+
+      expect(new AlignmentList([]).has('all')).toBeFalsy()
+    })
+  })
+})

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

@@ -0,0 +1,188 @@
+import { Alternates } from '../../main'
+
+describe(Alternates.name, () => {
+  describe('Constructor', () => {
+    test('should accept a list of alternate values', () => {
+      new Alternates([
+        { value: 'Default' },
+        { sex: 'M', value: 'Male' },
+        { 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', () => {
+    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: '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: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'hero', value: 'Hero' },
+        { value: 'Default' },
+        { sex: 'M', value: 'Male' },
+        { alignment: 'praetorian', 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: '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: 'praetorian', sex: 'F', value: 'Praetorian Female' },
+        { sex: 'M', value: 'Male' },
+        { alignment: 'hero', value: 'Hero' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
+        { value: 'Default' },
+      ]).getValue('villain', 'M')).toBe('Male Villain')
+    })
+
+    test('should return the lowest canonical value if there is no default', () => {
+      expect(new Alternates([
+        { alignment: 'hero', value: 'Hero' },
+        { sex: 'M', value: 'Male' },
+        { 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: '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')
+    })
+  })
+
+  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: '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: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
+        { sex: 'M', value: 'Male' },
+        { value: 'Default' },
+        { alignment: 'hero', value: 'Hero' },
+      ]).default?.value).toBe('Default')
+
+      expect(new Alternates([
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
+        { sex: 'M', value: 'Male' },
+        { alignment: 'hero', value: 'Hero' },
+      ]).default?.value).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: 'hero', sex: 'F', value: 'Female Hero' },
+        { alignment: 'praetorian', value: 'Praetorian' },
+        { sex: 'F', value: 'Female' },
+        { 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: 'villain', value: 'Villain' },
+        { alignment: 'villain', sex: 'F', value: 'Female Villain' },
+        { alignment: 'praetorian', sex: 'F', value: 'Female Praetorian' },
+        { value: 'Default' },
+      ]).canonical
+
+      expect(result).toStrictEqual([
+        { value: 'Default' },
+        { sex: 'M', value: 'Male' },
+        { sex: 'F', value: 'Female' },
+        { 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' },
+      ])
+    })
+
+    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 by value alpha', () => {
+      expect(new Alternates([
+        { alignment: 'villain', value: 'B' },
+        { sex: 'M', value: 'D' },
+        { alignment: 'villain', value: 'A' },
+        { sex: 'M', value: 'C' },
+      ]).canonical).toStrictEqual([
+        { sex: 'M', value: 'C' },
+        { sex: 'M', value: 'D' },
+        { alignment: 'villain', value: 'A' },
+        { alignment: 'villain', value: 'B' },
+      ])
+    })
+  })
+
+  describe('toString', () => {
+    test('should create a string separated by the separator', () => {
+      expect(new Alternates([
+        { sex: 'M', value: 'A' },
+        { sex: 'F', value: 'B' },
+        { alignment: 'hero', value: 'C' },
+      ]).toString(', ')).toBe('A, B, 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()
+    })
+  })
+})