@takaro/gameserver 0.0.0-next.09a7ca1

package/src/TakaroEmitter.unit.test.ts

@@ -0,0 +1,201 @@
+import { TakaroEmitter } from './TakaroEmitter.js';
+import { expect, sandbox } from '@takaro/test';
+import { EventLogLine, GameEvents } from '@takaro/modules';
+import { describe, it } from 'node:test';
+
+class ExtendedTakaroEmitter extends TakaroEmitter {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async start() {}
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async stop() {}
+
+  async foo() {
+    throw new Error('testing error');
+  }
+}
+
+describe('TakaroEmitter', () => {
+  it('Can listen for events', async () => {
+    const emitter = new ExtendedTakaroEmitter();
+    const spy = sandbox.spy();
+
+    emitter.on(GameEvents.LOG_LINE, spy);
+
+    await emitter.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: 'test',
+      }),
+    );
+
+    expect(spy).to.have.been.calledOnce;
+
+    await emitter.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: 'test',
+      }),
+    );
+
+    expect(spy).to.have.been.calledTwice;
+  });
+
+  it('Can remove a listener, which causes further events to not be received', async () => {
+    const emitter = new ExtendedTakaroEmitter();
+    const spy = sandbox.spy();
+
+    emitter.on(GameEvents.LOG_LINE, spy);
+
+    await emitter.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: 'test',
+      }),
+    );
+
+    expect(spy).to.have.been.calledOnce;
+
+    emitter.off(GameEvents.LOG_LINE, spy);
+
+    await emitter.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: 'test',
+      }),
+    );
+
+    expect(spy).to.have.been.calledOnce;
+  });
+
+  it('Can have multiple listeners for the same event', async () => {
+    const emitter = new ExtendedTakaroEmitter();
+    const spy1 = sandbox.spy();
+    const spy2 = sandbox.spy();
+    const spy3 = sandbox.spy();
+
+    emitter.on(GameEvents.LOG_LINE, spy1);
+    emitter.on(GameEvents.LOG_LINE, spy2);
+    emitter.on(GameEvents.LOG_LINE, spy3);
+
+    await emitter.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: 'test',
+      }),
+    );
+
+    expect(spy1).to.have.been.calledOnce;
+    expect(spy2).to.have.been.calledOnce;
+    expect(spy3).to.have.been.calledOnce;
+  });
+
+  it('Can remove one listener without affecting others', async () => {
+    const emitter = new ExtendedTakaroEmitter();
+    const spy1 = sandbox.spy();
+    const spy2 = sandbox.spy();
+
+    emitter.on(GameEvents.LOG_LINE, spy1);
+    emitter.on(GameEvents.LOG_LINE, spy2);
+
+    await emitter.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: 'test',
+      }),
+    );
+
+    expect(spy1).to.have.been.calledOnce;
+    expect(spy2).to.have.been.calledOnce;
+
+    emitter.off(GameEvents.LOG_LINE, spy1);
+
+    await emitter.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: 'test',
+      }),
+    );
+
+    expect(spy1).to.have.been.calledOnce;
+    expect(spy2).to.have.been.calledTwice;
+  });
+
+  it('Errors happening inside extended class do not interrupt flow of events', async () => {
+    const emitter = new ExtendedTakaroEmitter();
+    const spy = sandbox.spy();
+    const errorSpy = sandbox.spy();
+
+    emitter.on(GameEvents.LOG_LINE, spy);
+    emitter.on('error', errorSpy);
+
+    await expect(emitter.foo()).to.eventually.be.rejectedWith('testing error');
+
+    expect(errorSpy).to.have.been.calledOnce;
+
+    await emitter.emit(
+      GameEvents.LOG_LINE,
+      new EventLogLine({
+        msg: 'test',
+      }),
+    );
+
+    expect(spy).to.have.been.calledOnce;
+  });
+
+  // it('Validates data on emitting', async (t) => {
+  //   t.skip();
+  //   const emitter = new ExtendedTakaroEmitter();
+  //   const spy = sandbox.spy();
+  //   const errorSpy = sandbox.spy();
+
+  //   emitter.on(GameEvents.LOG_LINE, spy);
+  //   emitter.on('error', errorSpy);
+
+  //   await emitter.emit(
+  //     GameEvents.LOG_LINE,
+  //     new EventLogLine({
+  //       msg: 'test',
+  //       // @ts-expect-error testing validation, our types accurately detect this is invalid
+  //       unknownProperty: 'this should trip validation',
+  //     }),
+  //   );
+
+  //   expect(errorSpy).to.have.been.calledOnce;
+  //   expect(errorSpy.getCall(0).args[0].message).to.match(
+  //     /property unknownProperty has failed the following constraints: whitelistValidation/,
+  //   );
+  // });
+
+  it('Throws when an error occurs and no listeners are attached to the "error" event', async () => {
+    const emitter = new ExtendedTakaroEmitter();
+    const errorSpy = sandbox.spy();
+
+    await expect(emitter.foo()).to.eventually.be.rejectedWith('Unhandled error in TakaroEmitter');
+
+    emitter.on('error', errorSpy);
+
+    await expect(emitter.foo()).to.eventually.be.rejectedWith('testing error');
+    expect(errorSpy).to.have.been.calledOnce;
+  });
+
+  it('Should not process events after stop() is called', async () => {
+    const emitter = new ExtendedTakaroEmitter();
+    const spy = sandbox.spy();
+
+    emitter.on(GameEvents.LOG_LINE, spy);
+
+    // Event before stop - should be processed
+    await emitter.emit(GameEvents.LOG_LINE, new EventLogLine({ msg: 'before stop' }));
+    expect(spy).to.have.been.calledOnce;
+
+    // Remove all listeners then call stop (like GameServerManager.remove() does during reconnection)
+    emitter.removeAllListeners();
+    await emitter.stop();
+
+    // Event after stop - should NOT be processed
+    await emitter.emit(GameEvents.LOG_LINE, new EventLogLine({ msg: 'after stop' }));
+
+    // Now it should pass - listeners were removed so spy still called once
+    expect(spy).to.have.been.calledOnce; // Should still be 1, not 2
+  });
+});

