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

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

@@ -0,0 +1,457 @@
+import { MoralityList } from '../../main'
+
+describe(MoralityList.name, () => {
+  describe('items', () => {
+    test('should return the basic set', () => {
+      expect(new MoralityList(['hero', 'villain', 'loyalist']).items).toStrictEqual(['hero', 'villain', 'loyalist'])
+    })
+
+    test('should collapse extended values', () => {
+      expect(new MoralityList(['primal']).items).toStrictEqual(['hero', 'vigilante', 'villain', 'rogue'])
+      expect(new MoralityList(['heroic']).items).toStrictEqual(['hero', 'vigilante'])
+      expect(new MoralityList(['heroic', 'praetorian']).items).toStrictEqual(['hero', 'vigilante', 'resistance', 'loyalist'])
+    })
+
+    test('should not duplicate overlaps', () => {
+      expect(new MoralityList(['primal', 'heroic', 'hero']).items).toStrictEqual(['hero', 'vigilante', 'villain', 'rogue'])
+      expect(new MoralityList(['all', 'heroic', 'hero']).items).toStrictEqual(['hero', 'vigilante', 'villain', 'rogue', 'resistance', 'loyalist'])
+    })
+
+    test('should have deterministic order', () => {
+      expect(new MoralityList(['hero', 'villain']).items).toStrictEqual(['hero', 'villain'])
+      expect(new MoralityList(['villain', 'hero']).items).toStrictEqual(['hero', 'villain'])
+      expect(new MoralityList(['primal', 'all', 'hero']).items).toStrictEqual(['hero', 'vigilante', 'villain', 'rogue', 'resistance', 'loyalist'])
+      expect(new MoralityList(['hero', 'primal', 'all']).items).toStrictEqual(['hero', 'vigilante', 'villain', 'rogue', 'resistance', 'loyalist'])
+      expect(new MoralityList(['all', 'hero', 'primal']).items).toStrictEqual(['hero', 'vigilante', 'villain', 'rogue', 'resistance', 'loyalist'])
+    })
+
+    test('should treat undefined as all values', () => {
+      expect(new MoralityList().items).toStrictEqual(['hero', 'vigilante', 'villain', 'rogue', 'resistance', 'loyalist'])
+    })
+
+    test('should treat empty as no values', () => {
+      expect(new MoralityList([]).items).toStrictEqual([])
+    })
+  })
+
+  describe('values', () => {
+    test('should all be true when undefined', () => {
+      const moralitys = new MoralityList()
+      expect(moralitys.hero).toBeTruthy()
+      expect(moralitys.vigilante).toBeTruthy()
+      expect(moralitys.villain).toBeTruthy()
+      expect(moralitys.rogue).toBeTruthy()
+      expect(moralitys.resistance).toBeTruthy()
+      expect(moralitys.loyalist).toBeTruthy()
+      expect(moralitys.primal).toBeTruthy()
+      expect(moralitys.praetorian).toBeTruthy()
+      expect(moralitys.heroic).toBeTruthy()
+      expect(moralitys.villainous).toBeTruthy()
+      expect(moralitys.paragonCityAccess).toBeTruthy()
+      expect(moralitys.rogueIslesAccess).toBeTruthy()
+      expect(moralitys.all).toBeTruthy()
+    })
+
+    test('should all be false when empty', () => {
+      const moralitys = new MoralityList([])
+      expect(moralitys.hero).toBeFalsy()
+      expect(moralitys.vigilante).toBeFalsy()
+      expect(moralitys.villain).toBeFalsy()
+      expect(moralitys.rogue).toBeFalsy()
+      expect(moralitys.resistance).toBeFalsy()
+      expect(moralitys.loyalist).toBeFalsy()
+      expect(moralitys.primal).toBeFalsy()
+      expect(moralitys.praetorian).toBeFalsy()
+      expect(moralitys.heroic).toBeFalsy()
+      expect(moralitys.villainous).toBeFalsy()
+      expect(moralitys.paragonCityAccess).toBeFalsy()
+      expect(moralitys.rogueIslesAccess).toBeFalsy()
+      expect(moralitys.all).toBeFalsy()
+    })
+  })
+
+  describe('hero', () => {
+    test('should detect a hero', () => {
+      expect(new MoralityList(['hero', 'villain']).hero).toBeTruthy()
+    })
+
+    test('should detect primal', () => {
+      expect(new MoralityList(['primal']).hero).toBeTruthy()
+    })
+
+    test('should detect heroic', () => {
+      expect(new MoralityList(['heroic']).hero).toBeTruthy()
+    })
+
+    test('should detect paragon-city-access', () => {
+      expect(new MoralityList(['paragon-city-access']).hero).toBeTruthy()
+    })
+
+    test('should detect all', () => {
+      expect(new MoralityList(['all']).hero).toBeTruthy()
+    })
+
+    test('should not falsely detect a hero', () => {
+      expect(new MoralityList(['villain']).hero).toBeFalsy()
+    })
+  })
+
+  describe('vigilante', () => {
+    test('should detect a vigilante', () => {
+      expect(new MoralityList(['vigilante', 'villain']).vigilante).toBeTruthy()
+    })
+
+    test('should detect primal', () => {
+      expect(new MoralityList(['primal']).vigilante).toBeTruthy()
+    })
+
+    test('should detect heroic', () => {
+      expect(new MoralityList(['heroic']).vigilante).toBeTruthy()
+    })
+
+    test('should detect paragon-city-access', () => {
+      expect(new MoralityList(['paragon-city-access']).vigilante).toBeTruthy()
+    })
+
+    test('should detect rogue-isles-access', () => {
+      expect(new MoralityList(['rogue-isles-access']).vigilante).toBeTruthy()
+    })
+
+    test('should detect all', () => {
+      expect(new MoralityList(['all']).vigilante).toBeTruthy()
+    })
+
+    test('should not falsely detect a vigilante', () => {
+      expect(new MoralityList(['villain']).vigilante).toBeFalsy()
+    })
+  })
+
+  describe('villain', () => {
+    test('should detect a villain', () => {
+      expect(new MoralityList(['hero', 'villain']).villain).toBeTruthy()
+    })
+
+    test('should detect primal', () => {
+      expect(new MoralityList(['primal']).villain).toBeTruthy()
+    })
+
+    test('should detect villainous', () => {
+      expect(new MoralityList(['villainous']).villain).toBeTruthy()
+    })
+
+    test('should detect rogue-isles-access', () => {
+      expect(new MoralityList(['rogue-isles-access']).villain).toBeTruthy()
+    })
+
+    test('should detect all', () => {
+      expect(new MoralityList(['all']).villain).toBeTruthy()
+    })
+
+    test('should not falsely detect a villain', () => {
+      expect(new MoralityList(['hero']).villain).toBeFalsy()
+    })
+  })
+
+  describe('rogue', () => {
+    test('should detect a rogue', () => {
+      expect(new MoralityList(['hero', 'rogue']).rogue).toBeTruthy()
+    })
+
+    test('should detect primal', () => {
+      expect(new MoralityList(['primal']).rogue).toBeTruthy()
+    })
+
+    test('should detect villainous', () => {
+      expect(new MoralityList(['villainous']).rogue).toBeTruthy()
+    })
+
+    test('should detect paragon-city-access', () => {
+      expect(new MoralityList(['paragon-city-access']).rogue).toBeTruthy()
+    })
+
+    test('should detect rogue-isles-access', () => {
+      expect(new MoralityList(['rogue-isles-access']).rogue).toBeTruthy()
+    })
+
+    test('should detect all', () => {
+      expect(new MoralityList(['all']).rogue).toBeTruthy()
+    })
+
+    test('should not falsely detect a rogue', () => {
+      expect(new MoralityList(['hero']).rogue).toBeFalsy()
+    })
+  })
+
+  describe('primal', () => {
+    test('should detect hero, vigilante, villain and rogue', () => {
+      expect(new MoralityList(['hero', 'vigilante', 'villain', 'rogue']).primal).toBeTruthy()
+    })
+
+    test('should detect primal', () => {
+      expect(new MoralityList(['primal']).primal).toBeTruthy()
+    })
+
+    test('should detect all', () => {
+      expect(new MoralityList(['all']).primal).toBeTruthy()
+    })
+
+    test('should not falsely detect a primal', () => {
+      expect(new MoralityList(['villain']).primal).toBeFalsy()
+      expect(new MoralityList(['praetorian']).primal).toBeFalsy()
+      expect(new MoralityList(['hero', 'villain']).primal).toBeFalsy()
+    })
+  })
+
+  describe('praetorian', () => {
+    test('should detect resistance and loyalist', () => {
+      expect(new MoralityList(['resistance', 'loyalist']).praetorian).toBeTruthy()
+    })
+
+    test('should detect praetorian', () => {
+      expect(new MoralityList(['praetorian']).praetorian).toBeTruthy()
+    })
+
+    test('should detect all', () => {
+      expect(new MoralityList(['all']).praetorian).toBeTruthy()
+    })
+
+    test('should not falsely detect a praetorian', () => {
+      expect(new MoralityList(['villain']).praetorian).toBeFalsy()
+      expect(new MoralityList(['primal']).praetorian).toBeFalsy()
+      expect(new MoralityList(['hero', 'villain']).praetorian).toBeFalsy()
+    })
+  })
+
+  describe('heroic', () => {
+    test('should detect hero and vigilante', () => {
+      expect(new MoralityList(['hero', 'vigilante']).heroic).toBeTruthy()
+    })
+
+    test('should detect heroic', () => {
+      expect(new MoralityList(['heroic']).heroic).toBeTruthy()
+    })
+
+    test('should detect paragon-city-access', () => {
+      expect(new MoralityList(['paragon-city-access']).heroic).toBeTruthy()
+    })
+
+    test('should detect all', () => {
+      expect(new MoralityList(['all']).heroic).toBeTruthy()
+    })
+
+    test('should not falsely detect heroic', () => {
+      expect(new MoralityList(['villain']).heroic).toBeFalsy()
+      expect(new MoralityList(['praetorian']).heroic).toBeFalsy()
+      expect(new MoralityList(['villain', 'rogue']).heroic).toBeFalsy()
+    })
+  })
+
+  describe('villainous', () => {
+    test('should detect villain and rogue', () => {
+      expect(new MoralityList(['villain', 'rogue']).villainous).toBeTruthy()
+    })
+
+    test('should detect villainous', () => {
+      expect(new MoralityList(['villainous']).villainous).toBeTruthy()
+    })
+
+    test('should detect rogue-isles-access', () => {
+      expect(new MoralityList(['rogue-isles-access']).villainous).toBeTruthy()
+    })
+
+    test('should detect all', () => {
+      expect(new MoralityList(['all']).villainous).toBeTruthy()
+    })
+
+    test('should not falsely detect villainous', () => {
+      expect(new MoralityList(['villain']).villainous).toBeFalsy()
+      expect(new MoralityList(['praetorian']).villainous).toBeFalsy()
+      expect(new MoralityList(['hero', 'vigilante']).villainous).toBeFalsy()
+    })
+  })
+
+  describe('paragonCityAccess', () => {
+    test('should detect hero, vigilante and rogue', () => {
+      expect(new MoralityList(['hero', 'vigilante', 'rogue']).paragonCityAccess).toBeTruthy()
+    })
+
+    test('should detect paragon-city-access', () => {
+      expect(new MoralityList(['paragon-city-access']).paragonCityAccess).toBeTruthy()
+    })
+
+    test('should detect all', () => {
+      expect(new MoralityList(['all']).paragonCityAccess).toBeTruthy()
+    })
+
+    test('should not falsely detect paragonCityAccess', () => {
+      expect(new MoralityList(['villain']).paragonCityAccess).toBeFalsy()
+      expect(new MoralityList(['praetorian']).paragonCityAccess).toBeFalsy()
+      expect(new MoralityList(['hero', 'vigilante']).paragonCityAccess).toBeFalsy()
+    })
+  })
+
+  describe('rogueIslesAccess', () => {
+    test('should detect villain, rogue and vigilante', () => {
+      expect(new MoralityList(['villain', 'rogue', 'vigilante']).rogueIslesAccess).toBeTruthy()
+    })
+
+    test('should detect rogue-isles-access', () => {
+      expect(new MoralityList(['rogue-isles-access']).rogueIslesAccess).toBeTruthy()
+    })
+
+    test('should detect all', () => {
+      expect(new MoralityList(['all']).rogueIslesAccess).toBeTruthy()
+    })
+
+    test('should not falsely detect rogueIslesAccess', () => {
+      expect(new MoralityList(['villain']).rogueIslesAccess).toBeFalsy()
+      expect(new MoralityList(['praetorian']).rogueIslesAccess).toBeFalsy()
+      expect(new MoralityList(['hero', 'vigilante']).rogueIslesAccess).toBeFalsy()
+    })
+  })
+
+  describe('all', () => {
+    test('should detect when all are present', () => {
+      expect(new MoralityList(['hero', 'vigilante', 'villain', 'rogue', 'resistance', 'loyalist']).all).toBeTruthy()
+      expect(new MoralityList(['heroic', 'villainous', 'praetorian']).all).toBeTruthy()
+      expect(new MoralityList(['primal', 'praetorian']).all).toBeTruthy()
+    })
+
+    test('should detect all', () => {
+      expect(new MoralityList(['all']).all).toBeTruthy()
+    })
+
+    test('should not falsely detect all', () => {
+      expect(new MoralityList(['villain']).all).toBeFalsy()
+      expect(new MoralityList(['praetorian']).all).toBeFalsy()
+      expect(new MoralityList(['primal']).all).toBeFalsy()
+    })
+  })
+
+  describe('has', () => {
+    test('should return true if present', () => {
+      expect(new MoralityList(['villain']).has('villain')).toBeTruthy()
+      expect(new MoralityList(['hero', 'loyalist']).has('loyalist')).toBeTruthy()
+    })
+
+    test('should return false if absent', () => {
+      expect(new MoralityList(['hero']).has('villain')).toBeFalsy()
+      expect(new MoralityList(['heroic']).has('villain')).toBeFalsy()
+      expect(new MoralityList(['hero', 'praetorian']).has('primal')).toBeFalsy()
+    })
+
+    test('should return false if undefined', () => {
+      expect(new MoralityList(['hero']).has()).toBeFalsy()
+    })
+
+    test('should test hero correctly', () => {
+      expect(new MoralityList(['hero']).has('hero')).toBeTruthy()
+      expect(new MoralityList(['heroic']).has('hero')).toBeTruthy()
+      expect(new MoralityList(['primal']).has('hero')).toBeTruthy()
+      expect(new MoralityList(['all']).has('hero')).toBeTruthy()
+
+      expect(new MoralityList(['villain']).has('hero')).toBeFalsy()
+    })
+
+    test('should test vigilante correctly', () => {
+      expect(new MoralityList(['hero', 'vigilante']).has('vigilante')).toBeTruthy()
+      expect(new MoralityList(['heroic']).has('vigilante')).toBeTruthy()
+      expect(new MoralityList(['primal']).has('vigilante')).toBeTruthy()
+      expect(new MoralityList(['all']).has('vigilante')).toBeTruthy()
+
+      expect(new MoralityList(['villain']).has('vigilante')).toBeFalsy()
+    })
+
+    test('should test villain correctly', () => {
+      expect(new MoralityList(['villain']).has('villain')).toBeTruthy()
+      expect(new MoralityList(['villainous']).has('villain')).toBeTruthy()
+      expect(new MoralityList(['primal']).has('villain')).toBeTruthy()
+      expect(new MoralityList(['all']).has('villain')).toBeTruthy()
+
+      expect(new MoralityList(['hero']).has('villain')).toBeFalsy()
+    })
+
+    test('should test rogue correctly', () => {
+      expect(new MoralityList(['rogue']).has('rogue')).toBeTruthy()
+      expect(new MoralityList(['villainous']).has('rogue')).toBeTruthy()
+      expect(new MoralityList(['primal']).has('rogue')).toBeTruthy()
+      expect(new MoralityList(['all']).has('rogue')).toBeTruthy()
+
+      expect(new MoralityList(['hero']).has('rogue')).toBeFalsy()
+    })
+
+    test('should test resistance correctly', () => {
+      expect(new MoralityList(['resistance']).has('resistance')).toBeTruthy()
+      expect(new MoralityList(['praetorian']).has('resistance')).toBeTruthy()
+      expect(new MoralityList(['all']).has('resistance')).toBeTruthy()
+
+      expect(new MoralityList(['villain']).has('resistance')).toBeFalsy()
+    })
+
+    test('should test loyalist correctly', () => {
+      expect(new MoralityList(['loyalist']).has('loyalist')).toBeTruthy()
+      expect(new MoralityList(['praetorian']).has('loyalist')).toBeTruthy()
+      expect(new MoralityList(['all']).has('loyalist')).toBeTruthy()
+
+      expect(new MoralityList(['villain']).has('loyalist')).toBeFalsy()
+    })
+
+    test('should test primal correctly', () => {
+      expect(new MoralityList(['hero', 'vigilante', 'villain', 'rogue']).has('primal')).toBeTruthy()
+      expect(new MoralityList(['heroic', 'villainous']).has('primal')).toBeTruthy()
+      expect(new MoralityList(['primal']).has('primal')).toBeTruthy()
+      expect(new MoralityList(['all']).has('primal')).toBeTruthy()
+
+      expect(new MoralityList(['villain']).has('primal')).toBeFalsy()
+    })
+
+    test('should test praetorian correctly', () => {
+      expect(new MoralityList(['resistance', 'loyalist']).has('praetorian')).toBeTruthy()
+      expect(new MoralityList(['praetorian']).has('praetorian')).toBeTruthy()
+      expect(new MoralityList(['all']).has('praetorian')).toBeTruthy()
+
+      expect(new MoralityList(['villain']).has('praetorian')).toBeFalsy()
+    })
+
+    test('should test heroic correctly', () => {
+      expect(new MoralityList(['hero', 'vigilante']).has('heroic')).toBeTruthy()
+      expect(new MoralityList(['heroic']).has('heroic')).toBeTruthy()
+      expect(new MoralityList(['all']).has('heroic')).toBeTruthy()
+
+      expect(new MoralityList(['villain']).has('heroic')).toBeFalsy()
+    })
+
+    test('should test villainous correctly', () => {
+      expect(new MoralityList(['villain', 'rogue']).has('villainous')).toBeTruthy()
+      expect(new MoralityList(['villainous']).has('villainous')).toBeTruthy()
+      expect(new MoralityList(['all']).has('villainous')).toBeTruthy()
+
+      expect(new MoralityList(['villain']).has('villainous')).toBeFalsy()
+    })
+
+    test('should test paragon-city-access correctly', () => {
+      expect(new MoralityList(['hero', 'vigilante', 'rogue']).has('paragon-city-access')).toBeTruthy()
+      expect(new MoralityList(['heroic', 'rogue']).has('paragon-city-access')).toBeTruthy()
+      expect(new MoralityList(['all']).has('paragon-city-access')).toBeTruthy()
+
+      expect(new MoralityList(['villain']).has('paragon-city-access')).toBeFalsy()
+    })
+
+    test('should test rogue-isles-access correctly', () => {
+      expect(new MoralityList(['villain', 'rogue', 'vigilante']).has('rogue-isles-access')).toBeTruthy()
+      expect(new MoralityList(['villainous', 'vigilante']).has('rogue-isles-access')).toBeTruthy()
+      expect(new MoralityList(['all']).has('rogue-isles-access')).toBeTruthy()
+
+      expect(new MoralityList(['villain']).has('rogue-isles-access')).toBeFalsy()
+    })
+
+    test('should test all correctly', () => {
+      expect(new MoralityList(['hero', 'vigilante', 'villain', 'rogue', 'resistance', 'loyalist']).has('all')).toBeTruthy()
+      expect(new MoralityList(['primal', 'praetorian']).has('all')).toBeTruthy()
+      expect(new MoralityList(['heroic', 'villainous', 'praetorian']).has('all')).toBeTruthy()
+      expect(new MoralityList(['all']).has('all')).toBeTruthy()
+
+      expect(new MoralityList(['villain']).has('all')).toBeFalsy()
+    })
+  })
+})

