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

package/src/test/api/alignment.test.ts

@@ -1,4 +1,4 @@
-import { Alignment, ALIGNMENT } from '../../main'
+import { Alignment, ALIGNMENT, compareAlignment } from '../../main'
 
 describe('ALIGNMENT', () => {
   test('should be an array', () => {
@@ -16,7 +16,7 @@ describe('ALIGNMENT', () => {
   })
 
   test('should contain all known alignments', () => {
-    const expected = ['H', 'V', 'P']
+    const expected = ['hero', 'villain', 'praetorian']
     for (const category of expected) {
       expect(ALIGNMENT).toContain(category)
     }
@@ -25,7 +25,41 @@ describe('ALIGNMENT', () => {
 
 describe('Alignment', () => {
   test('should be a usable type', () => {
-    const field: Alignment = 'H'
-    expect(field).toBe('H')
+    const field: Alignment = 'hero'
+    expect(field).toBe('hero')
+  })
+})
+
+describe('compareAlignment', () => {
+  test('should return <0 if first argument comes first', () => {
+    expect(compareAlignment('hero', 'villain')).toBeLessThan(0)
+    expect(compareAlignment('hero', 'praetorian')).toBeLessThan(0)
+  })
+
+  test('should return >0 if second argument comes first', () => {
+    expect(compareAlignment('villain', 'hero')).toBeGreaterThan(0)
+    expect(compareAlignment('praetorian', 'hero')).toBeGreaterThan(0)
+  })
+
+  test('should return 0 if arguments match', () => {
+    expect(compareAlignment('hero', 'hero')).toBe(0)
+  })
+
+  test('should return 0 if both arguments are undefined', () => {
+    expect(compareAlignment()).toBe(0)
+  })
+
+  test('should work as a compare function', () => {
+    const unsorted: (Alignment | undefined)[] = [undefined, 'hero', 'villain', 'praetorian', undefined, 'villain', 'praetorian']
+    const sorted = unsorted.sort(compareAlignment)
+
+    expect(sorted).toStrictEqual(['hero', 'villain', 'villain', 'praetorian', 'praetorian', undefined, undefined])
+  })
+
+  test('should sort against undefined', () => {
+    const unsorted: (Alignment | undefined)[] = [undefined, 'hero']
+    const sorted = unsorted.sort(compareAlignment)
+
+    expect(sorted).toStrictEqual(['hero', undefined])
   })
 })

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

@@ -1,24 +1,8 @@
 import { defineFixture } from 'efate'
-import { ALIGNMENT, BADGE_TYPE, BadgeData } from '../../main'
-import { badgeRequirementDataFixture } from './badge-requirement-data.fixture'
+import { BADGE_TYPE, BadgeData } from '../../main'
 
 export const badgeDataFixture = defineFixture<BadgeData>((t) => {
   t.key.as(index => `badge-${index}`)
   t.type.pickFrom([...BADGE_TYPE])
   t.name.as(index => [{ value: `Badge ${index}` }])
-  t.alignment.pickFrom([...ALIGNMENT])
-  t.badgeText?.as(index => [{ value: `This is badge ${index}` }])
-  t.acquisition?.asLoremIpsum()
-  t.icon?.as(() => [{ value: 'https://nouri.org' }])
-  t.notes?.asLoremIpsum()
-  t.links?.as(() => [{ href: 'https://nouri.org' }])
-  t.zoneKey?.asString()
-  t.loc?.as(index => [index, index, index])
-  t.vidiotMapKey?.asString()
-  t.setTitle?.as((index) => {
-    return { id: index }
-  })
-  t.effect?.asString()
-  t.requirements?.as(() => [[badgeRequirementDataFixture]])
-  t.ignoreInTotals?.asBoolean()
 })

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

@@ -3,9 +3,9 @@ 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'],
+  type: 'achievement',
+  name: [{ value: 'Test Badge' }, { alignment: 'praetorian', value: 'My Badge for Praetorians' }],
+  morality: ['hero', 'praetorian'],
 }
 
 describe('BadgeData', () => {

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

@@ -1,17 +1,7 @@
 import { defineFixture } from 'efate'
-import { BADGE_REQUIREMENT_TYPE, BadgeRequirementData, ENHANCEMENT_CATEGORY, PLAQUE_TYPE } from '../../main'
+import { BADGE_REQUIREMENT_TYPE, BadgeRequirementData } from '../../main'
 
 export const badgeRequirementDataFixture = defineFixture<BadgeRequirementData>((t) => {
   t.key.as(index => `badge-requirement-${index}`)
   t.type.pickFrom([...BADGE_REQUIREMENT_TYPE])
-  t.zoneKey?.asString()
-  t.loc?.as(index => [index, index, index])
-  t.plaqueType?.pickFrom([...PLAQUE_TYPE])
-  t.plaqueInscription?.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-requirement-type.test.ts

@@ -16,7 +16,7 @@ describe('BADGE_REQUIREMENT_TYPE', () => {
   })
 
   test('should contain all known badge requirement types', () => {
-    const expected = ['PLAQUE', 'BADGE', 'INVENTION', 'INVENTION_PLUS_ONE']
+    const expected = ['badge', 'invention', 'invention-plus-one', 'location', 'monument', 'mission', 'task']
     for (const category of expected) {
       expect(BADGE_REQUIREMENT_TYPE).toContain(category)
     }
@@ -25,7 +25,7 @@ describe('BADGE_REQUIREMENT_TYPE', () => {
 
 describe('BadgeRequirementType', () => {
   test('should be a usable type', () => {
-    const field: BadgeRequirementType = 'PLAQUE'
-    expect(field).toBe('PLAQUE')
+    const field: BadgeRequirementType = 'monument'
+    expect(field).toBe('monument')
   })
 })

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

@@ -17,9 +17,9 @@ describe('BADGE_TYPE', () => {
 
   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',
+      'exploration', 'history', 'accomplishment', 'achievement', 'accolade',
+      'gladiator', 'veteran', 'pvp', 'invention', 'defeat',
+      'event', 'ouroboros', 'consignment', 'day-job', 'architect-entertainment',
     ]
     for (const category of expected) {
       expect(BADGE_TYPE).toContain(category)
@@ -29,7 +29,7 @@ describe('BADGE_TYPE', () => {
 
 describe('BadgeType', () => {
   test('should be a usable type', () => {
-    const field: BadgeType = 'EXPLORATION'
-    expect(field).toBe('EXPLORATION')
+    const field: BadgeType = 'exploration'
+    expect(field).toBe('exploration')
   })
 })

package/src/test/api/contact-data.fixture.ts

@@ -4,10 +4,4 @@ import { ContactData } from '../../main'
 export const contactDataFixture = defineFixture<ContactData>((t) => {
   t.key.as(index => `contact-${index}`)
   t.name.as(index => [{ value: `Contact ${index}` }])
-  t.title?.as(index => [{ value: `Contact title ${index}` }])
-  t.zoneKey?.asString()
-  t.loc?.as(index => [index, index, index])
-  t.levelRange?.as(index => [index, index])
-  t.notes?.asLoremIpsum()
-  t.links?.as(() => [{ href: 'https://nouri.org' }])
 })

package/src/test/api/content-bundle.fixture.ts

@@ -1,22 +1,6 @@
 import { defineFixture } from 'efate'
-import { Change, ContentBundle } from '../../main'
-import { archetypeDataFixture } from './archetype-data.fixture'
-import { zoneDataFixture } from './zone-data.fixture'
-import { badgeDataFixture } from './badge-data.fixture'
+import { ContentBundle } from '../../main'
 
 export const contentBundleFixture = defineFixture<ContentBundle>((t) => {
   t.name.as(index => `Bundle ${index}`)
-  t.description?.asLoremIpsum()
-  t.repository?.as(index => `https://nouri.org?id=${index}`)
-  t.servers?.asArray()
-  t.archetypes?.arrayOfFixture({ fixture: archetypeDataFixture })
-  t.zones?.arrayOfFixture({ fixture: zoneDataFixture })
-  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/enhancement-category.test.ts

@@ -17,9 +17,9 @@ describe('ENHANCEMENT_CATEGORY', () => {
 
   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',
+      '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)
@@ -29,7 +29,7 @@ describe('ENHANCEMENT_CATEGORY', () => {
 
 describe('EnhancementCategory', () => {
   test('should be a usable type', () => {
-    const field: EnhancementCategory = 'RUN_SPEED'
-    expect(field).toBe('RUN_SPEED')
+    const field: EnhancementCategory = 'run-speed'
+    expect(field).toBe('run-speed')
   })
 })

package/src/test/api/mission-data.fixture.ts

@@ -0,0 +1,12 @@
+import { defineFixture } from 'efate'
+import { MISSION_TYPE, MissionData, MissionFlashbackData } from '../../main'
+
+export const missionDataFixture = defineFixture<MissionData>((t) => {
+  t.key.as(index => `mission-${index}`)
+  t.name.as(index => `Mission ${index}`)
+  t.type.pickFrom([...MISSION_TYPE])
+})
+
+export const missionFlashbackDataFixture = defineFixture<MissionFlashbackData>((t) => {
+  t.id.as(index => `${index}.${index}`)
+})

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

@@ -1,4 +1,4 @@
-import { Sex, SEX } from '../../main'
+import { compareSex, Sex, SEX } from '../../main'
 
 describe('SEX', () => {
   test('should be an array', () => {
@@ -29,3 +29,35 @@ describe('Sex', () => {
     expect(field).toBe('M')
   })
 })
+
+describe('compareSex', () => {
+  test('should return <0 if first argument comes first', () => {
+    expect(compareSex('M', 'F')).toBeLessThan(0)
+  })
+
+  test('should return >0 if second argument comes first', () => {
+    expect(compareSex('F', 'M')).toBeGreaterThan(0)
+  })
+
+  test('should return 0 if arguments match', () => {
+    expect(compareSex('F', 'F')).toBe(0)
+  })
+
+  test('should return 0 if both arguments are undefined', () => {
+    expect(compareSex()).toBe(0)
+  })
+
+  test('should work as a compare function', () => {
+    const unsorted: (Sex | undefined)[] = [undefined, 'M', 'F', 'M', undefined, 'F', 'M']
+    const sorted = unsorted.sort(compareSex)
+
+    expect(sorted).toStrictEqual(['M', 'M', 'M', 'F', 'F', undefined, undefined])
+  })
+
+  test('should sort against undefined', () => {
+    const unsorted: (Sex | undefined)[] = [undefined, 'M']
+    const sorted = unsorted.sort(compareSex)
+
+    expect(sorted).toStrictEqual(['M', undefined])
+  })
+})

package/src/test/api/zone-data.fixture.ts

@@ -4,5 +4,5 @@ import { defineFixture } from 'efate'
 export const zoneDataFixture = defineFixture<ZoneData>((t) => {
   t.key.as(index => `zone-${index}`)
   t.name.as(index => `Zone ${index}`)
-  t.links?.as(() => [{ href: 'https://nouri.org' }])
+  t.links?.as(() => [{ title: 'foo', href: 'https://nouri.org' }])
 })

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