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

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

@@ -1,42 +1,282 @@
 import { CohContentDatabase } from '../../main'
-import { serverGroupDataFixture } from '../api/server-group-data.fixture'
+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'
+import { bundleDataFixture } from '../api/bundle-data.fixture'
 
 describe(CohContentDatabase.name, () => {
-  test('should be instantiable', () => {
-    expect(new CohContentDatabase()).not.toBeNull()
+  describe('Constructor', () => {
+    test('should load a basic bundle', () => {
+      new CohContentDatabase(bundleDataFixture.create())
+    })
+  })
+
+  describe('header', () => {
+    test(`should accept an undefined field`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.omit('header').create(),
+      )
+      expect(database.header).toBeDefined()
+      expect(database.header?.name).toBeUndefined()
+    })
+
+    test(`should load values from bundle`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create(
+          { header: { name: 'Homecoming' } },
+        ),
+      )
+
+      expect(database.header?.name).toBe('Homecoming')
+    })
+  })
+
+  describe('servers', () => {
+    test(`should accept an undefined field`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.omit('servers').create(),
+      )
+      expect(database.servers).toHaveLength(0)
+    })
+
+    test(`should load values from bundle`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture
+          .create({ servers: ['Foo', 'Bar'] }),
+      )
+      expect(database.servers).toStrictEqual(['Foo', 'Bar'])
+    })
+  })
+
+  describe('archetypes', () => {
+    test(`should accept an undefined field`, () => {
+      const database = new CohContentDatabase(bundleDataFixture
+        .omit('archetypes')
+        .create())
+      expect(database.archetypes).toHaveLength(0)
+    })
+
+    test(`should load data from bundle`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture
+          .create({ archetypes: [archetypeDataFixture.create({ key: 'foo' })] }),
+      )
+      expect(database.getArchetype('foo')).not.toBeUndefined()
+    })
+  })
+
+  describe('badges', () => {
+    test(`should accept an undefined field`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.omit('badges').create(),
+      )
+      expect(database.badges).toHaveLength(0)
+    })
+
+    test(`should load data from bundle`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture
+          .create({ badges: [badgeDataFixture.create({ key: 'foo' })] }),
+      )
+      expect(database.getBadge('foo')).not.toBeUndefined()
+    })
+  })
+
+  describe('zones', () => {
+    test(`should accept an undefined field`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.omit('zones').create(),
+      )
+      expect(database.zones).toHaveLength(0)
+    })
+
+    test(`should load data from bundle`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture
+          .create({ zones: [zoneDataFixture.create({ key: 'foo' })] }),
+      )
+      expect(database.getZone('foo')).not.toBeUndefined()
+    })
   })
 
-  describe(CohContentDatabase.prototype.loadServerGroupData.name, () => {
-    test('should load an empty server group', () => {
-      const database = new CohContentDatabase()
-      database.loadServerGroupData(serverGroupDataFixture.create())
+  describe('contacts', () => {
+    test(`should accept an undefined field`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.omit('contacts').create(),
+      )
+      expect(database.contacts).toHaveLength(0)
+    })
+
+    test(`should load data from bundle`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture
+          .create({ contacts: [contactDataFixture.create({ key: 'foo' })] }),
+      )
+      expect(database.getContact('foo')).not.toBeUndefined()
     })
   })
 
-  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' }))
+  describe('missions', () => {
+    test(`should accept an undefined field`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.omit('missions').create(),
+      )
+      expect(database.missions).toHaveLength(0)
+    })
 
-      const sgs = database.listServerGroups()
+    test(`should load data from bundle`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture
+          .create({ missions: [missionDataFixture.create({ key: 'foo' })] }),
+      )
+      expect(database.getMission('foo')).not.toBeUndefined()
+    })
+  })
 