package/src/__tests__/gameEventEmitter.test.ts

@@ -0,0 +1,29 @@
+import { expect, sandbox } from '@takaro/test';
+import { GenericConnectionInfo } from '../gameservers/generic/connectionInfo.js';
+import { Generic } from '../gameservers/generic/index.js';
+import { GameEvents } from '@takaro/modules';
+import { describe, it } from 'node:test';
+
+describe('GameEventEmitter', () => {
+  /**
+   * This test doesn't really do much interesting runtime validation
+   * It exists to ensure that the event emitter is safely typed
+   * We use @ts-expect-error so that if the compiler fails to mark these as errors, we'll know instantly
+   */
+  it('Has a typed event emitter', async () => {
+    const gameServer = new Generic(new GenericConnectionInfo({}), {}, 'dummy-id');
+    const emitter = gameServer.getEventEmitter();
+    const listenerSpy = sandbox.spy();
+
+    emitter.on(GameEvents.PLAYER_CONNECTED, async (e) => {
+      expect(() => e.player.name).to.throw("Cannot read properties of undefined (reading 'name')");
+    });
+    emitter.on(GameEvents.PLAYER_CONNECTED, listenerSpy);
+
+    // @ts-expect-error Should use the enum here
+    emitter.on('non-existent-event', listenerSpy);
+
+    // But the raw string will also work in runtime when ignoring the compilation error
+    emitter.on('player-connected', listenerSpy);
+  });
+});

package/src/config.ts

@@ -0,0 +1,20 @@
+import { Config, IBaseConfig } from '@takaro/config';
+
+interface IGameServerLibConfig extends IBaseConfig {
+  connector: {
+    host: string;
+  };
+}
+
+const configSchema = {
+  connector: {
+    host: {
+      doc: 'The host of the connector',
+      format: String,
+      default: 'http://localhost:3003',
+      env: 'CONNECTOR_HOST',
+    },
+  },
+};
+
+export const config = new Config<IGameServerLibConfig>([configSchema]);

package/src/gameservers/7d2d/__tests__/7d2dActions.unit.test.ts

