@quenty/studio-bridge 0.22.1 → 0.24.0

package/src/commands/playtest/player/playtest-players.test.ts

@@ -5,20 +5,23 @@ import {
   removePlaytestPlayersAsync,
 } from './playtest-players.js';
 
+type Reply = { players?: unknown[]; remaining?: string[] };
+
 function createSession(
   sessionId: string,
   context: string,
-  returnValues: unknown[][],
+  replies: Reply[],
   playerName?: string
 ) {
-  const scripts: string[] = [];
+  const requests: Array<Record<string, unknown>> = [];
   return {
-    scripts,
+    requests,
     info: { sessionId, instanceId: 'place-1a2b', context, playerName },
     context,
-    execAsync: vi.fn(async (script: string) => {
-      scripts.push(script);
-      return { success: true, output: [], returnValues: returnValues.shift() };
+    playtestPlayersAsync: vi.fn(async (request: Record<string, unknown>) => {
+      requests.push(request);
+      const reply = replies.shift() ?? {};
+      return { players: reply.players ?? [], remaining: reply.remaining ?? [] };
     }),
   };
 }
@@ -39,7 +42,7 @@ const player = (name: string, userId: number) => ({
 describe('listPlaytestPlayersAsync', () => {
   it('pairs each player with its client session', async () => {
     const server = createSession('place-1a2b-server', 'server', [
-      [[player('Player1', -1), player('Player2', -2)]],
+      { players: [player('Player1', -1), player('Player2', -2)] },
     ]);
     const client = createSession(
       'place-1a2b-client-player1',
@@ -53,6 +56,7 @@ describe('listPlaytestPlayersAsync', () => {
       server as any
     );
 
+    expect(server.requests).toEqual([{ op: 'list' }]);
     expect(players).toEqual([
       { ...player('Player1', -1), sessionId: 'place-1a2b-client-player1' },
       player('Player2', -2),
@@ -63,7 +67,7 @@ describe('listPlaytestPlayersAsync', () => {
 describe('addPlaytestPlayersAsync', () => {
   it('adds players from the server and reports the ones that joined', async () => {
     const server = createSession('place-1a2b-server', 'server', [
-      [[player('Player3', -3)]],
+      { players: [player('Player3', -3)] },
     ]);
     const client = createSession(
       'place-1a2b-client-player3',
@@ -78,7 +82,7 @@ describe('addPlaytestPlayersAsync', () => {
       1
     );
 
-    expect(server.scripts[0]).toContain('AddPlayers(1)');
+    expect(server.requests).toEqual([{ op: 'add', count: 1, timeoutSec: 60 }]);
     expect(players).toEqual([
       { ...player('Player3', -3), sessionId: 'place-1a2b-client-player3' },
     ]);
@@ -88,14 +92,13 @@ describe('addPlaytestPlayersAsync', () => {
 describe('removePlaytestPlayersAsync', () => {
   it('has a connected client leave and kicks the rest', async () => {
     const server = createSession('place-1a2b-server', 'server', [
-      [[player('Player1', -1), player('Player2', -2)]],
-      [],
-      [[]],
+      { players: [player('Player1', -1), player('Player2', -2)] },
+      { remaining: [] },
     ]);
     const client = createSession(
       'place-1a2b-client-player1',
       'client',
-      [[]],
+      [{}],
       'Player1'
     );
 
@@ -109,16 +112,19 @@ describe('removePlaytestPlayersAsync', () => {
       { name: 'Player1', how: 'left' },
       { name: 'Player2', how: 'kicked' },
     ]);
-    expect(client.scripts[0]).toContain('LeaveTest');
-    expect(server.scripts[1]).toContain('"Player2"');
-    expect(server.scripts[1]).not.toContain('"Player1"');
+    expect(client.requests).toEqual([{ op: 'leave' }]);
+    expect(server.requests[1]).toEqual({
+      op: 'remove',
+      kick: ['Player2'],
+      names: ['Player1', 'Player2'],
+      timeoutSec: 60,
+    });
   });
 
   it('removes a player named twice only once', async () => {
     const server = createSession('place-1a2b-server', 'server', [
-      [[player('Player2', -2)]],
-      [],
-      [[]],
+      { players: [player('Player2', -2)] },
+      { remaining: [] },
     ]);
 
     const removed = await removePlaytestPlayersAsync(
@@ -130,9 +136,22 @@ describe('removePlaytestPlayersAsync', () => {
     expect(removed).toEqual([{ name: 'Player2', how: 'kicked' }]);
   });
 
+  it('reports players still there at the timeout', async () => {
+    const server = createSession('place-1a2b-server', 'server', [
+      { players: [player('Player2', -2)] },
+      { remaining: ['Player2'] },
+    ]);
+
+    await expect(
+      removePlaytestPlayersAsync(createConnection([server]), server as any, [
+        'Player2',
+      ])
+    ).rejects.toThrow('Players still in the playtest after 60s: Player2');
+  });
+
   it('refuses an unknown name before removing anyone', async () => {
     const server = createSession('place-1a2b-server', 'server', [
-      [[player('Player1', -1)]],
+      { players: [player('Player1', -1)] },
     ]);
 
     await expect(
@@ -141,6 +160,6 @@ describe('removePlaytestPlayersAsync', () => {
         'Nobody',
       ])
     ).rejects.toThrow("No player named 'Nobody' (players: Player1)");
-    expect(server.scripts).toHaveLength(1);
+    expect(server.requests).toHaveLength(1);
   });
 });

package/src/commands/playtest/player/playtest-players.ts

@@ -17,7 +17,7 @@ import {
 
 const PLAYER_CHANGE_TIMEOUT_SEC = 60;
 const CLIENT_SESSION_TIMEOUT_MS = 30_000;
-const SCRIPT_GRACE_MS = 10_000;
+const REPLY_GRACE_MS = 10_000;
 
 export interface PlaytestPlayer {
   name: string;
@@ -27,103 +27,12 @@ export interface PlaytestPlayer {
   sessionId?: string;
 }
 
-const PLAYER_INFO_FUNCTION = [
-  'local function playerInfo(player)',
-  '\treturn { name = player.Name, userId = player.UserId, displayName = player.DisplayName }',
-  'end',
-].join('\n');
+const REQUEST_TIMEOUT_MS = PLAYER_CHANGE_TIMEOUT_SEC * 1000 + REPLY_GRACE_MS;
 
-const LIST_PLAYERS_SCRIPT = [
-  PLAYER_INFO_FUNCTION,
-  'local players = {}',
-  'for _, player in game:GetService("Players"):GetPlayers() do',
-  '\ttable.insert(players, playerInfo(player))',
-  'end',
-  'return players',
-].join('\n');
-
-function addPlayersScript(count: number): string {
-  return [
-    PLAYER_INFO_FUNCTION,
-    'local Players = game:GetService("Players")',
-    'local before = {}',
-    'for _, player in Players:GetPlayers() do',
-    '\tbefore[player] = true',
-    'end',
-    `game:GetService("StudioTestService"):AddPlayers(${count})`,
-    `local deadline = os.clock() + ${PLAYER_CHANGE_TIMEOUT_SEC}`,
-    'local added = {}',
-    'repeat',
-    '\ttask.wait(0.25)',
-    '\tadded = {}',
-    '\tfor _, player in Players:GetPlayers() do',
-    '\t\tif not before[player] then',
-    '\t\t\ttable.insert(added, playerInfo(player))',
-    '\t\tend',
-    '\tend',
-    `until #added >= ${count} or os.clock() > deadline`,
-    'return added',
-  ].join('\n');
-}
-
-function kickPlayersScript(names: string[]): string {
-  return [
-    `local names = ${luaStringList(names)}`,
-    'local Players = game:GetService("Players")',
-    'for _, name in names do',
-    '\tlocal player = Players:FindFirstChild(name)',
-    '\tif player then',
-    '\t\tplayer:Kick("Removed by studio-bridge")',
-    '\tend',
-    'end',
-  ].join('\n');
-}
-
-function waitForPlayersGoneScript(names: string[]): string {
-  return [
-    `local names = ${luaStringList(names)}`,
-    'local Players = game:GetService("Players")',
-    `local deadline = os.clock() + ${PLAYER_CHANGE_TIMEOUT_SEC}`,
-    'local remaining',
-    'repeat',
-    '\tremaining = {}',
-    '\tfor _, name in names do',
-    '\t\tif Players:FindFirstChild(name) then',
-    '\t\t\ttable.insert(remaining, name)',
-    '\t\tend',
-    '\tend',
-    '\tif #remaining > 0 then',
-    '\t\ttask.wait(0.25)',
-    '\tend',
-    'until #remaining == 0 or os.clock() > deadline',
-    'return remaining',
-  ].join('\n');
-}
-
-const LEAVE_TEST_SCRIPT =
-  'task.defer(function() game:GetService("StudioTestService"):LeaveTest() end)';
-
-function luaStringList(values: string[]): string {
-  return `{ ${values.map((value) => JSON.stringify(value)).join(', ')} }`;
-}
-
-async function runScriptAsync(
-  session: BridgeSession,
-  script: string
-): Promise<unknown> {
-  const result = await session.execAsync(
-    script,
-    PLAYER_CHANGE_TIMEOUT_SEC * 1000 + SCRIPT_GRACE_MS
-  );
-  if (!result.success) {
-    throw new Error(result.error ?? 'Player script failed');
-  }
-  return result.returnValues?.[0];
-}
-
-function toPlayers(value: unknown): PlaytestPlayer[] {
-  if (!Array.isArray(value)) return [];
-  return value.map((entry) => ({
+function toPlayers(
+  players: Array<{ name: string; userId: number; displayName: string }>
+): PlaytestPlayer[] {
+  return players.map((entry) => ({
     name: String(entry.name),
     userId: Number(entry.userId),
     displayName: String(entry.displayName),
@@ -162,10 +71,15 @@ export async function listPlaytestPlayersAsync(
   connection: BridgeConnection,
   serverSession: BridgeSession
 ): Promise<PlaytestPlayer[]> {
-  const players = toPlayers(
-    await runScriptAsync(serverSession, LIST_PLAYERS_SCRIPT)
+  const { players } = await serverSession.playtestPlayersAsync(
+    { op: 'list' },
+    REQUEST_TIMEOUT_MS
+  );
+  return withSessions(
+    connection,
+    serverSession.info.instanceId,
+    toPlayers(players)
   );
-  return withSessions(connection, serverSession.info.instanceId, players);
 }
 
 /**
@@ -178,7 +92,12 @@ export async function addPlaytestPlayersAsync(
   count: number
 ): Promise<PlaytestPlayer[]> {
   const added = toPlayers(
-    await runScriptAsync(serverSession, addPlayersScript(count))
+    (
+      await serverSession.playtestPlayersAsync(
+        { op: 'add', count, timeoutSec: PLAYER_CHANGE_TIMEOUT_SEC },
+        REQUEST_TIMEOUT_MS
+      )
+    ).players
   );
   const { instanceId } = serverSession.info;
 
@@ -230,22 +149,23 @@ export async function removePlaytestPlayersAsync(
       ? connection.getSession(player.sessionId)
       : undefined;
     if (client) {
-      await runScriptAsync(client, LEAVE_TEST_SCRIPT);
+      await client.playtestPlayersAsync({ op: 'leave' }, REQUEST_TIMEOUT_MS);
       removed.push({ name: player.name, how: 'left' });
     } else {
       toKick.push(player.name);
       removed.push({ name: player.name, how: 'kicked' });
     }
   }
-  if (toKick.length > 0) {
-    await runScriptAsync(serverSession, kickPlayersScript(toKick));
-  }
-
-  const remaining = await runScriptAsync(
-    serverSession,
-    waitForPlayersGoneScript(targets.map((p) => p.name))
+  const { remaining } = await serverSession.playtestPlayersAsync(
+    {
+      op: 'remove',
+      kick: toKick,
+      names: targets.map((p) => p.name),
+      timeoutSec: PLAYER_CHANGE_TIMEOUT_SEC,
+    },
+    REQUEST_TIMEOUT_MS
   );
-  if (Array.isArray(remaining) && remaining.length > 0) {
+  if (remaining.length > 0) {
     throw new Error(
       `Players still in the playtest after ${PLAYER_CHANGE_TIMEOUT_SEC}s: ${remaining.join(
         ', '

package/src/commands/playtest/playtest-sessions.test.ts

@@ -12,6 +12,18 @@ vi.mock('../../process/studio-settings.js', () => ({
     settings.loadUserPluginsOnPlaytest,
 }));
 
+vi.mock('../../plugin/playtest-bridge.js', () => ({
+  buildPlaytestBridgeAsync: async (
+    scripts?: string[],
+    options?: { withClient?: boolean }
+  ) => ({
+    entrySource: 'entry',
+    ...(options?.withClient ? { clientEntrySource: 'client entry' } : {}),
+    modules: {},
+    precompiled: scripts ?? [],
+  }),
+}));
+
 import { ContextNotFoundError } from '../../bridge/index.js';
 import {
   explainMissingPlaytestContextAsync,
@@ -63,24 +75,12 @@ describe('startPlaytestAsync multiplayer checks', () => {
 });
 
 describe('with "Load user plugins on playtest" off', () => {
-  it('refuses to start a playtest whose sessions could never connect', async () => {
-    settings.loadUserPluginsOnPlaytest = false;
-    const editSession = createEditSession('current');
-
-    await expect(
-      startPlaytestAsync({} as any, editSession, 'play')
-    ).rejects.toThrow(
-      `Studio's "Load user plugins on playtest" setting is off`
-    );
-    expect(editSession.runPlaytestAsync).not.toHaveBeenCalled();
-  });
-
-  it('names the setting when no server session is connected', async () => {
+  it('does not blame the setting for a missing server session, which is planted', async () => {
     settings.loadUserPluginsOnPlaytest = false;
     const connection = { listSessions: () => [] } as any;
 
     await expect(resolvePlaytestServerSessionAsync(connection)).rejects.toThrow(
-      `No playtest is connected. Studio's "Load user plugins on playtest" setting is off`
+      "No playtest is running. Start one with 'studio-bridge playtest start'."
     );
   });
 
@@ -141,3 +141,105 @@ describe('explainMissingPlaytestContextAsync', () => {
     );
   });
 });
+
+describe('planting the server session', () => {
+  function createConnection() {
+    return {
+      port: 38741,
+      isRemote: false,
+      listSessions: () => [],
+      getSession: () => undefined,
+      on: vi.fn(),
+      off: vi.fn(),
+    } as any;
+  }
+
+  // The start fails at once, so the test sees what it was asked to start
+  function createFailingEditSession(pluginVersion: string) {
+    const editSession = createEditSession(pluginVersion);
+    editSession.runPlaytestAsync.mockResolvedValue({
+      playtestId: 'p',
+      success: false,
+      error: 'refused',
+    });
+    return editSession;
+  }
+
+  it('plants a bridge with the scripts to run when the setting is off', async () => {
+    settings.loadUserPluginsOnPlaytest = false;
+    const editSession = createFailingEditSession('old');
+
+    await expect(
+      startPlaytestAsync(createConnection(), editSession, 'run', undefined, {
+        scripts: ['return 1'],
+      })
+    ).rejects.toThrow('Playtest failed to start: refused');
+
+    const bridge = editSession.runPlaytestAsync.mock.calls[0][5];
+    expect(bridge.precompiled).toEqual(['return 1']);
+  });
+
+  it('plants a client bridge too for a play mode playtest when the setting is off', async () => {
+    settings.loadUserPluginsOnPlaytest = false;
+    const editSession = createFailingEditSession('old');
+
+    await expect(
+      startPlaytestAsync(createConnection(), editSession, 'play')
+    ).rejects.toThrow('Playtest failed to start: refused');
+
+    expect(
+      editSession.runPlaytestAsync.mock.calls[0][5].clientEntrySource
+    ).toContain('client entry');
+  });
+
+  it('plants no client bridge in run mode, or when the setting is unknown', async () => {
+    settings.loadUserPluginsOnPlaytest = false;
+    const runMode = createFailingEditSession('old');
+    await expect(
+      startPlaytestAsync(createConnection(), runMode, 'run')
+    ).rejects.toThrow('refused');
+    expect(
+      runMode.runPlaytestAsync.mock.calls[0][5].clientEntrySource
+    ).toBeUndefined();
+
+    settings.loadUserPluginsOnPlaytest = undefined;
+    const unknown = createFailingEditSession('current');
+    await expect(
+      startPlaytestAsync(createConnection(), unknown, 'play')
+    ).rejects.toThrow('refused');
+    expect(
+      unknown.runPlaytestAsync.mock.calls[0][5].clientEntrySource
+    ).toBeUndefined();
+  });
+
+  it('plants a bridge when the setting is unknown', async () => {
+    const editSession = createFailingEditSession('current');
+
+    await expect(
+      startPlaytestAsync(createConnection(), editSession, 'run')
+    ).rejects.toThrow('refused');
+
+    expect(editSession.runPlaytestAsync.mock.calls[0][5]).toBeDefined();
+  });
+
+  it('leaves the server to the plugin when the setting is on', async () => {
+    settings.loadUserPluginsOnPlaytest = true;
+    const editSession = createFailingEditSession('current');
+
+    await expect(
+      startPlaytestAsync(createConnection(), editSession, 'run')
+    ).rejects.toThrow('refused');
+
+    expect(editSession.runPlaytestAsync.mock.calls[0][5]).toBeUndefined();
+  });
+
+  it('needs the current plugin when plugin sessions will connect', async () => {
+    settings.loadUserPluginsOnPlaytest = true;
+    const editSession = createFailingEditSession('old');
+
+    await expect(
+      startPlaytestAsync(createConnection(), editSession, 'run')
+    ).rejects.toThrow("Run 'studio-bridge plugin install' first");
+    expect(editSession.runPlaytestAsync).not.toHaveBeenCalled();
+  });
+});