@mnbroatch/boardgame.io 0.0.1

package/src/lobby/client.test.ts

@@ -0,0 +1,385 @@
+// Tell ESLint about additional assertion methods.
+/*
+eslint jest/expect-expect: [
+  "warn",
+  { "assertFunctionNames": ["expect", "throwsWith*", "testBasicBody"] }
+]
+*/
+
+import { LobbyClient } from './client';
+
+const throwsWithoutBody = (fn: (...args: any) => Promise<any>) => async () => {
+  await expect(fn('tic-tac-toe')).rejects.toThrow(
+    `Expected body, got “undefined”.`
+  );
+};
+
+const testStringValidation =
+  (fn: (arg: any) => Promise<any>, label: string) => async () => {
+    await expect(fn(undefined)).rejects.toThrow(
+      `Expected ${label} string, got "undefined".`
+    );
+    await expect(fn(2)).rejects.toThrow(`Expected ${label} string, got "2".`);
+    await expect(fn('')).rejects.toThrow(`Expected ${label} string, got "".`);
+  };
+
+const throwsWithInvalidGameName = (fn: (...args: any) => Promise<any>) =>
+  testStringValidation(fn, 'game name');
+
+const throwsWithInvalidMatchID = (fn: (...args: any) => Promise<any>) =>
+  testStringValidation((matchID: string) => fn('chess', matchID), 'match ID');
+
+const testBasicBody = (fn: (...args: any) => Promise<any>) => async () => {
+  await expect(
+    fn('chess', '1', { playerID: undefined, credentials: 'pwd' })
+  ).rejects.toThrow(
+    'Expected body.playerID to be of type string, got “undefined”.'
+  );
+
+  await expect(
+    fn('chess', '2', { playerID: '0', credentials: 0 as unknown as string })
+  ).rejects.toThrow('Expected body.credentials to be of type string, got “0”.');
+};
+
+describe('LobbyClient', () => {
+  let client = new LobbyClient();
+
+  beforeEach(async () => {
+    (global as any).fetch = jest.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => {},
+    }));
+  });
+
+  describe('construction', () => {
+    test('basic', async () => {
+      await client.listGames();
+      expect(fetch).toBeCalledWith(`/games`, undefined);
+    });
+
+    test('with server address', async () => {
+      const client = new LobbyClient({ server: 'http://api.io' });
+      await client.listGames();
+      expect(fetch).toBeCalledWith(`http://api.io/games`, undefined);
+    });
+
+    test('with server address with trailing slash', async () => {
+      const client = new LobbyClient({ server: 'http://api.io/' });
+      await client.listGames();
+      expect(fetch).toBeCalledWith(`http://api.io/games`, undefined);
+    });
+  });
+
+  describe('status errors', () => {
+    beforeEach(async () => {
+      client = new LobbyClient();
+    });
+
+    test('404 throws an error', async () => {
+      (global as any).fetch = jest.fn(async () => ({
+        ok: false,
+        status: 404,
+        json: async () => {},
+      }));
+
+      await expect(client.listGames()).rejects.toThrow('HTTP status 404');
+    });
+
+    test('404 throws an error with json details', async () => {
+      (global as any).fetch = jest.fn(async () => ({
+        ok: false,
+        status: 404,
+        clone: () => ({
+          json: async () => ({ moreInformation: 'some helpful details' }),
+        }),
+      }));
+
+      await expect(client.listGames()).rejects.toThrow(
+        expect.objectContaining({
+          message: 'HTTP status 404',
+          details: {
+            moreInformation: 'some helpful details',
+          },
+        })
+      );
+    });
+
+    test('404 throws an error with text details', async () => {
+      (global as any).fetch = jest.fn(async () => ({
+        ok: false,
+        status: 404,
+        json: async () => {
+          throw new Error('impossible to parse json');
+        },
+        text: async () =>
+          '<moreInformation>some helpful details</moreInformation>',
+      }));
+
+      await expect(client.listGames()).rejects.toThrow(
+        expect.objectContaining({
+          message: 'HTTP status 404',
+          details: '<moreInformation>some helpful details</moreInformation>',
+        })
+      );
+    });
+
+    test('404 throws an error without details', async () => {
+      (global as any).fetch = jest.fn(async () => ({
+        ok: false,
+        status: 404,
+        json: async () => {
+          throw new Error('impossible to parse json');
+        },
+        text: async () => {
+          throw new Error('something went wrong in the connection');
+        },
+      }));
+
+      await expect(client.listGames()).rejects.toThrow(
+        expect.objectContaining({
+          message: 'HTTP status 404',
+          details: 'something went wrong in the connection',
+        })
+      );
+    });
+  });
+
+  describe('listGames', () => {
+    test('calls `/games`', async () => {
+      await client.listGames();
+      expect(fetch).toBeCalledWith('/games', undefined);
+    });
+
+    test('init can be customized', async () => {
+      await client.listGames({ headers: { Authorization: 'pwd' } });
+      expect(fetch).toBeCalledWith('/games', {
+        headers: { Authorization: 'pwd' },
+      });
+    });
+  });
+
+  describe('listMatches', () => {
+    test('calls `/games/:name`', async () => {
+      await client.listMatches('tic-tac-toe');
+      expect(fetch).toBeCalledWith(`/games/tic-tac-toe`, undefined);
+    });
+
+    test('validates gameName', throwsWithInvalidGameName(client.listMatches));
+
+    describe('builds filter queries', () => {
+      test('kitchen sink', async () => {
+        await client.listMatches('chess', {
+          isGameover: false,
+          updatedBefore: 3000,
+          updatedAfter: 1000,
+        });
+        expect(fetch).toBeCalledWith(
+          '/games/chess?isGameover=false&updatedBefore=3000&updatedAfter=1000',
+          undefined
+        );
+      });
+
+      test('isGameover', async () => {
+        await client.listMatches('chess', { isGameover: undefined });
+        expect(fetch).toBeCalledWith('/games/chess', undefined);
+        await client.listMatches('chess', { isGameover: false });
+        expect(fetch).toBeCalledWith(
+          '/games/chess?isGameover=false',
+          undefined
+        );
+        await client.listMatches('chess', { isGameover: true });
+        expect(fetch).toBeCalledWith('/games/chess?isGameover=true', undefined);
+      });
+
+      test('updatedBefore', async () => {
+        const updatedBefore = 1989;
+        await client.listMatches('chess', { updatedBefore });
+        expect(fetch).toBeCalledWith(
+          '/games/chess?updatedBefore=1989',
+          undefined
+        );
+      });
+
+      test('updatedAfter', async () => {
+        const updatedAfter = 1970;
+        await client.listMatches('chess', { updatedAfter });
+        expect(fetch).toBeCalledWith(
+          '/games/chess?updatedAfter=1970',
+          undefined
+        );
+      });
+    });
+  });
+
+  describe('getMatch', () => {
+    test('calls `/games/:name/:id`', async () => {
+      await client.getMatch('tic-tac-toe', 'xyz');
+      expect(fetch).toBeCalledWith(`/games/tic-tac-toe/xyz`, undefined);
+    });
+
+    test('validates gameName', throwsWithInvalidGameName(client.getMatch));
+    test('validates matchID', throwsWithInvalidMatchID(client.getMatch));
+  });
+
+  describe('createMatch', () => {
+    test('calls `/games/:name/create`', async () => {
+      await client.createMatch('tic-tac-toe', { numPlayers: 2 });
+      expect(fetch).toBeCalledWith(`/games/tic-tac-toe/create`, {
+        method: 'post',
+        body: '{"numPlayers":2}',
+        headers: { 'Content-Type': 'application/json' },
+      });
+    });
+
+    test('validates gameName', throwsWithInvalidGameName(client.createMatch));
+
+    test('throws without body', throwsWithoutBody(client.createMatch));
+
+    test('validates body', async () => {
+      await expect(
+        client.createMatch('tic-tac-toe', {
+          numPlayers: '12' as unknown as number,
+        })
+      ).rejects.toThrow(
+        'Expected body.numPlayers to be of type number, got “12”.'
+      );
+    });
+
+    test('init can be customized', async () => {
+      await client.createMatch(
+        'chess',
+        { numPlayers: 2 },
+        { headers: { Authorization: 'pwd' } }
+      );
+      expect(fetch).toBeCalledWith(`/games/chess/create`, {
+        method: 'post',
+        body: '{"numPlayers":2}',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: 'pwd',
+        },
+      });
+    });
+  });
+
+  describe('joinMatch', () => {
+    test('calls `/games/:name/:id/join`', async () => {
+      await client.joinMatch('tic-tac-toe', 'xyz', {
+        playerID: '0',
+        playerName: 'Alice',
+      });
+      expect(fetch).toBeCalledWith(`/games/tic-tac-toe/xyz/join`, {
+        method: 'post',
+        body: '{"playerID":"0","playerName":"Alice"}',
+        headers: { 'Content-Type': 'application/json' },
+      });
+    });
+
+    test('validates gameName', throwsWithInvalidGameName(client.joinMatch));
+    test('validates matchID', throwsWithInvalidMatchID(client.joinMatch));
+
+    test(
+      'throws without body',
+      throwsWithoutBody(() => client.joinMatch('chess', 'id', undefined))
+    );
+
+    test('validates body', async () => {
+      await expect(
+        client.joinMatch('tic-tac-toe', 'xyz', {
+          playerID: 0 as unknown as string,
+          playerName: 'Bob',
+        })
+      ).rejects.toThrow(
+        'Expected body.playerID to be of type string|undefined, got “0”.'
+      );
+
+      await expect(
+        client.joinMatch('tic-tac-toe', 'xyz', {
+          playerID: '0',
+          playerName: undefined,
+        })
+      ).rejects.toThrow(
+        'Expected body.playerName to be of type string, got “undefined”.'
+      );
+
+      // Allows requests that don’t specify `playerID`.
+      await expect(
+        client.joinMatch('tic-tac-toe', 'xyz', { playerName: 'Bob' })
+      ).resolves.not.toThrow();
+    });
+  });
+
+  describe('leaveMatch', () => {
+    test('calls `/games/:name/:id/leave`', async () => {
+      await client.leaveMatch('tic-tac-toe', 'xyz', {
+        playerID: '0',
+        credentials: 'pwd',
+      });
+      expect(fetch).toBeCalledWith(`/games/tic-tac-toe/xyz/leave`, {
+        method: 'post',
+        body: '{"playerID":"0","credentials":"pwd"}',
+        headers: { 'Content-Type': 'application/json' },
+      });
+    });
+
+    test('validates gameName', throwsWithInvalidGameName(client.leaveMatch));
+    test('validates matchID', throwsWithInvalidMatchID(client.leaveMatch));
+
+    test(
+      'throws without body',
+      throwsWithoutBody(() => client.leaveMatch('chess', 'id', undefined))
+    );
+
+    test('validates body', testBasicBody(client.leaveMatch));
+  });
+
+  describe('updatePlayer', () => {
+    test('calls `/games/:name/:id/update`', async () => {
+      await client.updatePlayer('tic-tac-toe', 'xyz', {
+        playerID: '0',
+        credentials: 'pwd',
+        newName: 'Al',
+      });
+      expect(fetch).toBeCalledWith(`/games/tic-tac-toe/xyz/update`, {
+        method: 'post',
+        body: '{"playerID":"0","credentials":"pwd","newName":"Al"}',
+        headers: { 'Content-Type': 'application/json' },
+      });
+    });
+
+    test('validates gameName', throwsWithInvalidGameName(client.updatePlayer));
+    test('validates matchID', throwsWithInvalidMatchID(client.updatePlayer));
+
+    test(
+      'throws without body',
+      throwsWithoutBody(() => client.updatePlayer('chess', 'id', undefined))
+    );
+
+    test('validates body', testBasicBody(client.updatePlayer));
+  });
+
+  describe('playAgain', () => {
+    test('calls `/games/:name/:id/playAgain`', async () => {
+      await client.playAgain('tic-tac-toe', 'xyz', {
+        playerID: '0',
+        credentials: 'pwd',
+      });
+      expect(fetch).toBeCalledWith(`/games/tic-tac-toe/xyz/playAgain`, {
+        method: 'post',
+        body: '{"playerID":"0","credentials":"pwd"}',
+        headers: { 'Content-Type': 'application/json' },
+      });
+    });
+
+    test('validates gameName', throwsWithInvalidGameName(client.playAgain));
+    test('validates matchID', throwsWithInvalidMatchID(client.playAgain));
+
+    test(
+      'throws without body',
+      throwsWithoutBody(() => client.playAgain('chess', 'id', undefined))
+    );
+
+    test('validates body', testBasicBody(client.playAgain));
+  });
+});