Include tests for team creations.

At max players create a team from the queue that is inserted into the database.

Author: PhlexPlexico

__test__/queue.test.js

@@ -0,0 +1,83 @@
+import { agent } from 'supertest';
+import app from '../app.js';
+import { db } from '../src/services/db.js';
+import { QueueService } from '../src/services/queue.js';
+const request = agent(app);
+
+describe('Queue routes', () => {
+  beforeAll(() => {
+    // Authenticate mock steam user (mock strategy)
+    return request.get('/auth/steam/return').expect(302);
+  });
+
+  it('should create a queue and return URL', async () => {
+    const payload = [ { maxPlayers: 4, private: false } ];
+    const res = await request
+      .post('/queue/')
+      .set('Content-Type', 'application/json')
+      .send(payload)
+      .expect(200);
+
+    expect(res.body.url).toMatch(/\/queue\//);
+    // Save the slug for subsequent tests
+    const slug = res.body.url.split('/').pop();
+    expect(slug).toBeDefined();
+    // store on global for other tests
+    global.__TEST_QUEUE_SLUG = slug;
+  });
+
+  it('should add users to the queue and create teams when full', async () => {
+    const slug = global.__TEST_QUEUE_SLUG;
+    // Add 4 users; the first is the creator (already added) so add 3 more
+    // Using the mockProfile steam id and some fake ids for others
+    const extraUsers = ['76561198025644195','76561198025644196','76561198025644197'];
+    // Add users directly to the queue service to simulate distinct steam IDs (route uses req.user)
+    for (const id of extraUsers) {
+      await QueueService.addUserToQueue(slug, id);
+    }
+
+    // Now trigger team creation from the service (would normally be called by the route once full)
+    const result = await QueueService.createTeamsFromQueue(slug);
+    expect(result).toBeDefined();
+    expect(Array.isArray(result.teams)).toBe(true);
+    expect(result.teams.length).toBe(2);
+
+    // Check DB for created teams; there should be at least 2 inserted with team_auth_names
+    const teams = await db.query('SELECT id FROM team WHERE name LIKE ?', [`team_%`]);
+    expect(teams.length).toBeGreaterThanOrEqual(2);
+    const teamId = teams[0].id;
+    const auths = await db.query('SELECT auth FROM team_auth_names WHERE team_id = ?', [teamId]);
+    expect(auths.length).toBeGreaterThan(0);
+  });
+
+  describe('rating normalization', () => {
+    test('uses median when some ratings are present and adds jitter for missing', () => {
+      const realRandom = Math.random;
+      Math.random = () => 0.5;
+
+      const players = [
+        { steamId: '1', timestamp: 1, hltvRating: 2 },
+        { steamId: '2', timestamp: 2, hltvRating: 4 },
+        { steamId: '3', timestamp: 3, hltvRating: undefined },
+      ];
+      const out = QueueService.normalizePlayerRatings(players);
+      expect(out.find(p => p.steamId === '3').hltvRating).toBeCloseTo(3);
+
+      Math.random = realRandom;
+    });
+
+    test('all missing ratings fall back to 1.0 +/- jitter', () => {
+      const realRandom = Math.random;
+      Math.random = () => 0.25;
+
+      const players = [
+        { steamId: 'a', timestamp: 1, hltvRating: undefined },
+        { steamId: 'b', timestamp: 2, hltvRating: undefined }
+      ];
+      const out = QueueService.normalizePlayerRatings(players);
+      expect(out[0].hltvRating).toBeCloseTo(0.975);
+
+      Math.random = realRandom;
+    });
+  });
+});

jest_config/jest.queue.config.cjs

@@ -0,0 +1,16 @@
+process.env.NODE_ENV = "test";
+module.exports = {
+  preset: 'ts-jest/presets/js-with-ts-esm',
+  resolver: "jest-ts-webcompat-resolver",
+  clearMocks: true,
+  globalTeardown: "./test-teardown-globals.cjs",
+  testEnvironment: "node",
+  roots: [
+    "../__test__"
+  ],
+  testMatch: [
+    "**/__test__/queue.test.js",
+    "**/@(queue.)+(spec|test).[tj]s?(x)"
+  ],
+  verbose: false,
+};

package.json

@@ -51,11 +51,12 @@
     "migrate-drop-prod": "MYSQL_FLAGS=\"-CONNECT_WITH_DB\" db-migrate --env production --config config/production.json db:drop get5",
     "migrate-drop-test": "MYSQL_FLAGS=\"-CONNECT_WITH_DB\" db-migrate --env test --config config/test.json db:drop get5test",
     "prod": "NODE_ENV=production yarn migrate-create-prod && yarn migrate-prod-upgrade",
-    "test": "yarn build && NODE_ENV=test && yarn test:setup-user && yarn migrate-drop-test && yarn migrate-create-test && yarn migrate-test-upgrade && yarn test:user && yarn test:gameservers && yarn test:teams && yarn test:matches && yarn test:seasons && yarn test:vetoes && yarn test:mapstats && yarn test:playerstats && yarn test:vetosides && yarn test:maplists",
+    "test": "yarn build && NODE_ENV=test && yarn test:setup-user && yarn migrate-drop-test && yarn migrate-create-test && yarn migrate-test-upgrade && yarn test:user && yarn test:gameservers && yarn test:teams && yarn test:matches && yarn test:seasons && yarn test:vetoes && yarn test:mapstats && yarn test:playerstats && yarn test:vetosides && yarn test:maplists && yarn test:queue",
     "test:gameservers": "yarn test:removeID && NODE_OPTIONS=--experimental-vm-modules jest --testTimeout=10000 --detectOpenHandles --config ./jest_config/jest.gameservers.config.cjs",
     "test:mapstats": "NODE_OPTIONS=--experimental-vm-modules jest --testTimeout=10000 --detectOpenHandles --config ./jest_config/jest.mapstats.config.cjs",
     "test:maplists": "NODE_OPTIONS=--experimental-vm-modules jest --testTimeout=10000 --detectOpenHandles --config ./jest_config/jest.maplist.config.cjs",
     "test:matches": "NODE_OPTIONS=--experimental-vm-modules jest --testTimeout=10000 --detectOpenHandles --config ./jest_config/jest.matches.config.cjs",
+    "test:queue": "NODE_OPTIONS=--experimental-vm-modules jest --testTimeout=10000 --detectOpenHandles --config ./jest_config/jest.queue.config.cjs",
     "test:playerstats": "NODE_OPTIONS=--experimental-vm-modules jest --testTimeout=10000 --detectOpenHandles --config ./jest_config/jest.playerstats.config.cjs",
     "test:removeID": "sed -i -e 's.\"steam_ids\": \"[0-9][0-9]*\".\"steam_ids\": \"super_admins,go,here\".g' ./config/test.json",
     "test:seasons": "NODE_OPTIONS=--experimental-vm-modules jest --testTimeout=10000 --detectOpenHandles --config ./jest_config/jest.seasons.config.cjs",

src/routes/queue.ts

@@ -334,8 +334,14 @@ router.put('/:slug', Utils.ensureAuthenticated, async (req, res) => {
     if (action === 'join') {
       await QueueService.addUserToQueue(slug, req.user?.steam_id!);
       if (currentQueueCount == maxQueueCount) {
-        // TODO: Add in logic to create teams, or create a new queue with users' steam IDs and queue ID
-        // to get ready to shuffle teams.
+        // Queue is full — create teams and persist them.
+        try {
+          const result = await QueueService.createTeamsFromQueue(slug);
+          return res.status(200).json({ success: true, teams: result.teams });
+        } catch (err) {
+          console.error('Error creating teams from queue:', err);
+          // Fall through to return success=true but without teams
+        }
       }
     } else if (action === 'leave') {
       await QueueService.removeUserFromQueue(slug, req.user?.steam_id!, req.user?.steam_id!);

src/services/queue.ts

@@ -3,6 +3,7 @@ import Utils from "../utility/utils.js";
 import { QueueDescriptor } from "../types/queues/QueueDescriptor.js"
 import { QueueItem } from "../types/queues/QueueItem.js";
 import { createClient } from "redis";
+import { db } from "./db.js";
 
 const redis = createClient({ url: config.get("server.redisUrl"), });
 const DEFAULT_TTL_SECONDS: number = config.get("server.queueTTL") == 0 ? 3600 : config.get("server.queueTTL");
@@ -184,6 +185,202 @@ export class QueueService {
     return meta.maxSize;
   }
 
+  // Normalize player ratings helper
+  static normalizePlayerRatings(players: QueueItem[]): QueueItem[] {
+    const knownRatings = players
+      .map((p) => p.hltvRating)
+      .filter((r) => typeof r === 'number') as number[];
+    let fallbackRating = 1.0;
+    if (knownRatings.length > 0) {
+      knownRatings.sort((a, b) => a - b);
+      const mid = Math.floor(knownRatings.length / 2);
+      fallbackRating = knownRatings.length % 2 === 0
+        ? (knownRatings[mid - 1] + knownRatings[mid]) / 2
+        : knownRatings[mid];
+    }
+
+    return players.map((p) => {
+      if (typeof p.hltvRating === 'number') return { ...p, hltvRating: p.hltvRating };
+      const jitter = (Math.random() - 0.5) * 0.1 * fallbackRating;
+      return { ...p, hltvRating: fallbackRating + jitter };
+    });
+  }
+
+  /**
+   * Create two teams from the queue for the given slug.
+   * - Uses the first `maxSize` players in the queue
+   * - Attempts to balance teams by `hltvRating` while keeping randomness
+   * - Stores result in `queue-teams:<slug>` and removes selected players from the queue
+   * - Team name is `team_<CAPTAIN>` where CAPTAIN is the first member's steamId
+   */
+  static async createTeamsFromQueue(slug: string): Promise<{ teams: { name: string; members: QueueItem[] }[] }> {
+    const key = `queue:${slug}`;
+    const meta = await getQueueMetaOrThrow(slug);
+
+    // Ensure redis connected
+    if (redis.isOpen === false) {
+      await redis.connect();
+    }
+
+    const rawItems = await redis.lRange(key, 0, -1);
+    if (!rawItems || rawItems.length === 0) {
+      throw new Error(`Queue ${slug} is empty.`);
+    }
+
+    const maxPlayers = meta.maxSize || rawItems.length;
+
+    if (rawItems.length < maxPlayers) {
+      throw new Error(`Not enough players in queue to form teams. Have ${rawItems.length}, need ${maxPlayers}.`);
+    }
+
+    // Take the first N entries (FIFO semantics)
+    const selectedRaw = rawItems.slice(0, maxPlayers);
+    const players: QueueItem[] = selectedRaw.map((r) => JSON.parse(r));
+
+    // Compute a robust fallback for missing ratings: use median of known ratings
+    const knownRatings = players
+      .map((p) => p.hltvRating)
+      .filter((r) => typeof r === 'number') as number[];
+    let fallbackRating = 1.0;
+    if (knownRatings.length > 0) {
+      knownRatings.sort((a, b) => a - b);
+      const mid = Math.floor(knownRatings.length / 2);
+      fallbackRating = knownRatings.length % 2 === 0
+        ? (knownRatings[mid - 1] + knownRatings[mid]) / 2
+        : knownRatings[mid];
+    }
+
+  // Normalize ratings so every player has a numeric rating using helper
+  const normPlayers = QueueService.normalizePlayerRatings(players);
+
+  // Sort players by rating descending (strongest first)
+  normPlayers.sort((a: QueueItem, b: QueueItem) => (b.hltvRating! - a.hltvRating!));
+
+    // Greedy assignment with small randomness to avoid deterministic splits
+    const teamA: QueueItem[] = [];
+    const teamB: QueueItem[] = [];
+    let sumA = 0;
+    let sumB = 0;
+    const flipProb = 0.10; // 10% chance to flip assignment to add randomness
+
+    const targetSizeA = Math.ceil(maxPlayers / 2);
+    const targetSizeB = Math.floor(maxPlayers / 2);
+
+    for (const p of normPlayers) {
+      // If one team is already full, push to the other
+      if (teamA.length >= targetSizeA) {
+        teamB.push(p);
+        sumB += p.hltvRating!;
+        continue;
+      }
+      if (teamB.length >= targetSizeB) {
+        teamA.push(p);
+        sumA += p.hltvRating!;
+        continue;
+      }
+
+      // Normally assign to the team with smaller total rating
+      let assignToA = sumA <= sumB;
+
+      // small random flip
+      if (Math.random() < flipProb) assignToA = !assignToA;
+
+      if (assignToA) {
+        teamA.push(p);
+        sumA += p.hltvRating!;
+      } else {
+        teamB.push(p);
+        sumB += p.hltvRating!;
+      }
+    }
+
+    // Final size-adjustment (move lowest-rated if needed)
+    while (teamA.length > targetSizeA) {
+      // move lowest-rated from A to B
+      teamA.sort((a, b) => a.hltvRating! - b.hltvRating!);
+      const moved = teamA.shift()!;
+      sumA -= moved.hltvRating!;
+      teamB.push(moved);
+      sumB += moved.hltvRating!;
+    }
+    while (teamB.length > targetSizeB) {
+      teamB.sort((a, b) => a.hltvRating! - b.hltvRating!);
+      const moved = teamB.shift()!;
+      sumB -= moved.hltvRating!;
+      teamA.push(moved);
+      sumA += moved.hltvRating!;
+    }
+
+    // Captain is first user in each team array
+    const captainA = teamA[0];
+    const captainB = teamB[0];
+
+    const teams = [
+      { name: `team_${captainA?.steamId ?? 'A'}`, members: teamA },
+      { name: `team_${captainB?.steamId ?? 'B'}`, members: teamB },
+    ];
+
+    // Persist teams to database (team + team_auth_names)
+    // Resolve queue owner to internal user_id if present
+    let ownerUserId: number | null = 0;
+    try {
+      if (meta.ownerId) {
+        const ownerRows = await db.query('SELECT id FROM user WHERE steam_id = ?', [meta.ownerId]);
+        if (ownerRows && ownerRows.length > 0 && ownerRows[0].id) {
+          ownerUserId = ownerRows[0].id;
+        }
+      }
+    } catch (err) {
+      // fallback to 0 (system) if DB lookup fails
+      ownerUserId = 0;
+    }
+
+    for (const t of teams) {
+      const teamInsert = await db.query("INSERT INTO team (user_id, name, flag, logo, tag, public_team) VALUES ?", [[[
+        ownerUserId || 0,
+        t.name,
+        null,
+        null,
+        null,
+        0
+      ]]]);
+      // @ts-ignore insertId from RowDataPacket
+      const insertedTeamId = (teamInsert as any).insertId || null;
+      if (insertedTeamId) {
+        // prepare team_auth_names bulk insert
+        const authRows: Array<Array<any>> = [];
+        for (let i = 0; i < t.members.length; i++) {
+          const member = t.members[i];
+          const isCaptain = i === 0 ? 1 : 0;
+          authRows.push([insertedTeamId, member.steamId, '', isCaptain, 0]);
+        }
+        if (authRows.length > 0) {
+          await db.query("INSERT INTO team_auth_names (team_id, auth, name, captain, coach) VALUES ?", [authRows]);
+        }
+      }
+    }
+
+    // Store teams in Redis and remove selected players from queue
+    const teamsKey = `queue-teams:${slug}`;
+    // TTL based on remaining queue meta TTL
+    const remainingSeconds = Math.max(1, Math.floor((meta.expiresAt - Date.now()) / 1000));
+
+    await redis.set(teamsKey, JSON.stringify({ teams }), { EX: remainingSeconds });
+
+    // Remove selected players from queue list and update meta
+    for (const raw of selectedRaw) {
+      // remove one occurrence
+      await redis.lRem(key, 1, raw);
+      meta.currentPlayers -= 1;
+    }
+
+    // Persist updated meta and expire
+    await redis.set(`queue-meta:${slug}`, JSON.stringify(meta), { EX: remainingSeconds });
+    await redis.expire(key, remainingSeconds);
+
+    return { teams };
+  }
+
 }
 
 async function getQueueMetaOrThrow(slug: string): Promise<QueueDescriptor> {