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

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

@@ -4,245 +4,319 @@ import { archetypeDataFixture } from '../api/archetype-data.fixture'
 import { badgeDataFixture } from '../api/badge-data.fixture'
 import { zoneDataFixture } from '../api/zone-data.fixture'
 import { contactDataFixture } from '../api/contact-data.fixture'
+import { missionDataFixture } from '../api/mission-data.fixture'
 
 describe(CohContentDatabase.name, () => {
-  test('should load a basic bundle', () => {
-    new CohContentDatabase(contentBundleFixture.create())
+  describe('load', () => {
+    test('should load a basic bundle', () => {
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create())
+    })
+
+    test('should reset the database if load is called again', () => {
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({
+        name: 'Metadata',
+        servers: ['Test'],
+        archetypes: [archetypeDataFixture.create()],
+        zones: [zoneDataFixture.create()],
+        contacts: [contactDataFixture.create()],
+        missions: [missionDataFixture.create()],
+        badges: [badgeDataFixture.create()],
+      }))
+
+      expect(database.metadata?.name).toEqual('Metadata')
+      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(contentBundleFixture.create({ name: 'Reset' }))
+      expect(database.metadata?.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)
+    })
+  })
+
+  describe('metadata', () => {
+    test(`should hby undefined if not initialized`, () => {
+      const database = new CohContentDatabase()
+      expect(database.metadata).toBeUndefined()
+    })
+
+    test(`should load values from bundle`, () => {
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture
+        .create({ name: 'Metadata' }))
+
+      expect(database.metadata?.name).toBe('Metadata')
+    })
   })
 
   describe('servers', () => {
     test(`should accept an undefined field`, () => {
-      const data = contentBundleFixture
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture
         .omit('servers')
-        .create()
-      expect(() => new CohContentDatabase(data).archetypes).toHaveLength(0)
+        .create())
+
+      expect(database.servers).toHaveLength(0)
+    })
+
+    test(`should be empty if uninitialized`, () => {
+      const database = new CohContentDatabase()
+      expect(database.servers).toHaveLength(0)
     })
 
     test(`should load values from bundle`, () => {
-      const data = contentBundleFixture
-        .create({ servers: ['Foo', 'Bar'] })
-      expect(new CohContentDatabase(data).servers).toStrictEqual(['Foo', 'Bar'])
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture
+        .create({ servers: ['Foo', 'Bar'] }))
+
+      expect(database.servers).toStrictEqual(['Foo', 'Bar'])
     })
   })
 
   describe('archetypes', () => {
     test(`should throw an error on duplicate key`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      expect(() => database.load(contentBundleFixture.create({
         archetypes: [
           archetypeDataFixture.create({ key: 'foo' }),
           archetypeDataFixture.create({ key: 'foo' }),
         ],
-      })
-      expect(() => new CohContentDatabase(data)).toThrow(`Duplicate archetype key 'foo'`)
+      }))).toThrow(`Duplicate key [foo]`)
     })
 
     test(`should accept an undefined field`, () => {
-      const data = contentBundleFixture
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture
         .omit('archetypes')
-        .create()
-      expect(() => new CohContentDatabase(data).archetypes).toHaveLength(0)
+        .create())
+      expect(database.archetypes).toHaveLength(0)
     })
 
     test(`should load data from bundle`, () => {
-      const data = contentBundleFixture
-        .create({ archetypes: [archetypeDataFixture.create({ key: 'foo' })] })
-      expect(() => new CohContentDatabase(data).getArchetype('foo')).not.toBeUndefined()
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture
+        .create({ archetypes: [archetypeDataFixture.create({ key: 'foo' })] }))
+      expect(database.getArchetype('foo')).not.toBeUndefined()
     })
   })
 
   describe('badges', () => {
     test(`should throw an error on duplicate key`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      expect(() => database.load(contentBundleFixture.create({
         badges: [
           badgeDataFixture.create({ key: 'foo' }),
           badgeDataFixture.create({ key: 'foo' }),
         ],
-      })
-      expect(() => new CohContentDatabase(data)).toThrow('Duplicate badge key [foo]')
+      }))).toThrow('Duplicate key [foo]')
     })
 
     test(`should accept an undefined field`, () => {
-      const data = contentBundleFixture
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture
         .omit('badges')
-        .create()
-      expect(() => new CohContentDatabase(data).badges).toHaveLength(0)
+        .create())
+      expect(database.badges).toHaveLength(0)
     })
   })
 
   describe('zones', () => {
     test(`should throw an error on duplicate zone`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      expect(() => database.load(contentBundleFixture.create({
         zones: [
           zoneDataFixture.create({ key: 'foo' }),
           zoneDataFixture.create({ key: 'foo' }),
         ],
-      })
-      expect(() => new CohContentDatabase(data)).toThrow(`Duplicate zone key 'foo'`)
+      }))).toThrow(`Duplicate key [foo]`)
     })
 
     test(`should accept an undefined field`, () => {
-      const data = contentBundleFixture
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture
         .omit('zones')
-        .create()
-      expect(() => new CohContentDatabase(data).zones).toHaveLength(0)
+        .create())
+      expect(database.zones).toHaveLength(0)
     })
   })
 
   describe('contacts', () => {
     test(`should throw an error on duplicate contact`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      expect(() => database.load(contentBundleFixture.create({
         contacts: [
           contactDataFixture.create({ key: 'foo' }),
           contactDataFixture.create({ key: 'foo' }),
         ],
-      })
-      expect(() => new CohContentDatabase(data)).toThrow(`Duplicate contact key 'foo'`)
+      }))).toThrow(`Duplicate key [foo]`)
     })
 
     test(`should accept an undefined field`, () => {
-      const data = contentBundleFixture
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture
         .omit('contacts')
-        .create()
-      expect(() => new CohContentDatabase(data).contacts).toHaveLength(0)
+        .create())
+      expect(database.contacts).toHaveLength(0)
+    })
+  })
+
+  describe('missions', () => {
+    test(`should throw an error on duplicate mission`, () => {
+      const database = new CohContentDatabase()
+      expect(() => database.load(contentBundleFixture.create({
+        missions: [
+          missionDataFixture.create({ key: 'foo' }),
+          missionDataFixture.create({ key: 'foo' }),
+        ],
+      }))).toThrow(`Duplicate key [foo]`)
+    })
+
+    test(`should accept an undefined field`, () => {
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture
+        .omit('missions')
+        .create())
+      expect(database.missions).toHaveLength(0)
     })
   })
 
   describe('getArchetype', () => {
     test(`should retrieve archetype from the index`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({
         archetypes: [archetypeDataFixture.create({ key: 'foo' })],
-      })
-
-      expect(new CohContentDatabase(data).getArchetype('foo')).not.toBeUndefined()
+      }))
+      expect(database.getArchetype('foo')).not.toBeUndefined()
     })
 
