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

package/src/test/db/badge.test.ts

@@ -0,0 +1,337 @@
+import { Badge, compareByDefaultName, compareByZoneKey } from '../../main'
+import { badgeDataFixture } from '../api/badge-data.fixture'
+import { badgeRequirementDataFixture } from '../api/badge-requirement-data.fixture'
+
+describe(Badge.name, () => {
+  describe('Constructor', () => {
+    test(`should accept the test fixture`, () => {
+      new Badge(badgeDataFixture.create())
+    })
+  })
+
+  describe('key', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ key: 'badge123' }))
+      expect(badge.key).toEqual('badge123')
+    })
+  })
+
+  describe('type', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ type: 'achievement' }))
+      expect(badge.type).toEqual('achievement')
+    })
+  })
+
+  describe('name', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ name: [{ value: 'foo' }] }))
+      expect(badge.name.default).toEqual({ value: 'foo' })
+    })
+  })
+
+  describe('morality', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ morality: ['hero', 'villain'] }))
+      expect(badge.morality.hero).toBeTruthy()
+      expect(badge.morality.villain).toBeTruthy()
+    })
+
+    test('should accept a single string', () => {
+      const badge = new Badge(badgeDataFixture.create({ morality: 'hero' }))
+      expect(badge.morality.hero).toBeTruthy()
+      expect(badge.morality.villain).toBeFalsy()
+    })
+
+    test('should be optional, defaulting to all', () => {
+      const badge = new Badge(badgeDataFixture.omit('morality').create())
+      expect(badge.morality.all).toBeTruthy()
+    })
+  })
+
+  describe('badgeText', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ badgeText: [{ value: 'foo' }] }))
+      expect(badge.badgeText.default).toEqual({ value: 'foo' })
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('badgeText').create())
+      expect(badge.badgeText.default).toBeUndefined()
+    })
+  })
+
+  describe('acquisition', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ acquisition: 'Quest Reward' }))
+      expect(badge.acquisition).toEqual('Quest Reward')
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('acquisition').create())
+      expect(badge.acquisition).toBeUndefined()
+    })
+  })
+
+  describe('icon', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ icon: [{ value: 'foo' }] }))
+      expect(badge.icon.default).toEqual({ value: 'foo' })
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('icon').create())
+      expect(badge.icon.default).toBeUndefined()
+    })
+  })
+
+  describe('notes', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ notes: 'foo' }))
+      expect(badge.notes).toEqual('foo')
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('notes').create())
+      expect(badge.notes).toBeUndefined()
+    })
+  })
+
+  describe('links', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ links: [{ title: 'foo', href: 'bar' }] }))
+      expect(badge.links).toStrictEqual([{ title: 'foo', href: 'bar' }])
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('links').create())
+      expect(badge.links).toHaveLength(0)
+    })
+  })
+
+  describe('effect', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ effect: 'foo' }))
+      expect(badge.effect).toEqual('foo')
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('effect').create())
+      expect(badge.effect).toBeUndefined()
+    })
+  })
+
+  describe('setTitle', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ setTitleId: [123, 456] }))
+      expect(badge.setTitleId).toStrictEqual([123, 456])
+    })
+
+    test('should treat the praetorian id as optional', () => {
+      const badge = new Badge(badgeDataFixture.create({ setTitleId: [123] }))
+      expect(badge.setTitleId).toStrictEqual([123])
+    })
+
+    test('should be optional', () => {
+      const badge = new Badge(badgeDataFixture.omit('setTitleId').create())
+      expect(badge.setTitleId).toBeUndefined()
+    })
+  })
+
+  describe('ignoreInTotals', () => {
+    test('should be set from the data', () => {
+      const badge = new Badge(badgeDataFixture.create({ ignoreInTotals: true }))
+      expect(badge.ignoreInTotals).toEqual(true)
+    })
+
+    test('should default to false', () => {
+      const badge = new Badge(badgeDataFixture.omit('ignoreInTotals').create())
+      expect(badge.ignoreInTotals).toEqual(false)
+    })
+  })
+
+  describe('requirements', () => {
+    test(`should throw an error on duplicate key`, () => {
+      const data = badgeDataFixture.create({
+        key: 'badge',
+        requirements: [
+          badgeRequirementDataFixture.create({ key: 'foo' }),
+          badgeRequirementDataFixture.create({ key: 'foo' }),
+        ],
+      })
+      expect(() => new Badge(data)).toThrow('Duplicate badge requirement key [badge:foo]')
+    })
+  })
+
+  describe('getRequirement', () => {
+    test(`should retrieve requirement from the index`, () => {
+      const data = badgeDataFixture.create({
+        requirements: [badgeRequirementDataFixture.create({ key: 'foo' })],
+      })
+
+      expect(new Badge(data).getRequirement('foo')).not.toBeUndefined()
+    })
+
+    test(`should throw error for unknown requirement`, () => {
+      const data = badgeDataFixture.create({
+        requirements: [],
+      })
+
+      expect(() => new Badge(data).getRequirement('foo')).toThrow('Unknown badge requirement key [foo]')
+    })
+  })
+
+  describe('zoneKeys', () => {
+    test(`should return the list of keys`, () => {
+      const badge = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'c' } }),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'b' } }),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'c' } }),
+        ],
+      }))
+      expect(badge.zoneKeys).toStrictEqual(['a', 'c', 'b'])
+    })
+
+    test(`should return undefined if there no zones`, () => {
+      const badge = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.omit('location').create(),
+        ],
+      }))
+      expect(badge.zoneKey).toBeUndefined()
+    })
+
+    test(`should ignore requirements with no location`, () => {
+      const badge = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'c' } }),
+          badgeRequirementDataFixture.omit('location').create(),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'c' } }),
+        ],
+      }))
+      expect(badge.zoneKeys).toStrictEqual(['a', 'c'])
+    })
+  })
+
+  describe('zoneKey', () => {
+    test(`should return the key for a single zone`, () => {
+      const badge = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+        ],
+      }))
+      expect(badge.zoneKey).toBe('a')
+    })
+
+    test(`should return undefined if there no zones`, () => {
+      const badge = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.omit('location').create(),
+        ],
+      }))
+      expect(badge.zoneKey).toBeUndefined()
+    })
+
+    test(`should return undefined if there are multiple zones`, () => {
+      const badge = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'c' } }),
+        ],
+      }))
+      expect(badge.zoneKey).toBeUndefined()
+    })
+  })
+
+  describe(compareByDefaultName.name, () => {
+    test(`should compare two badges by name`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ name: 'A' }))
+      const badgeB = new Badge(badgeDataFixture.create({ name: 'B' }))
+      expect(compareByDefaultName(badgeA, badgeB)).toBeLessThan(0)
+      expect([badgeB, badgeA].sort(compareByDefaultName)).toStrictEqual([badgeA, badgeB])
+    })
+
+    test(`should return 0 for equal names`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ name: 'A' }))
+      const badgeB = new Badge(badgeDataFixture.create({ name: 'A' }))
+      expect(compareByDefaultName(badgeA, badgeB)).toEqual(0)
+    })
+
+    test(`should compare two undefined values`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ name: [] }))
+      const badgeB = new Badge(badgeDataFixture.create({ name: [] }))
+      expect(compareByDefaultName(badgeA, badgeB)).toEqual(0)
+    })
+
+    test(`should sort undefined values last`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({ name: 'A' }))
+      const badgeB = new Badge(badgeDataFixture.create({ name: [] }))
+      expect([badgeA, badgeB].sort(compareByDefaultName)).toStrictEqual([badgeA, badgeB])
+      expect([badgeB, badgeA].sort(compareByDefaultName)).toStrictEqual([badgeA, badgeB])
+    })
+  })
+
+  describe(compareByZoneKey.name, () => {
+    test(`should compare two badges by zoneKey`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+        ],
+      }))
+      const badgeB = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'b' } }),
+        ],
+      }))
+      expect(compareByZoneKey(badgeA, badgeB)).toBeLessThan(0)
+      expect([badgeB, badgeA].sort(compareByZoneKey)).toStrictEqual([badgeA, badgeB])
+    })
+
+    test(`should return 0 for equal zoneKeys`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+        ],
+      }))
+      const badgeB = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+        ],
+      }))
+      expect(compareByZoneKey(badgeA, badgeB)).toEqual(0)
+    })
+
+    test(`should equate two undefined values`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.omit('location').create(),
+        ],
+      }))
+      const badgeB = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.omit('location').create(),
+        ],
+      }))
+      expect(compareByZoneKey(badgeA, badgeB)).toEqual(0)
+    })
+
+    test(`should sort badges with multiple values last`, () => {
+      const badgeA = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'a' } }),
+        ],
+      }))
+      const badgeB = new Badge(badgeDataFixture.create({
+        requirements: [
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'b' } }),
+          badgeRequirementDataFixture.create({ location: { zoneKey: 'c' } }),
+        ],
+      }))
+      expect([badgeA, badgeB].sort(compareByZoneKey)).toStrictEqual([badgeA, badgeB])
+      expect([badgeB, badgeA].sort(compareByZoneKey)).toStrictEqual([badgeA, badgeB])
+    })
+  })
+})