package/src/test/db/zone.test.ts

@@ -0,0 +1,36 @@
+import { Zone } from '../../main'
+import { zoneDataFixture } from '../api/zone-data.fixture'
+
+describe(Zone.name, () => {
+  describe('Constructor', () => {
+    test(`should accept the test fixture`, () => {
+      new Zone(zoneDataFixture.create())
+    })
+  })
+
+  describe('key', () => {
+    test(`should be set from the data`, () => {
+      const zone = new Zone(zoneDataFixture.create({ key: 'foo' }))
+      expect(zone.key).toEqual('foo')
+    })
+  })
+
+  describe('name', () => {
+    test(`should be set from the data`, () => {
+      const zone = new Zone(zoneDataFixture.create({ name: 'foo' }))
+      expect(zone.name).toEqual('foo')
+    })
+  })
+
+  describe('links', () => {
+    test(`should be set from the data`, () => {
+      const zone = new Zone(zoneDataFixture.create({ links: [{ title: 'foo', href: 'bar' }] }))
+      expect(zone.links).toStrictEqual([{ title: 'foo', href: 'bar' }])
+    })
+
+    test(`should be optional`, () => {
+      const zone = new Zone(zoneDataFixture.omit('links').create())
+      expect(zone.links).toHaveLength(0)
+    })
+  })
+})