-      expect(sgs).toHaveLength(2)
+  describe('getArchetype', () => {
+    test(`should retrieve archetype from the index`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({
+          archetypes: [archetypeDataFixture.create({ key: 'foo' })],
+        }),
+      )
+      expect(database.getArchetype('foo')).not.toBeUndefined()
+    })
+
+    test(`should return undefined for unknown archetype`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ archetypes: [] }),
+      )
+      expect(database.getArchetype('foo')).toBeUndefined()
+    })
+
+    test(`should return undefined for undefined key`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ archetypes: [] }),
+      )
+      const key = undefined
+      expect(database.getArchetype(key)).toBeUndefined()
+    })
+  })
+
+  describe('getZone', () => {
+    test(`should retrieve zone from the index`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({
+          zones: [zoneDataFixture.create({ key: 'foo' })],
+        }),
+      )
+      expect(database.getZone('foo')).not.toBeUndefined()
+    })
+
+    test(`should return undefined for unknown zone`, () => {
+      const database = new CohContentDatabase(bundleDataFixture.create({ zones: [] }))
+      expect(database.getZone('foo')).toBeUndefined()
+    })
+
+    test(`should return undefined for undefined key`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ zones: [] }),
+      )
+      const key = undefined
+      expect(database.getZone(key)).toBeUndefined()
+    })
+  })
+
+  describe('getContact', () => {
+    test(`should retrieve contact from the index`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({
+          contacts: [contactDataFixture.create({ key: 'foo' })],
+        }),
+      )
+      expect(database.getContact('foo')).not.toBeUndefined()
+    })
+
+    test(`should return undefined for unknown contact`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ contacts: [] }),
+      )
+      expect(database.getContact('foo')).toBeUndefined()
+    })
+
+    test(`should return undefined for undefined key`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ contacts: [] }),
+      )
+      const key = undefined
+      expect(database.getContact(key)).toBeUndefined()
+    })
+  })
+
+  describe('getMission', () => {
+    test(`should retrieve mission from the index`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({
+          missions: [missionDataFixture.create({ key: 'foo' })],
+        }),
+      )
+      expect(database.getMission('foo')).not.toBeUndefined()
+    })
+
+    test(`should return undefined for unknown mission`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ missions: [] }),
+      )
+      expect(database.getMission('foo')).toBeUndefined()
+    })
+
+    test(`should return undefined for undefined key`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ missions: [] }),
+      )
+      const key = undefined
+      expect(database.getMission(key)).toBeUndefined()
+    })
+  })
+
+  describe('getBadge', () => {
+    test(`should retrieve badge from the index`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({
+          badges: [badgeDataFixture.create({ key: 'foo' })],
+        }),
+      )
+      expect(database.getBadge('foo')).not.toBeUndefined()
+    })
+
+    test(`should return undefined for unknown badge`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ badges: [] }),
+      )
+      expect(database.getBadge('foo')).toBeUndefined()
+    })
 
-      for (const entry of sgs) {
-        expect(['sg1', 'sg2']).toContain(entry.key)
-      }
+    test(`should return undefined for undefined key`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ badges: [] }),
+      )
+      const key = undefined
+      expect(database.getBadge(key)).toBeUndefined()
     })
   })
 
-  describe(CohContentDatabase.prototype.getServerGroup.name, () => {
-    test('should load a server group by key', () => {
-      const database = new CohContentDatabase()
-      database.loadServerGroupData(serverGroupDataFixture.create({ key: 'sg1' }))
+  describe('searchBadges', () => {
+    test(`should search the badge list`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({
+          badges: [
+            badgeDataFixture.create({ key: 'foo', name: [{ value: 'Foo' }] }),
+            badgeDataFixture.create({ key: 'bar', name: [{ value: 'Bar' }] }),
+          ],
+        }),
+      )
 
-      const sg = database.getServerGroup('sg1')
-      expect(sg).not.toBeNull()
-      expect(sg?.key).toEqual('sg1')
+      const result = database.searchBadges({ query: { str: 'oo', fields: ['name'] } })
+      expect(result.totalItems).toBe(1)
+      expect(result.items.map(x => x.key)).toStrictEqual(['foo'])
     })
   })
 })

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

