feat(*): wait for gameserver to start (#5)

.eslintrc.cjs

@@ -7,6 +7,14 @@ module.exports = {
     'plugin:@typescript-eslint/stylistic-type-checked',
     'plugin:prettier/recommended',
   ],
+  rules: {
+    '@typescript-eslint/no-misused-promises': [
+      'error',
+      {
+        checksVoidReturn: false,
+      },
+    ],
+  },
   env: {
     node: true,
   },

examples/create-reservation.ts

@@ -46,6 +46,13 @@ const reserveServer = async () => {
   });
 
   console.log(`reservation created: ${reservation.id}`);
+
+  await reservation.waitForStarted();
+  console.log(`server started`);
+  console.log(
+    `connect string: connect ${reservation.server.ip_and_port}; password ${reservation.password}`,
+  );
+  console.log(`rcon password: ${reservation.rcon}`);
 };
 
 reserveServer().catch(error => {

src/errors/index.ts

@@ -1,2 +1,4 @@
 export { HttpClientError } from './http-client.error';
+export { InvalidReservationStatusError } from './invalid-reservation-state.error';
 export { ServemeTfApiError } from './serveme-tf-api.error';
+export { TimeoutError } from './timeout.error';

src/errors/invalid-reservation-state.error.ts

@@ -0,0 +1,7 @@
+import { ReservationStatus } from '../types/reservation-status';
+
+export class InvalidReservationStatusError extends Error {
+  constructor(public readonly reservationStatus: ReservationStatus) {
+    super(`invalid reservation status: ${reservationStatus}`);
+  }
+}

src/errors/timeout.error.ts

@@ -0,0 +1,5 @@
+export class TimeoutError extends Error {
+  constructor(public readonly timeoutMs: number) {
+    super(`timed out after ${timeoutMs}ms`);
+  }
+}

src/reservation.test.ts

@@ -1,8 +1,10 @@
-import { beforeEach, expect, vi, describe, it } from 'vitest';
+import { beforeEach, expect, vi, describe, it, afterEach } from 'vitest';
 import { Reservation } from './reservation';
 import { Client } from './client';
 import { Response } from './types/serveme-tf-responses';
 import { ReservationStatus } from './types/reservation-status';
+import { secondsToMilliseconds } from 'date-fns';
+import { TimeoutError } from './errors/timeout.error';
 
 const mockReservationResponse: Response.ActiveReservation = vi.hoisted(() => ({
   status: 'Starting',
@@ -131,4 +133,88 @@ describe('Reservation', () => {
       expect(reservation.status).toEqual(ReservationStatus.ending);
     });
   });
+
+  describe('#waitForStarted()', () => {
+    let refreshNo = 0;
+
+    beforeEach(() => {
+      refreshNo = 0;
+      vi.mocked(client.httpClient).get.mockImplementation(() => {
+        switch (refreshNo++) {
+          case 0:
+            return Promise.resolve({
+              reservation: {
+                ...mockReservationResponse,
+                status: 'Waiting to start',
+              },
+            });
+
+          case 1:
+            return Promise.resolve({
+              reservation: {
+                ...mockReservationResponse,
+                status: 'Starting',
+              },
+            });
+
+          default:
+            return Promise.resolve({
+              reservation: {
+                ...mockReservationResponse,
+                status: 'Ready',
+              },
+            });
+        }
+      });
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it('should wait for reservation to start', () =>
+      new Promise<void>((resolve, reject) => {
+        vi.useFakeTimers();
+        reservation
+          .waitForStarted()
+          .then(() => {
+            expect(reservation.status).toEqual(ReservationStatus.ready);
+            resolve();
+          })
+          .catch(reject);
+        vi.advanceTimersByTime(secondsToMilliseconds(20));
+      }));
+
+    describe('when the reservation has ended', () => {
+      beforeEach(() => {
+        vi.mocked(client.httpClient).get.mockResolvedValue({
+          reservation: {
+            ...mockReservationResponse,
+            status: 'Ended',
+          },
+        });
+      });
+
+      it('should throw', () =>
+        new Promise<void>((resolve, reject) => {
+          vi.useFakeTimers();
+          reservation
+            .waitForStarted()
+            .then(reject)
+            .catch(error => {
+              expect(error.message).toEqual(
+                'invalid reservation status: Ended',
+              );
+              resolve();
+            });
+          vi.advanceTimersByTime(secondsToMilliseconds(20));
+        }));
+    });
+
+    it('should timeout', async () => {
+      await expect(reservation.waitForStarted(100)).rejects.toThrow(
+        TimeoutError,
+      );
+    });
+  });
 });

src/reservation.ts

@@ -1,6 +1,10 @@
 import { Client } from './client';
 import { Response } from './types/serveme-tf-responses';
 import { ReservationDetails } from './reservation-details';
+import { ReservationStatus } from './types/reservation-status';
+import { InvalidReservationStatusError } from './errors/invalid-reservation-state.error';
+import { secondsToMilliseconds } from 'date-fns';
+import { withTimeout } from './with-timeout';
 
 export class Reservation extends ReservationDetails {
   constructor(
@@ -29,4 +33,32 @@ export class Reservation extends ReservationDetails {
     this.setResponse(response.reservation);
     return this;
   }
+
+  async waitForStarted(timeoutMs = secondsToMilliseconds(30)): Promise<this> {
+    let interval: ReturnType<typeof setInterval>;
+    return withTimeout(
+      new Promise<this>((resolve, reject) => {
+        interval = setInterval(async () => {
+          await this.refresh();
+
+          if (
+            [ReservationStatus.ending, ReservationStatus.ended].includes(
+              this.status,
+            )
+          ) {
+            return reject(new InvalidReservationStatusError(this.status));
+          }
+
+          if (
+            [ReservationStatus.ready, ReservationStatus.sdrReady].includes(
+              this.status,
+            )
+          ) {
+            return resolve(this);
+          }
+        }, secondsToMilliseconds(5));
+      }),
+      timeoutMs,
+    ).finally(() => clearInterval(interval));
+  }
 }

src/with-timeout.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import { withTimeout } from './with-timeout';
+import { TimeoutError } from './errors/timeout.error';
+
+describe('when fn does not timeout', () => {
+  it('should return fn result', async () => {
+    const result = await withTimeout(
+      new Promise(resolve => setTimeout(() => resolve('foo'), 50)),
+      100,
+    );
+    expect(result).toEqual('foo');
+  });
+});
+
+describe('when fn times out', () => {
+  it('should throw', async () => {
+    const promise = new Promise(resolve => setTimeout(resolve, 100));
+    await expect(withTimeout(promise, 50)).rejects.toThrow(TimeoutError);
+  });
+});

src/with-timeout.ts

@@ -0,0 +1,16 @@
+import { TimeoutError } from './errors/timeout.error';
+
+export const withTimeout = async <T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+): Promise<T> => {
+  let timeout: ReturnType<typeof setTimeout>;
+  return Promise.race([
+    promise,
+    new Promise<never>((_resolve, reject) => {
+      timeout = setTimeout(() => {
+        reject(new TimeoutError(timeoutMs));
+      }, timeoutMs);
+    }),
+  ]).finally(() => clearTimeout(timeout));
+};