package/src/test/db/bundle-header.test.ts

@@ -0,0 +1,76 @@
+import { BundleHeader } from '../../main'
+import { bundleHeaderDataFixture } from '../api/bundle-header-data.fixture'
+
+describe(BundleHeader.name, () => {
+  describe('name', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ name: 'foo' }))
+      expect(header.name).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('name').create())
+      expect(header.name).toBeUndefined()
+    })
+  })
+
+  describe('description', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ description: 'foo' }))
+      expect(header.description).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('description').create())
+      expect(header.description).toBeUndefined()
+    })
+  })
+
+  describe('repositoryUrl', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ repositoryUrl: 'foo' }))
+      expect(header.repositoryUrl).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('repositoryUrl').create())
+      expect(header.repositoryUrl).toBeUndefined()
+    })
+  })
+
+  describe('changelogUrl', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ changelogUrl: 'foo' }))
+      expect(header.changelogUrl).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('changelogUrl').create())
+      expect(header.changelogUrl).toBeUndefined()
+    })
+  })
+
+  describe('links', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ links: [{ title: 'foo', href: 'bar' }] }))
+      expect(header.links).toStrictEqual([{ title: 'foo', href: 'bar' }])
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('links').create())
+      expect(header.links).toHaveLength(0)
+    })
+  })
+
+  describe('version', () => {
+    test(`should be set from the data`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.create({ version: 'foo' }))
+      expect(header.version).toEqual('foo')
+    })
+
+    test(`should be optional`, () => {
+      const header = new BundleHeader(bundleHeaderDataFixture.omit('version').create())
+      expect(header.version).toBeUndefined()
+    })
+  })
+})

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

@@ -0,0 +1,282 @@
+import { CohContentDatabase } from '../../main'
+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, () => {
+  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('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('missions', () => {
+    test(`should accept an undefined field`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.omit('missions').create(),
+      )
+      expect(database.missions).toHaveLength(0)
+    })
+
+    test(`should load data from bundle`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture
+          .create({ missions: [missionDataFixture.create({ key: 'foo' })] }),
+      )
+      expect(database.getMission('foo')).not.toBeUndefined()
+    })
+  })
+
+  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()
+    })
+
+    test(`should return undefined for undefined key`, () => {
+      const database = new CohContentDatabase(
+        bundleDataFixture.create({ badges: [] }),
+      )
+      const key = undefined
+      expect(database.getBadge(key)).toBeUndefined()
+    })
+  })
+
+  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 result = database.searchBadges({ query: { str: 'oo' } })
+      expect(result.totalItems).toBe(1)
+      expect(result.items.map(x => x.key)).toStrictEqual(['foo'])
+    })
+  })
+})