@@ -0,0 +1,97 @@
+import { Contact } from '../../main'
+import { contactDataFixture } from '../api/contact-data.fixture'
+
+describe(Contact.name, () => {
+  describe('Constructor', () => {
+    test(`should accept the test fixture`, () => {
+      new Contact(contactDataFixture.create())
+    })
+  })
+
+  describe('key', () => {
+    test(`should be set from the data`, () => {
+      const contact = new Contact(contactDataFixture.create({ key: 'foo' }))
+      expect(contact.key).toEqual('foo')
+    })
+  })
+
+  describe('name', () => {
+    test(`should be set from the data`, () => {
+      const contact = new Contact(contactDataFixture.create({ name: 'foo' }))
+      expect(contact.name).toEqual('foo')
+    })
+  })
+
+  describe('title', () => {
+    test(`should be set from the data`, () => {
+      const contact = new Contact(contactDataFixture.create({ title: 'foo' }))
+      expect(contact.title).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const contact = new Contact(contactDataFixture.omit('title').create())
+      expect(contact.title).toBeUndefined()
+    })
+  })
+
+  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 be optional`, () => {
+      const contact = new Contact(contactDataFixture.omit('morality').create())
+      expect(contact.morality?.all).toBeTruthy()
+    })
+  })
+
+  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 be optional`, () => {
+      const contact = new Contact(contactDataFixture.omit('location').create())
+      expect(contact.location).toBeUndefined()
+    })
+  })
+
+  describe('levelRange', () => {
+    test(`should be set from the data`, () => {
+      const contact = new Contact(contactDataFixture.create({ levelRange: [1, 2] }))
+      expect(contact.levelRange).toStrictEqual([1, 2])
+    })
+
+    test(`should be optional`, () => {
+      const contact = new Contact(contactDataFixture.omit('levelRange').create())
+      expect(contact.levelRange).toBeUndefined()
+    })
+  })
+
+  describe('notes', () => {
+    test(`should be set from the data`, () => {
+      const contact = new Contact(contactDataFixture.create({ notes: 'foo' }))
+      expect(contact.notes).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const contact = new Contact(contactDataFixture.omit('notes').create())
+      expect(contact.notes).toBeUndefined()
+    })
+  })
+
+  describe('links', () => {
+    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 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()
+    })
+  })
+})

package/src/test/db/mission.test.ts