-    test(`should throw error for unknown archetype`, () => {
-      const data = contentBundleFixture.create({
-        archetypes: [],
-      })
+    test(`should return undefined for unknown archetype`, () => {
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({ archetypes: [] }))
+      expect(database.getArchetype('foo')).toBeUndefined()
+    })
 
-      expect(() => new CohContentDatabase(data).getArchetype('foo')).toThrow(`Unknown archetype key 'foo'`)
+    test(`should return undefined for undefined key`, () => {
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({ archetypes: [] }))
+      const key = undefined
+      expect(database.getArchetype(key)).toBeUndefined()
     })
   })
 
   describe('getZone', () => {
     test(`should retrieve zone from the index`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({
         zones: [zoneDataFixture.create({ key: 'foo' })],
-      })
+      }))
 
-      expect(new CohContentDatabase(data).getZone('foo')).not.toBeUndefined()
+      expect(database.getZone('foo')).not.toBeUndefined()
     })
 
-    test(`should throw error for unknown zone`, () => {
-      const data = contentBundleFixture.create({
-        zones: [],
-      })
-
-      expect(() => new CohContentDatabase(data).getZone('foo')).toThrow(`Unknown zone key 'foo'`)
+    test(`should return undefined for unknown zone`, () => {
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({ zones: [] }))
+      expect(database.getZone('foo')).toBeUndefined()
     })
-  })
 
-  describe('zoneExists', () => {
-    test(`should return true for a zone that exists`, () => {
-      const data = contentBundleFixture.create({
-        zones: [zoneDataFixture.create({ key: 'foo' })],
-      })
-
-      expect(new CohContentDatabase(data).zoneExists('foo')).toBeTruthy()
-    })
-
-    test(`should return false for a zone that does not exist`, () => {
-      const data = contentBundleFixture.create({
-        zones: [],
-      })
-
-      expect(new CohContentDatabase(data).zoneExists('foo')).toBeFalsy()
+    test(`should return undefined for undefined key`, () => {
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({ zones: [] }))
+      const key = undefined
+      expect(database.getZone(key)).toBeUndefined()
     })
   })
 
   describe('getContact', () => {
     test(`should retrieve contact from the index`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({
         contacts: [contactDataFixture.create({ key: 'foo' })],
-      })
-
-      expect(new CohContentDatabase(data).getContact('foo')).not.toBeUndefined()
+      }))
+      expect(database.getContact('foo')).not.toBeUndefined()
     })
 