@@ -0,0 +1,96 @@
+import { expect, sandbox } from '@takaro/test';
+import { SevenDaysToDie } from '../index.js';
+import { CommandOutput } from '../../../interfaces/GameServer.js';
+import { SdtdConnectionInfo } from '../connectionInfo.js';
+import { describe, it } from 'node:test';
+
+const testData = {
+  oneBan:
+    'Ban list entries:\n  Banned until - UserID (name) - Reason\n  2023-06-29 19:39:56 - EOS_00028a9b73bb45b2b74e8f22cda7d225 (-unknown-) - Totally valid testing reason :)\n',
+  twoBans:
+    'Ban list entries:\n  Banned until - UserID (name) - Reason\n  2028-06-29 17:49:45 - EOS_0002e0daea3b493fa146ce6d06e79a57 (-unknown-) - test\n  2028-06-29 19:19:40 - EOS_00028a9b73bb45b2b74e8f22cda7d225 (-unknown-) - test\n',
+  noBans: 'Ban list entries:\n  Banned until - UserID (name) - Reason\n',
+  oneBanWithDisplayName:
+    'Ban list entries:\n  Banned until - UserID (name) - Reason\n  2023-06-29 19:40:59 - EOS_00028a9b73bb45b2b74e8f22cda7d225 (testing display name) - Totally valid testing reason :)\n',
+};
+
+const mockSdtdConnectionInfo = new SdtdConnectionInfo({
+  adminToken: 'aaa',
+  adminUser: 'aaa',
+  useTls: false,
+  host: 'localhost',
+});
+
+describe('7d2d Actions', () => {
+  describe('listBans', () => {
+    it('Can parse ban list with a single ban', async () => {
+      sandbox.stub(SevenDaysToDie.prototype, 'executeConsoleCommand').resolves(
+        new CommandOutput({
+          rawResult: testData.oneBan,
+          success: true,
+        }),
+      );
+
+      const result = await new SevenDaysToDie(await mockSdtdConnectionInfo).listBans();
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0].player.gameId).to.equal('00028a9b73bb45b2b74e8f22cda7d225');
+      expect(result[0].player.epicOnlineServicesId).to.equal('00028a9b73bb45b2b74e8f22cda7d225');
+      expect(result[0].expiresAt).to.equal('2023-06-29T19:39:56.000Z');
+    });
+
+    it('Can parse ban list with two bans', async () => {
+      sandbox.stub(SevenDaysToDie.prototype, 'executeConsoleCommand').resolves(
+        new CommandOutput({
+          rawResult: testData.twoBans,
+          success: true,
+        }),
+      );
+
+      const result = await new SevenDaysToDie(await mockSdtdConnectionInfo).listBans();
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(2);
+
+      expect(result[0].player.gameId).to.equal('0002e0daea3b493fa146ce6d06e79a57');
+      expect(result[0].player.epicOnlineServicesId).to.equal('0002e0daea3b493fa146ce6d06e79a57');
+      expect(result[0].expiresAt).to.equal('2028-06-29T17:49:45.000Z');
+
+      expect(result[1].player.gameId).to.equal('00028a9b73bb45b2b74e8f22cda7d225');
+      expect(result[1].player.epicOnlineServicesId).to.equal('00028a9b73bb45b2b74e8f22cda7d225');
+      expect(result[1].expiresAt).to.equal('2028-06-29T19:19:40.000Z');
+    });
+
+    it('Can parse ban list with no bans', async () => {
+      sandbox.stub(SevenDaysToDie.prototype, 'executeConsoleCommand').resolves(
+        new CommandOutput({
+          rawResult: testData.noBans,
+          success: true,
+        }),
+      );
+
+      const result = await new SevenDaysToDie(await mockSdtdConnectionInfo).listBans();
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(0);
+    });
+
+    it('Can parse ban list with a single ban with a display name', async () => {
+      sandbox.stub(SevenDaysToDie.prototype, 'executeConsoleCommand').resolves(
+        new CommandOutput({
+          rawResult: testData.oneBanWithDisplayName,
+          success: true,
+        }),
+      );
+
+      const result = await new SevenDaysToDie(await mockSdtdConnectionInfo).listBans();
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0].player.gameId).to.equal('00028a9b73bb45b2b74e8f22cda7d225');
+      expect(result[0].player.epicOnlineServicesId).to.equal('00028a9b73bb45b2b74e8f22cda7d225');
+      expect(result[0].expiresAt).to.equal('2023-06-29T19:40:59.000Z');
+    });
+  });
+});