@@ -0,0 +1,171 @@
+import { Mission } from '../../main'
+import { missionDataFixture, missionFlashbackDataFixture } from '../api/mission-data.fixture'
+
+describe(Mission.name, () => {
+  describe('Constructor', () => {
+    test(`should accept the test fixture`, () => {
+      new Mission(missionDataFixture.create())
+    })
+  })
+
+  describe('key', () => {
+    test(`should be set from the data`, () => {
+      const mission = new Mission(missionDataFixture.create({ key: 'foo' }))
+      expect(mission.key).toEqual('foo')
+    })
+  })
+
+  describe('name', () => {
+    test(`should be set from the data`, () => {
+      const mission = new Mission(missionDataFixture.create({ name: 'Foo' }))
+      expect(mission.name).toEqual('Foo')
+    })
+  })
+
+  describe('type', () => {
+    test(`should be set from the data`, () => {
+      const mission = new Mission(missionDataFixture.create({ type: 'story-arc' }))
+      expect(mission.type).toEqual('story-arc')
+    })
+  })
+
+  describe('morality', () => {
+    test(`should be set from the data`, () => {
+      const mission = new Mission(missionDataFixture.create({ morality: ['hero'] }))
+      expect(mission.morality?.hero).toBeTruthy()
+      expect(mission.morality?.vigilante).toBeFalsy()
+    })
+
+    test(`should be optional`, () => {
+      const mission = new Mission(missionDataFixture.omit('morality').create())
+      expect(mission.morality?.all).toBeTruthy()
+    })
+  })
+
+  describe('contactKeys', () => {
+    test(`should be set from the data`, () => {
+      const mission = new Mission(missionDataFixture.create({ contactKeys: 'foo' }))
+      expect(mission.contactKeys).toStrictEqual(['foo'])
+    })
+
+    test(`should be optional`, () => {
+      const mission = new Mission(missionDataFixture.omit('contactKeys').create())
+      expect(mission.contactKeys).toBeUndefined()
+    })
+  })
+
+  describe('levelRange', () => {
+    test(`should be set from the data`, () => {
+      const mission = new Mission(missionDataFixture.create({ levelRange: [1, 2] }))
+      expect(mission.levelRange).toStrictEqual([1, 2])
+    })
+
+    test(`should be optional`, () => {
+      const mission = new Mission(missionDataFixture.omit('levelRange').create())
+      expect(mission.levelRange).toBeUndefined()
+    })
+  })
+
+  describe('notes', () => {
+    test(`should be set from the data`, () => {
+      const mission = new Mission(missionDataFixture.create({ notes: 'foo' }))
+      expect(mission.notes).toBe('foo')
+    })
+
+    test(`should be optional`, () => {
+      const mission = new Mission(missionDataFixture.omit('notes').create())
+      expect(mission.notes).toBeUndefined()
+    })
+  })
+
+  describe('links', () => {
+    test('should be set from the data', () => {
+      const badge = new Mission(missionDataFixture.create({ links: [{ title: 'foo', href: 'bar' }] }))
+      expect(badge.links).toStrictEqual([{ title: 'foo', href: 'bar' }])
+    })
+
+    test('should be optional', () => {
+      const badge = new Mission(missionDataFixture.omit('links').create())
+      expect(badge.links).toHaveLength(0)
+    })
+  })
+
+  describe('flashback', () => {
+    test('should be undefined if omitted', () => {
+      const badge = new Mission(missionDataFixture.omit('flashback').create())
+      expect(badge.flashback).toBeFalsy()
+    })
+
+    describe('id', () => {
+      test(`should be set from the data`, () => {
+        const mission = new Mission(missionDataFixture.create({ flashback: { id: 'foo' } }))
+        expect(mission.flashback?.id).toBe('foo')
+      })
+    })
+
+    describe('levelRange', () => {
+      test(`should be set from the data`, () => {
+        const mission = new Mission(missionDataFixture.create({ flashback: { levelRange: [1, 2] } }))
+        expect(mission.flashback?.levelRange).toStrictEqual([1, 2])
+      })
+
+      test(`should default to the mission value`, () => {
+        const mission = new Mission(missionDataFixture.create({ levelRange: [1, 2], flashback: missionFlashbackDataFixture.omit('levelRange').create() }))
+        expect(mission.flashback?.levelRange).toStrictEqual([1, 2])
+      })
+
+      test(`should be optional`, () => {
+        const mission = new Mission(missionDataFixture.omit('levelRange').create({ flashback: missionFlashbackDataFixture.omit('levelRange').create() }))
+        expect(mission.flashback?.levelRange).toBeUndefined()
+      })
+    })
+
+    describe('name', () => {
+      test(`should be set from the data`, () => {
+        const mission = new Mission(missionDataFixture.create({ flashback: { name: 'Foo' } }))
+        expect(mission.flashback?.name).toStrictEqual('Foo')
+      })
+
+      test(`should default to the mission value`, () => {
+        const mission = new Mission(missionDataFixture.create({ name: 'Foo', flashback: missionFlashbackDataFixture.omit('name').create() }))
+        expect(mission.flashback?.name).toStrictEqual('Foo')
+      })
+
+      test(`should be optional`, () => {
+        const mission = new Mission(missionDataFixture.omit('name').create({ flashback: missionFlashbackDataFixture.omit('name').create() }))
+        expect(mission.flashback?.name).toBeUndefined()
+      })
+    })
+
+    describe('morality', () => {
+      test(`should be set from the data`, () => {
+        const mission = new Mission(missionDataFixture.create({ flashback: { morality: ['hero'] } }))
+        expect(mission.flashback?.morality?.hero).toBeTruthy()
+        expect(mission.flashback?.morality?.vigilante).toBeFalsy()
+      })
+
+      test(`should default to the mission value`, () => {
+        const mission = new Mission(missionDataFixture.create({ morality: ['hero'], flashback: missionFlashbackDataFixture.omit('morality').create() }))
+        expect(mission.flashback?.morality?.hero).toBeTruthy()
+        expect(mission.flashback?.morality?.vigilante).toBeFalsy()
+      })
+
+      test(`should be optional`, () => {
+        const mission = new Mission(missionDataFixture.omit('morality').create({ flashback: missionFlashbackDataFixture.omit('morality').create() }))
+        expect(mission.morality?.all).toBeTruthy()
+      })
+    })
+
+    describe('notes', () => {
+      test(`should be set from the data`, () => {
+        const mission = new Mission(missionDataFixture.create({ flashback: { notes: 'foo' } }))
+        expect(mission.flashback?.notes).toStrictEqual('foo')
+      })
+
+      test(`should be optional`, () => {
+        const mission = new Mission(missionDataFixture.create({ flashback: missionFlashbackDataFixture.omit('notes').create() }))
+        expect(mission.flashback?.notes).toBeUndefined()
+      })
+    })
+  })
+})