package/src/test/integration.test.ts

@@ -0,0 +1,16 @@
+import { BundleData } from '../main'
+import { TEST_BADGE } from './api/badge-data.test'
+
+/**
+ * If you change this test, update the example in the README as well
+ */
+export const TEST_BUNDLE: BundleData = {
+  header: { name: 'My Content Bundle' },
+  badges: [TEST_BADGE],
+}
+
+describe('BundleData', () => {
+  test('should be a usable interface', () => {
+    expect(TEST_BUNDLE).not.toBeUndefined()
+  })
+})

package/src/test/util.test.ts

@@ -0,0 +1,165 @@
+import { Badge, badgeLink, badgeUri, coalesceToArray, Contact, contactLink, contactUri, Mission, missionLink, missionUri, Zone, zoneLink, zoneUri } from '../main'
+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(badgeUri.name, () => {
+  test('should return the expected pattern', () => {
+    expect(badgeUri('foo')).toBe('badge://foo')
+    expect(badgeUri('bar')).toBe('badge://bar')
+    expect(badgeUri('foo-bar')).toBe('badge://foo-bar')
+  })
+
+  test('should accept a Badge object', () => {
+    const badge = new Badge(badgeDataFixture.create({ key: 'foo' }))
+    expect(badgeUri(badge)).toBe('badge://foo')
+  })
+
+  test('should accept a BadgeData object', () => {
+    const badge = badgeDataFixture.create({ key: 'foo' })
+    expect(badgeUri(badge)).toBe('badge://foo')
+  })
+})
+
+describe(badgeLink.name, () => {
+  test('should return the expected pattern', () => {
+    expect(badgeLink('foo')).toBe('[foo](badge://foo)')
+    expect(badgeLink('bar')).toBe('[bar](badge://bar)')
+    expect(badgeLink('foo-bar')).toBe('[foo-bar](badge://foo-bar)')
+  })
+
+  test('should accept a Badge object', () => {
+    const badge = new Badge(badgeDataFixture.create({ key: 'foo' }))
+    expect(badgeLink(badge)).toBe('[foo](badge://foo)')
+  })
+
+  test('should accept a BadgeData object', () => {
+    const badge = badgeDataFixture.create({ key: 'foo' })
+    expect(badgeLink(badge)).toBe('[foo](badge://foo)')
+  })
+})
+
+describe(contactUri.name, () => {
+  test('should return the expected pattern', () => {
+    expect(contactUri('foo')).toBe('contact://foo')
+    expect(contactUri('bar')).toBe('contact://bar')
+    expect(contactUri('foo-bar')).toBe('contact://foo-bar')
+  })
+
+  test('should accept a Contact object', () => {
+    const contact = new Contact(contactDataFixture.create({ key: 'foo' }))
+    expect(contactUri(contact)).toBe('contact://foo')
+  })
+
+  test('should accept a ContactData object', () => {
+    const contact = contactDataFixture.create({ key: 'foo' })
+    expect(contactUri(contact)).toBe('contact://foo')
+  })
+})
+
+describe(contactLink.name, () => {
+  test('should return the expected pattern', () => {
+    expect(contactLink('foo')).toBe('[foo](contact://foo)')
+    expect(contactLink('bar')).toBe('[bar](contact://bar)')
+    expect(contactLink('foo-bar')).toBe('[foo-bar](contact://foo-bar)')
+  })
+
+  test('should accept a Contact object', () => {
+    const contact = new Contact(contactDataFixture.create({ key: 'foo' }))
+    expect(contactLink(contact)).toBe('[foo](contact://foo)')
+  })
+
+  test('should accept a ContactData object', () => {
+    const contact = contactDataFixture.create({ key: 'foo' })
+    expect(contactLink(contact)).toBe('[foo](contact://foo)')
+  })
+})
+
+describe(missionUri.name, () => {
+  test('should return the expected pattern', () => {
+    expect(missionUri('foo')).toBe('mission://foo')
+    expect(missionUri('bar')).toBe('mission://bar')
+    expect(missionUri('foo-bar')).toBe('mission://foo-bar')
+  })
+
+  test('should accept a Mission object', () => {
+    const mission = new Mission(missionDataFixture.create({ key: 'foo' }))
+    expect(missionUri(mission)).toBe('mission://foo')
+  })
+
+  test('should accept a MissionData object', () => {
+    const mission = missionDataFixture.create({ key: 'foo' })
+    expect(missionUri(mission)).toBe('mission://foo')
+  })
+})
+
+describe(missionLink.name, () => {
+  test('should return the expected pattern', () => {
+    expect(missionLink('foo')).toBe('[foo](mission://foo)')
+    expect(missionLink('bar')).toBe('[bar](mission://bar)')
+    expect(missionLink('foo-bar')).toBe('[foo-bar](mission://foo-bar)')
+  })
+
+  test('should accept a Mission object', () => {
+    const mission = new Mission(missionDataFixture.create({ key: 'foo' }))
+    expect(missionLink(mission)).toBe('[foo](mission://foo)')
+  })
+
+  test('should accept a MissionData object', () => {
+    const mission = missionDataFixture.create({ key: 'foo' })
+    expect(missionLink(mission)).toBe('[foo](mission://foo)')
+  })
+})
+
+describe(zoneUri.name, () => {
+  test('should return the expected pattern', () => {
+    expect(zoneUri('foo')).toBe('zone://foo')
+    expect(zoneUri('bar')).toBe('zone://bar')
+    expect(zoneUri('foo-bar')).toBe('zone://foo-bar')
+  })
+
+  test('should accept a Zone object', () => {
+    const zone = new Zone(zoneDataFixture.create({ key: 'foo' }))
+    expect(zoneUri(zone)).toBe('zone://foo')
+  })
+
+  test('should accept a ZoneData object', () => {
+    const zone = zoneDataFixture.create({ key: 'foo' })
+    expect(zoneUri(zone)).toBe('zone://foo')
+  })
+})
+
+describe(zoneLink.name, () => {
+  test('should return the expected pattern', () => {
+    expect(zoneLink('foo')).toBe('[foo](zone://foo)')
+    expect(zoneLink('bar')).toBe('[bar](zone://bar)')
+    expect(zoneLink('foo-bar')).toBe('[foo-bar](zone://foo-bar)')
+  })
+
+  test('should accept a Zone object', () => {
+    const zone = new Zone(zoneDataFixture.create({ key: 'foo' }))
+    expect(zoneLink(zone)).toBe('[foo](zone://foo)')
+  })
+
+  test('should accept a ZoneData object', () => {
+    const zone = zoneDataFixture.create({ key: 'foo' })
+    expect(zoneLink(zone)).toBe('[foo](zone://foo)')
+  })
+})
+
+describe(coalesceToArray.name, () => {
+  test('should return an array unmodified', () => {
+    expect(coalesceToArray(['a', 'b'])).toStrictEqual(['a', 'b'])
+    expect(coalesceToArray([1, 2])).toStrictEqual([1, 2])
+  })
+
+  test('should return a single value as a single-value array', () => {
+    expect(coalesceToArray('a')).toStrictEqual(['a'])
+    expect(coalesceToArray(1)).toStrictEqual([1])
+  })
+
+  test('should return undefined value as undefined', () => {
+    expect(coalesceToArray()).toBeUndefined()
+  })
+})