-    test(`should throw error for unknown contact`, () => {
-      const data = contentBundleFixture.create({
-        contacts: [],
-      })
+    test(`should return undefined for unknown contact`, () => {
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({ contacts: [] }))
+      expect(database.getContact('foo')).toBeUndefined()
+    })
 
-      expect(() => new CohContentDatabase(data).getContact('foo')).toThrow(`Unknown contact key 'foo'`)
+    test(`should return undefined for undefined key`, () => {
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({ contacts: [] }))
+      const key = undefined
+      expect(database.getContact(key)).toBeUndefined()
     })
   })
 
-  describe('contactExists', () => {
-    test(`should return true for a contact that exists`, () => {
-      const data = contentBundleFixture.create({
-        contacts: [contactDataFixture.create({ key: 'foo' })],
-      })
-
-      expect(new CohContentDatabase(data).contactExists('foo')).toBeTruthy()
+  describe('getMission', () => {
+    test(`should retrieve mission from the index`, () => {
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({
+        missions: [missionDataFixture.create({ key: 'foo' })],
+      }))
+      expect(database.getMission('foo')).not.toBeUndefined()
     })
 
-    test(`should return false for a contact that does not exist`, () => {
-      const data = contentBundleFixture.create({
-        contacts: [],
-      })
+    test(`should return undefined for unknown mission`, () => {
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({ missions: [] }))
+      expect(database.getMission('foo')).toBeUndefined()
+    })
 
-      expect(new CohContentDatabase(data).contactExists('foo')).toBeFalsy()
+    test(`should return undefined for undefined key`, () => {
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({ missions: [] }))
+      const key = undefined
+      expect(database.getMission(key)).toBeUndefined()
     })
   })
 
   describe('getBadge', () => {
     test(`should retrieve badge from the index`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({
         badges: [badgeDataFixture.create({ key: 'foo' })],
-      })
-
-      expect(new CohContentDatabase(data).getBadge('foo')).not.toBeUndefined()
-    })
-
-    test(`should throw error for unknown badge`, () => {
-      const data = contentBundleFixture.create({
-        badges: [],
-      })
-
-      expect(() => new CohContentDatabase(data).getBadge('foo')).toThrow('Unknown badge key [foo]')
+      }))
+      expect(database.getBadge('foo')).not.toBeUndefined()
     })
-  })
 
