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

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

@@ -1,42 +1,143 @@
 import { CohContentDatabase } from '../../main'
-import { serverGroupDataFixture } from '../api/server-group-data.fixture'
+import { contentBundleFixture } from '../api/content-bundle.fixture'
+import { archetypeDataFixture } from '../api/archetype-data.fixture'
+import { badgeDataFixture } from '../api/badge-data.fixture'
+import { gameMapDataFixture } from '../api/game-map-data.fixture'
 
 describe(CohContentDatabase.name, () => {
-  test('should be instantiable', () => {
-    expect(new CohContentDatabase()).not.toBeNull()
+  test('should load a basic bundle', () => {
+    new CohContentDatabase(contentBundleFixture.create())
   })
 
-  describe(CohContentDatabase.prototype.loadServerGroupData.name, () => {
-    test('should load an empty server group', () => {
-      const database = new CohContentDatabase()
-      database.loadServerGroupData(serverGroupDataFixture.create())
+  describe('servers', () => {
+    test(`should accept an undefined field`, () => {
+      const data = contentBundleFixture
+        .omit('servers')
+        .create()
+      expect(() => new CohContentDatabase(data).archetypes).toHaveLength(0)
+    })
+
+    test(`should load values from bundle`, () => {
+      const data = contentBundleFixture
+        .create({ servers: ['Foo', 'Bar'] })
+      expect(new CohContentDatabase(data).servers).toStrictEqual(['Foo', 'Bar'])
+    })
+  })
+
+  describe('archetypes', () => {
+    test(`should throw an error on duplicate key`, () => {
+      const data = contentBundleFixture.create({
+        archetypes: [
+          archetypeDataFixture.create({ key: 'foo' }),
+          archetypeDataFixture.create({ key: 'foo' }),
+        ],
+      })
+      expect(() => new CohContentDatabase(data)).toThrow('Duplicate archetype key [foo]')
+    })
+
+    test(`should accept an undefined field`, () => {
+      const data = contentBundleFixture
+        .omit('archetypes')
+        .create()
+      expect(() => new CohContentDatabase(data).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()
+    })
+  })
+
+  describe('badges', () => {
+    test(`should throw an error on duplicate key`, () => {
+      const data = contentBundleFixture.create({
+        badges: [
+          badgeDataFixture.create({ key: 'foo' }),
+          badgeDataFixture.create({ key: 'foo' }),
+        ],
+      })
+      expect(() => new CohContentDatabase(data)).toThrow('Duplicate badge key [foo]')
+    })
+
+    test(`should accept an undefined field`, () => {
+      const data = contentBundleFixture
+        .omit('badges')
+        .create()
+      expect(() => new CohContentDatabase(data).badges).toHaveLength(0)
+    })
+  })
+
+  describe('maps', () => {
+    test(`should throw an error on duplicate map`, () => {
+      const data = contentBundleFixture.create({
+        maps: [
+          gameMapDataFixture.create({ key: 'foo' }),
+          gameMapDataFixture.create({ key: 'foo' }),
+        ],
+      })
+      expect(() => new CohContentDatabase(data)).toThrow('Duplicate map key [foo]')
+    })
+
+    test(`should accept an undefined field`, () => {
+      const data = contentBundleFixture
+        .omit('maps')
+        .create()
+      expect(() => new CohContentDatabase(data).maps).toHaveLength(0)
     })
   })
 
-  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('getArchetype', () => {
+    test(`should retrieve archetype from the index`, () => {
+      const data = contentBundleFixture.create({
+        archetypes: [archetypeDataFixture.create({ key: 'foo' })],
+      })
 
-      const sgs = database.listServerGroups()
+      expect(new CohContentDatabase(data).getArchetype('foo')).not.toBeUndefined()
+    })
 
-      expect(sgs).toHaveLength(2)
+    test(`should throw error for unknown archetype`, () => {
+      const data = contentBundleFixture.create({
+        archetypes: [],
+      })
 
-      for (const entry of sgs) {
-        expect(['sg1', 'sg2']).toContain(entry.key)
-      }
+      expect(() => new CohContentDatabase(data).getArchetype('foo')).toThrow('Unknown archetype key [foo]')
     })
   })
 
-  describe(CohContentDatabase.prototype.getServerGroup.name, () => {
-    test('should load a server group by key', () => {
-      const database = new CohContentDatabase()
-      database.loadServerGroupData(serverGroupDataFixture.create({ key: 'sg1' }))
+  describe('getMap', () => {
+    test(`should retrieve map from the index`, () => {
+      const data = contentBundleFixture.create({
+        maps: [gameMapDataFixture.create({ key: 'foo' })],
+      })
+
+      expect(new CohContentDatabase(data).getMap('foo')).not.toBeUndefined()
+    })
+
+    test(`should throw error for unknown map`, () => {
+      const data = contentBundleFixture.create({
+        maps: [],
+      })
+
+      expect(() => new CohContentDatabase(data).getMap('foo')).toThrow('Unknown map key [foo]')
+    })
+  })
+
+  describe('getBadge', () => {
+    test(`should retrieve badge from the index`, () => {
+      const data = 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: [],
+      })
 
-      const sg = database.getServerGroup('sg1')
-      expect(sg).not.toBeNull()
-      expect(sg?.key).toEqual('sg1')
+      expect(() => new CohContentDatabase(data).getBadge('foo')).toThrow('Unknown badge key [foo]')
     })
   })
 })

package/src/main/db/server-group.ts

@@ -1,112 +0,0 @@
-import { Archetype } from './archetype'
-import { Badge } from './badge'
-import { ServerGroupData } from '../api/server-group-data'
-import { Key } from './key'
-import { Change } from '../api/change'
-import { GameMap } from './game-map'
-import { Link } from '../api/link'
-
-export class ServerGroup {
-  readonly #archetypeIndex: Record<string, Archetype> = {}
-  readonly #mapIndex: Record<string, GameMap> = {}
-  readonly #badgeIndex: Record<string, Badge> = {}
-
-  /**
-   * The database key for this server group.
-   */
-  readonly key: string
-
-  /**
-   * Name of the server group.
-   */
-  readonly name: string
-
-  /**
-   * Description of the server group.
-   *
-   * Supports {@link https://www.markdownguide.org/|Markdown} format.
-   */
-  readonly description?: string
-
-  /**
-   * Repository where the db content package is maintained.
-   */
-  readonly repository?: string
-
-  /**
-   * List of external links for this Server Group. Wiki, forums, etc.
-   */
-  readonly links?: Link[]
-
-  /**
-   * List of the game server names in this server group.
-   * Torchbearer, Excelsior, etc.
-   */
-  readonly servers: string[]
-
-  /**
-   * List of archetypes available in this server group.
-   */
-  readonly archetypes: Archetype[]
-
-  /**
-   * List of game maps supported by this server group.
-   */
-  readonly maps: GameMap[]
-
-  /**
-   * List of badges available on this server group.
-   */
-  readonly badges: Badge[]
-
-  /**
-   * Change log for this data package.
-   */
-  readonly changelog?: Change[]
-
-  constructor(data: ServerGroupData) {
-    this.key = new Key(data.key).value
-    this.name = data.name
-    this.description = data.description
-    this.repository = data.repository
-    this.links = data.links
-    this.servers = data.servers ?? []
-    this.archetypes = data.archetypes?.map((data) => {
-      if (this.#archetypeIndex[data.key] !== undefined) throw new Error(`Duplicate archetype key [${data.key}]`)
-      const archetype = new Archetype(data)
-      this.#archetypeIndex[archetype.key] = archetype
-      return archetype
-    }) ?? []
-    this.maps = data.maps?.map((data) => {
-      if (this.#mapIndex[data.key] !== undefined) throw new Error(`Duplicate map key [${data.key}]`)
-      const map = new GameMap(data)
-      this.#mapIndex[map.key] = map
-      return map
-    }) ?? []
-    this.badges = data.badges?.map((data) => {
-      if (this.#badgeIndex[data.key] !== undefined) throw new Error(`Duplicate badge key [${data.key}]`)
-      const badge = new Badge(data)
-      this.#badgeIndex[badge.key] = badge
-      return badge
-    }) ?? []
-    this.changelog = data.changelog
-  }
-
-  getArchetype(key: string): Archetype {
-    const result = this.#archetypeIndex[key]
-    if (result === undefined) throw new Error(`Unknown archetype key [${key}]`)
-    return result
-  }
-
-  getMap(key: string): GameMap {
-    const result = this.#mapIndex[key]
-    if (result === undefined) throw new Error(`Unknown map key [${key}]`)
-    return result
-  }
-
-  getBadge(key: string): Badge {
-    const result = this.#badgeIndex[key]
-    if (result === undefined) throw new Error(`Unknown badge key [${key}]`)
-    return result
-  }
-}

package/src/test/db/server-group.test.ts

@@ -1,124 +0,0 @@
-import { ServerGroup } from '../../main'
-import { serverGroupDataFixture } from '../api/server-group-data.fixture'
-import { badgeDataFixture } from '../api/badge-data.fixture'
-import { gameMapDataFixture } from '../api/game-map-data.fixture'
-import { archetypeDataFixture } from '../api/archetype-data.fixture'
-
-describe(ServerGroup.name, () => {
-  describe('Constructor', () => {
-    test(`should accept the test fixture`, () => {
-      new ServerGroup(serverGroupDataFixture.create())
-    })
-  })
-
-  describe('archetypes', () => {
-    test(`should throw an error on duplicate key`, () => {
-      const data = serverGroupDataFixture.create({
-        archetypes: [
-          archetypeDataFixture.create({ key: 'foo' }),
-          archetypeDataFixture.create({ key: 'foo' }),
-        ],
-      })
-      expect(() => new ServerGroup(data)).toThrow('Duplicate archetype key [foo]')
-    })
-
-    test(`should accept an empty list`, () => {
-      const data = serverGroupDataFixture
-        .omit('archetypes')
-        .create()
-      expect(() => new ServerGroup(data).archetypes).toHaveLength(0)
-    })
-  })
-
-  describe('badges', () => {
-    test(`should throw an error on duplicate key`, () => {
-      const data = serverGroupDataFixture.create({
-        badges: [
-          badgeDataFixture.create({ key: 'foo' }),
-          badgeDataFixture.create({ key: 'foo' }),
-        ],
-      })
-      expect(() => new ServerGroup(data)).toThrow('Duplicate badge key [foo]')
-    })
-
-    test(`should accept an empty list`, () => {
-      const data = serverGroupDataFixture
-        .omit('badges')
-        .create()
-      expect(() => new ServerGroup(data).badges).toHaveLength(0)
-    })
-  })
-
-  describe('maps', () => {
-    test(`should throw an error on duplicate map`, () => {
-      const data = serverGroupDataFixture.create({
-        maps: [
-          gameMapDataFixture.create({ key: 'foo' }),
-          gameMapDataFixture.create({ key: 'foo' }),
-        ],
-      })
-      expect(() => new ServerGroup(data)).toThrow('Duplicate map key [foo]')
-    })
-
-    test(`should accept an empty list`, () => {
-      const data = serverGroupDataFixture
-        .omit('maps')
-        .create()
-      expect(() => new ServerGroup(data).maps).toHaveLength(0)
-    })
-  })
-
-  describe('getArchetype', () => {
-    test(`should retrieve archetype from the index`, () => {
-      const data = serverGroupDataFixture.create({
-        archetypes: [archetypeDataFixture.create({ key: 'foo' })],
-      })
-
-      expect(new ServerGroup(data).getArchetype('foo')).not.toBeNull()
-    })
-
-    test(`should throw error for unknown archetype`, () => {
-      const data = serverGroupDataFixture.create({
-        archetypes: [],
-      })
-
-      expect(() => new ServerGroup(data).getArchetype('foo')).toThrow('Unknown archetype key [foo]')
-    })
-  })
-
-  describe('getMap', () => {
-    test(`should retrieve map from the index`, () => {
-      const data = serverGroupDataFixture.create({
-        maps: [gameMapDataFixture.create({ key: 'foo' })],
-      })
-
-      expect(new ServerGroup(data).getMap('foo')).not.toBeNull()
-    })
-
-    test(`should throw error for unknown map`, () => {
-      const data = serverGroupDataFixture.create({
-        maps: [],
-      })
-
-      expect(() => new ServerGroup(data).getMap('foo')).toThrow('Unknown map key [foo]')
-    })
-  })
-
-  describe('getBadge', () => {
-    test(`should retrieve badge from the index`, () => {
-      const data = serverGroupDataFixture.create({
-        badges: [badgeDataFixture.create({ key: 'foo' })],
-      })
-
-      expect(new ServerGroup(data).getBadge('foo')).not.toBeNull()
-    })
-
-    test(`should throw error for unknown badge`, () => {
-      const data = serverGroupDataFixture.create({
-        badges: [],
-      })
-
-      expect(() => new ServerGroup(data).getBadge('foo')).toThrow('Unknown badge key [foo]')
-    })
-  })
-})