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

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

@@ -0,0 +1,86 @@
+import { AbstractIndex } from '../../main/db/abstract-index'
+
+interface TestObject {
+  key: string
+  otherValue: number
+}
+
+describe(AbstractIndex.name, () => {
+  describe('Constructor', () => {
+    test(`should accept the key field`, () => {
+      new AbstractIndex<TestObject>('key')
+    })
+  })
+
+  describe('value', () => {
+    test(`should return the original values`, () => {
+      const values = [
+        { key: '1', otherValue: 1 },
+        { key: '2', otherValue: 2 },
+      ]
+      const index = new AbstractIndex<TestObject>('key')
+      index.load(values)
+
+      expect(index.values).toStrictEqual(values)
+    })
+  })
+
+  describe('get', () => {
+    test(`should return the indexed value on match`, () => {
+      const index = new AbstractIndex<TestObject>('key')
+      index.load([
+        { key: '1', otherValue: 1 },
+        { key: '2', otherValue: 2 },
+      ])
+
+      expect(index.get('2')).toStrictEqual({ key: '2', otherValue: 2 })
+    })
+
+    test(`should return undefined on no match`, () => {
+      const index = new AbstractIndex<TestObject>('key')
+
+      expect(index.get('2')).toBeUndefined()
+    })
+
+    test(`should return undefined on undefined key`, () => {
+      const index = new AbstractIndex<TestObject>('key')
+      const key = undefined
+      expect(index.get(key)).toBeUndefined()
+    })
+  })
+
+  describe('load', () => {
+    test(`should reset the index when used`, () => {
+      const index = new AbstractIndex<TestObject>('key')
+      index.load([
+        { key: '1', otherValue: 1 },
+        { key: '2', otherValue: 2 },
+      ])
+
+      expect(index.get('2')).toStrictEqual({ key: '2', otherValue: 2 })
+
+      index.load([
+        { key: '3', otherValue: 3 },
+      ])
+      expect(index.get('1')).toBeUndefined()
+      expect(index.get('2')).toBeUndefined()
+      expect(index.get('3')).toStrictEqual({ key: '3', otherValue: 3 })
+    })
+
+    test(`should accept an undefined value`, () => {
+      const index = new AbstractIndex<TestObject>('key')
+      const values = undefined
+      index.load(values)
+
+      expect(index.values).toHaveLength(0)
+    })
+
+    test(`should throw an error on duplicate key`, () => {
+      const index = new AbstractIndex<TestObject>('key')
+      expect(() => index.load([
+        { key: '1', otherValue: 1 },
+        { key: '1', otherValue: 1 },
+      ])).toThrow('Duplicate key [1]')
+    })
+  })
+})

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

@@ -6,11 +6,15 @@ describe(Alternates.name, () => {
       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' },
+        { 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', () => {
@@ -22,19 +26,19 @@ describe(Alternates.name, () => {
       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' },
+        { 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: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'H', value: 'Hero' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'hero', value: 'Hero' },
         { value: 'Default' },
         { sex: 'M', value: 'Male' },
-        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
       ]).getValue()).toBe('Default')
     })
 
@@ -42,37 +46,37 @@ describe(Alternates.name, () => {
       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')
+        { 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: 'P', sex: 'F', value: 'Praetorian Female' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
         { sex: 'M', value: 'Male' },
-        { alignment: 'H', value: 'Hero' },
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
+        { alignment: 'hero', value: 'Hero' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
         { value: 'Default' },
-      ]).getValue('V', 'M')).toBe('Male Villain')
+      ]).getValue('villain', 'M')).toBe('Male Villain')
     })
 
     test('should return the lowest canonical value if there is no default', () => {
       expect(new Alternates([
-        { alignment: 'H', value: 'Hero' },
+        { alignment: 'hero', value: 'Hero' },
         { sex: 'M', value: 'Male' },
-        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
+        { 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: 'H', value: 'Hero' },
-        { alignment: 'V', value: 'Villain' },
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+        { 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')
     })
   })
@@ -86,24 +90,24 @@ describe(Alternates.name, () => {
       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' },
+        { 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: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
         { sex: 'M', value: 'Male' },
         { value: 'Default' },
-        { alignment: 'H', value: 'Hero' },
+        { alignment: 'hero', value: 'Hero' },
       ]).default?.value).toBe('Default')
 
       expect(new Alternates([
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'P', sex: 'F', value: 'Praetorian Female' },
+        { alignment: 'villain', sex: 'M', value: 'Male Villain' },
+        { alignment: 'praetorian', sex: 'F', value: 'Praetorian Female' },
         { sex: 'M', value: 'Male' },
-        { alignment: 'H', value: 'Hero' },
+        { alignment: 'hero', value: 'Hero' },
       ]).default?.value).toBe('Male')
     })
   })
