Merge pull request #336 from PhlexPlexico/2.2.0.0

Version 2.2.0.0

Co-authored-by: Mostafa Mahran <mfamahran@gmail.com>

Author: PhlexPlexico

README.md

@@ -86,6 +86,9 @@ docker container run --name g5api \
 -e USEREDIS="true" \
 -e UPLOADDEMOS="" \
 -e LOCALLOGINS="" \
+-e QUEUETTL="" \
+-e SERVERPINGTO="" \
+-e SERVERPROVIDER="local"
 yourname\g5api:latest
 ```
 

__test__/dathost.test.js

@@ -0,0 +1,19 @@
+/**
+ * Unit tests for DatHost service (isDathostConfigured, releaseManagedServer with null).
+ * Does not require app or database.
+ */
+import { isDathostConfigured, releaseManagedServer } from "../src/services/dathost.js";
+
+describe("DatHost service", () => {
+  it("isDathostConfigured returns false when user dathost is not configured", async () => {
+    await expect(isDathostConfigured(1)).resolves.toBe(false);
+  });
+
+  it("releaseManagedServer(null) resolves without throwing", async () => {
+    await expect(releaseManagedServer(null)).resolves.toBeUndefined();
+  });
+
+  it("releaseManagedServer(undefined) resolves without throwing", async () => {
+    await expect(releaseManagedServer(undefined)).resolves.toBeUndefined();
+  });
+});

__test__/gameservers.test.js

@@ -14,6 +14,26 @@ describe("Test the game server routes.", () => {
       .expect("Content-Type", /json/)
       .expect(200);
   });
+  it("Should return public server count via GET /servers/publiccount", () => {
+    return request
+      .get("/servers/publiccount")
+      .expect("Content-Type", /json/)
+      .expect(200)
+      .expect((res) => {
+        expect(res.body).toHaveProperty("servers");
+        expect(typeof res.body.servers).toBe("number");
+      });
+  });
+  it("Should return available servers via GET /servers/available", () => {
+    return request
+      .get("/servers/available")
+      .expect("Content-Type", /json/)
+      .expect(200)
+      .expect((res) => {
+        expect(res.body).toHaveProperty("servers");
+        expect(Array.isArray(res.body.servers)).toBe(true);
+      });
+  });
   it("Should setup a new server with the given values.", () => {
     let newServerData = [
       {

__test__/matches.test.js

@@ -3,6 +3,9 @@ import app from '../app.js';
 const request = agent(app);
 
 describe("Test the matches routes", () => {
+  let defaultGameMatchId;
+  let csgoGameMatchId;
+
   beforeAll(() => {
     return request.get('/auth/steam/return')
       .expect(302);
@@ -11,6 +14,45 @@ describe("Test the matches routes", () => {
     return request.get('/matches/')
       .expect(404);
   });
+  it('Should reject use_dathost when server_id is also provided (400).', () => {
+    return request
+      .post("/matches/")
+      .set("Content-Type", "application/json")
+      .set("Accept", "application/json")
+      .send([{
+        use_dathost: true,
+        server_id: 3,
+        team1_id: 4,
+        team2_id: 3,
+        max_maps: 1,
+        title: "Map {MAPNUMBER} of {MAXMAPS}",
+        veto_mappool: "de_dust2 de_mirage",
+        skip_veto: 0
+      }])
+      .expect(400)
+      .expect((result) => {
+        expect(result.body.message).toMatch(/use_dathost.*server_id/);
+      });
+  });
+  it('Should reject use_dathost when DatHost is not configured (503).', () => {
+    return request
+      .post("/matches/")
+      .set("Content-Type", "application/json")
+      .set("Accept", "application/json")
+      .send([{
+        use_dathost: true,
+        team1_id: 4,
+        team2_id: 3,
+        max_maps: 1,
+        title: "Map {MAPNUMBER} of {MAXMAPS}",
+        veto_mappool: "de_dust2 de_mirage",
+        skip_veto: 0
+      }])
+      .expect(503)
+      .expect((result) => {
+        expect(result.body.message).toMatch(/DatHost|not configured/);
+      });
+  });
   it('Should create a single match that is ready to be played with teams.', () => {
     // Min required data.
     let newMatchData = [
@@ -208,4 +250,135 @@ describe("Test the matches routes", () => {
         expect(result.body.message).toMatch(/successfully/);
       });
   });
+  it('Should create a match without game and default to cs2.', () => {
+    const newMatchData = [
+      {
+        server_id: 2,
+        team1_id: 4,
+        team2_id: 3,
+        max_maps: 1,
+        title: "Game default check",
+        veto_mappool: "de_vertigo, de_inferno, de_mirage",
+        skip_veto: 1,
+        ignore_server: true
+      }
+    ];
+    return request
+      .post("/matches/")
+      .set("Content-Type", "application/json")
+      .set("Accept", "application/json")
+      .send(newMatchData)
+      .expect(200)
+      .expect((result) => {
+        defaultGameMatchId = result.body.id;
+        expect(result.body.message).toMatch(/successfully/);
+      });
+  });
+  it('Should persist default game as cs2.', () => {
+    return request
+      .get(`/matches/${defaultGameMatchId}`)
+      .expect(200)
+      .expect((result) => {
+        expect(result.body.match.game).toBe("cs2");
+      });
+  });
+  it('Should create a match with game set to csgo.', () => {
+    const newMatchData = [
+      {
+        server_id: 2,
+        team1_id: 4,
+        team2_id: 3,
+        max_maps: 1,
+        title: "Game csgo check",
+        veto_mappool: "de_vertigo, de_inferno, de_mirage",
+        skip_veto: 1,
+        ignore_server: true,
+        game: "csgo"
+      }
+    ];
+    return request
+      .post("/matches/")
+      .set("Content-Type", "application/json")
+      .set("Accept", "application/json")
+      .send(newMatchData)
+      .expect(200)
+      .expect((result) => {
+        csgoGameMatchId = result.body.id;
+        expect(result.body.message).toMatch(/successfully/);
+      });
+  });
+  it('Should persist explicit game as csgo.', () => {
+    return request
+      .get(`/matches/${csgoGameMatchId}`)
+      .expect(200)
+      .expect((result) => {
+        expect(result.body.match.game).toBe("csgo");
+      });
+  });
+  it('Should reject invalid game values on create.', () => {
+    const invalidMatchData = [
+      {
+        server_id: 2,
+        team1_id: 4,
+        team2_id: 3,
+        max_maps: 1,
+        title: "Invalid game create",
+        veto_mappool: "de_vertigo, de_inferno, de_mirage",
+        skip_veto: 1,
+        ignore_server: true,
+        game: "CS2"
+      }
+    ];
+    return request
+      .post("/matches/")
+      .set("Content-Type", "application/json")
+      .set("Accept", "application/json")
+      .send(invalidMatchData)
+      .expect(400)
+      .expect((result) => {
+        expect(result.body.message).toMatch(/Invalid game value/);
+      });
+  });
+  it('Should reject invalid game values on update.', () => {
+    const invalidUpdate = [
+      {
+        match_id: defaultGameMatchId,
+        game: "CSGO"
+      }
+    ];
+    return request
+      .put("/matches/")
+      .set("Content-Type", "application/json")
+      .set("Accept", "application/json")
+      .send(invalidUpdate)
+      .expect(400)
+      .expect((result) => {
+        expect(result.body.message).toMatch(/Invalid game value/);
+      });
+  });
+  it('Should update game to csgo on an existing match.', () => {
+    const updateData = [
+      {
+        match_id: defaultGameMatchId,
+        game: "csgo"
+      }
+    ];
+    return request
+      .put("/matches/")
+      .set("Content-Type", "application/json")
+      .set("Accept", "application/json")
+      .send(updateData)
+      .expect(200)
+      .expect((result) => {
+        expect(result.body.message).toMatch(/successfully/);
+      });
+  });
+  it('Should persist updated game after match update.', () => {
+    return request
+      .get(`/matches/${defaultGameMatchId}`)
+      .expect(200)
+      .expect((result) => {
+        expect(result.body.match.game).toBe("csgo");
+      });
+  });
 });