-  describe('badgeExists', () => {
-    test(`should return true for a badge that exists`, () => {
-      const data = contentBundleFixture.create({
-        badges: [badgeDataFixture.create({ key: 'foo' })],
-      })
-
-      expect(new CohContentDatabase(data).badgeExists('foo')).toBeTruthy()
+    test(`should return undefined for unknown badge`, () => {
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({ badges: [] }))
+      expect(database.getBadge('foo')).toBeUndefined()
     })
 
-    test(`should return false for a badge that does not exist`, () => {
-      const data = contentBundleFixture.create({
-        badges: [],
-      })
-
-      expect(new CohContentDatabase(data).badgeExists('foo')).toBeFalsy()
+    test(`should return undefined for undefined key`, () => {
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({ badges: [] }))
+      const key = undefined
+      expect(database.getBadge(key)).toBeUndefined()
     })
   })
 
   describe('searchBadges', () => {
     test(`should search the badge list`, () => {
-      const data = contentBundleFixture.create({
+      const database = new CohContentDatabase()
+      database.load(contentBundleFixture.create({
         badges: [
           badgeDataFixture.create({ key: 'foo', name: [{ value: 'Foo' }] }),
           badgeDataFixture.create({ key: 'bar', name: [{ value: 'Bar' }] }),
         ],
-      })
+      }))
 
-      const result = new CohContentDatabase(data).searchBadges({ query: { str: 'oo' } })
+      const result = database.searchBadges({ query: { str: 'oo' } })
       expect(result.totalItems).toBe(1)
       expect(result.items.map(x => x.key)).toStrictEqual(['foo'])
     })

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

@@ -9,86 +9,87 @@ describe(Contact.name, () => {
   })
 
   describe('key', () => {
-    test(`should should be set from the data`, () => {
+    test(`should be set from the data`, () => {
       const contact = new Contact(contactDataFixture.create({ key: 'foo' }))
       expect(contact.key).toEqual('foo')
     })
   })
 
   describe('name', () => {
-    test(`should should be set from the data`, () => {
+    test(`should be set from the data`, () => {
       const contact = new Contact(contactDataFixture.create({ name: 'foo' }))
       expect(contact.name).toEqual('foo')
     })
   })
 
   describe('title', () => {
-    test(`should should be set from the data`, () => {
+    test(`should be set from the data`, () => {
       const contact = new Contact(contactDataFixture.create({ title: 'foo' }))
       expect(contact.title).toEqual('foo')
     })
 
-    test(`should should be optional`, () => {
+    test(`should be optional`, () => {
       const contact = new Contact(contactDataFixture.omit('title').create())
       expect(contact.title).toBeUndefined()
     })
   })
 
-  describe('zoneKey', () => {
-    test(`should should be set from the data`, () => {
-      const contact = new Contact(contactDataFixture.create({ zoneKey: 'foo' }))
-      expect(contact.zoneKey).toEqual('foo')
+  describe('morality', () => {
+    test(`should be set from the data`, () => {
+      const contact = new Contact(contactDataFixture.create({ morality: ['hero'] }))
+      expect(contact.morality?.hero).toBeTruthy()
+      expect(contact.morality?.vigilante).toBeFalsy()
     })
 
-    test(`should should be optional`, () => {
-      const contact = new Contact(contactDataFixture.omit('zoneKey').create())
-      expect(contact.zoneKey).toBeUndefined()
+    test(`should be optional`, () => {
+      const contact = new Contact(contactDataFixture.omit('morality').create())
+      expect(contact.morality?.all).toBeTruthy()
     })
   })
 
-  describe('loc', () => {
-    test(`should should be set from the data`, () => {
-      const contact = new Contact(contactDataFixture.create({ loc: [1, 2, 3] }))
-      expect(contact.loc).toStrictEqual([1, 2, 3])
+  describe('zoneKey', () => {
+    test(`should be set from the data`, () => {
+      const contact = new Contact(contactDataFixture.create({ location: { zoneKey: 'atlas-park', coords: [1, -2, 3.5] } }))
+      expect(contact.location).toEqual({ zoneKey: 'atlas-park', coords: [1, -2, 3.5] })
     })
 
-    test(`should should be optional`, () => {
-      const contact = new Contact(contactDataFixture.omit('loc').create())
-      expect(contact.loc).toBeUndefined()
+    test(`should be optional`, () => {
+      const contact = new Contact(contactDataFixture.omit('location').create())
+      expect(contact.location).toBeUndefined()
     })
   })
 
   describe('levelRange', () => {
-    test(`should should be set from the data`, () => {
+    test(`should be set from the data`, () => {
       const contact = new Contact(contactDataFixture.create({ levelRange: [1, 2] }))
       expect(contact.levelRange).toStrictEqual([1, 2])
     })
 
-    test(`should should be optional`, () => {
+    test(`should be optional`, () => {
       const contact = new Contact(contactDataFixture.omit('levelRange').create())
       expect(contact.levelRange).toBeUndefined()
     })
   })
 
   describe('notes', () => {
-    test(`should should be set from the data`, () => {
+    test(`should be set from the data`, () => {
       const contact = new Contact(contactDataFixture.create({ notes: 'foo' }))
       expect(contact.notes).toEqual('foo')
     })
 
-    test(`should should be optional`, () => {
+    test(`should be optional`, () => {
       const contact = new Contact(contactDataFixture.omit('notes').create())
       expect(contact.notes).toBeUndefined()
     })
   })
 
   describe('links', () => {
-    test(`should should be set from the data`, () => {
+    test(`should be set from the data`, () => {
       const contact = new Contact(contactDataFixture.create({ links: [{ title: 'foo', href: 'bar' }] }))
       expect(contact.links).toStrictEqual([{ title: 'foo', href: 'bar' }])
     })
 
-    test(`should should be optional`, () => {
+    test(`should be optional`, () => {
       const contact = new Contact(contactDataFixture.omit('links').create())
       expect(contact.links).toHaveLength(0)
     })

package/src/test/db/location.test.ts

@@ -0,0 +1,51 @@
+import { Location } from '../../main'
+
+describe(Location.name, () => {
+  describe('zoneKey', () => {
+    test(`should be set from the data`, () => {
+      const location = new Location({ zoneKey: 'foo' })
+      expect(location.zoneKey).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const location = new Location({})
+      expect(location.zoneKey).toBeUndefined()
+    })
+  })
+
+  describe('coords', () => {
+    test(`should be set from the data`, () => {
+      const location = new Location({ coords: [1, 2, 3] })
+      expect(location.coords).toStrictEqual([1, 2, 3])
+    })
+
+    test(`should be optional`, () => {
+      const location = new Location({})
+      expect(location.coords).toBeUndefined()
+    })
+  })
+
+  describe('icon', () => {
+    test(`should be set from the data`, () => {
+      const location = new Location({ icon: 'plaque' })
+      expect(location.icon).toBe('plaque')
+    })
+
+    test(`should be optional`, () => {
+      const location = new Location({})
+      expect(location.icon).toBeUndefined()
+    })
+  })
+
+  describe('iconText', () => {
+    test(`should be set from the data`, () => {
+      const location = new Location({ iconText: '1' })
+      expect(location.iconText).toBe('1')
+    })
+
+    test(`should be optional`, () => {
+      const location = new Location({})
+      expect(location.iconText).toBeUndefined()
+    })
+  })
+})