@@ -115,17 +119,17 @@ describe(Alternates.name, () => {
 
     test('should return values sorted in canonical order', () => {
       const result = new Alternates([
-        { alignment: 'H', sex: 'F', value: 'Female Hero' },
-        { alignment: 'P', value: 'Praetorian' },
+        { alignment: 'hero', sex: 'F', value: 'Female Hero' },
+        { alignment: 'praetorian', value: 'Praetorian' },
         { sex: 'F', value: 'Female' },
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'P', sex: 'M', value: 'Male Praetorian' },
-        { alignment: 'H', value: 'Hero' },
-        { alignment: 'H', sex: 'M', value: 'Male Hero' },
+        { 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: 'V', value: 'Villain' },
-        { alignment: 'V', sex: 'F', value: 'Female Villain' },
-        { alignment: 'P', sex: 'F', value: 'Female Praetorian' },
+        { alignment: 'villain', value: 'Villain' },
+        { alignment: 'villain', sex: 'F', value: 'Female Villain' },
+        { alignment: 'praetorian', sex: 'F', value: 'Female Praetorian' },
         { value: 'Default' },
       ]).canonical
 
@@ -133,15 +137,15 @@ describe(Alternates.name, () => {
         { value: 'Default' },
         { sex: 'M', value: 'Male' },
         { sex: 'F', value: 'Female' },
-        { alignment: 'H', value: 'Hero' },
-        { alignment: 'V', value: 'Villain' },
-        { alignment: 'P', value: 'Praetorian' },
-        { alignment: 'H', sex: 'M', value: 'Male Hero' },
-        { alignment: 'H', sex: 'F', value: 'Female Hero' },
-        { alignment: 'V', sex: 'M', value: 'Male Villain' },
-        { alignment: 'V', sex: 'F', value: 'Female Villain' },
-        { alignment: 'P', sex: 'M', value: 'Male Praetorian' },
-        { alignment: 'P', sex: 'F', value: 'Female Praetorian' },
+        { 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' },
       ])
     })
 
@@ -159,15 +163,15 @@ describe(Alternates.name, () => {
 
     test('should sort identical values by value alpha', () => {
       expect(new Alternates([
-        { alignment: 'V', value: 'B' },
+        { alignment: 'villain', value: 'B' },
         { sex: 'M', value: 'D' },
-        { alignment: 'V', value: 'A' },
+        { alignment: 'villain', value: 'A' },
         { sex: 'M', value: 'C' },
       ]).canonical).toStrictEqual([
         { sex: 'M', value: 'C' },
         { sex: 'M', value: 'D' },
-        { alignment: 'V', value: 'A' },
-        { alignment: 'V', value: 'B' },
+        { alignment: 'villain', value: 'A' },
+        { alignment: 'villain', value: 'B' },
       ])
     })
   })
@@ -177,7 +181,7 @@ describe(Alternates.name, () => {
       expect(new Alternates([
         { sex: 'M', value: 'A' },
         { sex: 'F', value: 'B' },
-        { alignment: 'H', value: 'C' },
+        { alignment: 'hero', value: 'C' },
       ]).toString(', ')).toBe('A, B, C')
     })
   })