gameglue 1.1.1 → 1.1.3

package/src/auth.spec.js

@@ -0,0 +1,391 @@
+const { GameGlueAuth } = require('./auth');
+const { storage } = require('./utils');
+const {
+  mockConfig,
+  validAccessToken,
+  expiredAccessToken,
+  validRefreshToken,
+  createMockJwt
+} = require('./test/fixtures');
+
+// Mock the oidc-client-ts module
+jest.mock('oidc-client-ts', () => ({
+  OidcClient: jest.fn().mockImplementation(() => ({
+    createSigninRequest: jest.fn().mockResolvedValue({ url: 'https://auth.example.com/login' }),
+    processSigninResponse: jest.fn().mockResolvedValue({
+      access_token: 'new-access-token',
+      refresh_token: 'new-refresh-token'
+    })
+  }))
+}));
+
+// Mock fetch for token refresh
+global.fetch = jest.fn();
+
+// Suppress console output during tests
+const originalConsoleLog = console.log;
+const originalConsoleError = console.error;
+
+describe('GameGlueAuth', () => {
+  let auth;
+
+  beforeEach(() => {
+    auth = new GameGlueAuth(mockConfig);
+    jest.clearAllMocks();
+    jest.useFakeTimers();
+    // Suppress console output
+    console.log = jest.fn();
+    console.error = jest.fn();
+  });
+
+  afterEach(() => {
+    // Restore console
+    console.log = originalConsoleLog;
+    console.error = originalConsoleError;
+    jest.useRealTimers();
+    // Clear storage by setting to undefined (mimics clearing)
+    storage.set('gg-auth-token', undefined);
+    storage.set('gg-refresh-token', undefined);
+  });
+
+  describe('constructor', () => {
+    it('should initialize with correct OIDC settings', () => {
+      expect(auth._oidcSettings).toMatchObject({
+        authority: 'https://auth.gameglue.gg/realms/GameGlue',
+        client_id: 'test-client-id',
+        redirect_uri: 'http://localhost:3000/callback',
+        response_type: 'code',
+        scope: 'openid msfs:read gg:broadcast',
+        response_mode: 'fragment',
+        filterProtocolClaims: true
+      });
+      // post_logout_redirect_uri is based on window.location.href which varies by environment
+      expect(auth._oidcSettings.post_logout_redirect_uri).toBeDefined();
+    });
+
+    it('should use window.location.href as default redirect_uri', () => {
+      const configNoRedirect = { clientId: 'test', scopes: [] };
+      const authNoRedirect = new GameGlueAuth(configNoRedirect);
+
+      // The redirect_uri should be based on window.location.href (varies by environment)
+      expect(authNoRedirect._oidcSettings.redirect_uri).toMatch(/^http:\/\/localhost/);
+    });
+
+    it('should handle empty scopes array', () => {
+      const configEmptyScopes = { clientId: 'test', scopes: [] };
+      const authEmptyScopes = new GameGlueAuth(configEmptyScopes);
+
+      expect(authEmptyScopes._oidcSettings.scope).toBe('openid ');
+    });
+
+    it('should handle undefined scopes', () => {
+      const configNoScopes = { clientId: 'test' };
+      const authNoScopes = new GameGlueAuth(configNoScopes);
+
+      expect(authNoScopes._oidcSettings.scope).toBe('openid ');
+    });
+
+    it('should remove trailing slashes from redirect_uri', () => {
+      const configWithSlash = {
+        clientId: 'test',
+        redirect_uri: 'http://localhost:3000/callback/'
+      };
+      const authWithSlash = new GameGlueAuth(configWithSlash);
+
+      expect(authWithSlash._oidcSettings.redirect_uri).toBe('http://localhost:3000/callback');
+    });
+  });
+
+  describe('setAccessToken / getAccessToken', () => {
+    it('should store and retrieve access token', () => {
+      auth.setAccessToken(validAccessToken);
+      const retrieved = auth.getAccessToken();
+
+      expect(retrieved).toBe(validAccessToken);
+    });
+
+    it('should set up token refresh timeout when setting token', () => {
+      auth.setAccessToken(validAccessToken);
+
+      // Check that a timeout was scheduled
+      expect(jest.getTimerCount()).toBeGreaterThan(0);
+    });
+
+    it('should not set timeout for null token', () => {
+      auth.setAccessToken(null);
+
+      expect(jest.getTimerCount()).toBe(0);
+    });
+  });
+
+  describe('setRefreshToken / getRefreshToken', () => {
+    it('should store and retrieve refresh token', () => {
+      auth.setRefreshToken(validRefreshToken);
+      const retrieved = auth.getRefreshToken();
+
+      expect(retrieved).toBe(validRefreshToken);
+    });
+  });
+
+  describe('getUserId', () => {
+    it('should extract user ID from JWT', () => {
+      auth.setAccessToken(validAccessToken);
+
+      const userId = auth.getUserId();
+
+      expect(userId).toBe('user-123');
+    });
+  });
+
+  describe('isTokenExpired', () => {
+    it('should return false for valid token', () => {
+      const result = auth.isTokenExpired(validAccessToken);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true for expired token', () => {
+      const result = auth.isTokenExpired(expiredAccessToken);
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('isAuthenticated', () => {
+    it('should return false when no token exists', async () => {
+      const result = await auth.isAuthenticated();
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true for valid non-expired token', async () => {
+      auth.setAccessToken(validAccessToken);
+
+      const result = await auth.isAuthenticated();
+
+      expect(result).toBe(true);
+    });
+
+    it('should attempt refresh for expired token', async () => {
+      auth.setAccessToken(expiredAccessToken);
+      auth.setRefreshToken(validRefreshToken);
+
+      // Mock successful refresh
+      global.fetch.mockResolvedValueOnce({
+        status: 200,
+        json: () =>
+          Promise.resolve({
+            access_token: validAccessToken,
+            refresh_token: validRefreshToken
+          })
+      });
+
+      const result = await auth.isAuthenticated();
+
+      expect(global.fetch).toHaveBeenCalled();
+    });
+
+    it('should return false when refresh fails and token is still expired', async () => {
+      auth.setAccessToken(expiredAccessToken);
+      auth.setRefreshToken(validRefreshToken);
+
+      // Mock failed refresh
+      global.fetch.mockResolvedValueOnce({
+        status: 401,
+        json: () => Promise.resolve({ error: 'invalid_grant' })
+      });
+
+      const result = await auth.isAuthenticated();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('attemptRefresh', () => {
+    it('should call token endpoint with correct parameters', async () => {
+      auth.setRefreshToken(validRefreshToken);
+
+      global.fetch.mockResolvedValueOnce({
+        status: 200,
+        json: () =>
+          Promise.resolve({
+            access_token: validAccessToken,
+            refresh_token: validRefreshToken
+          })
+      });
+
+      await auth.attemptRefresh();
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://auth.gameglue.gg/realms/GameGlue/protocol/openid-connect/token',
+        expect.objectContaining({
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded'
+          }
+        })
+      );
+    });
+
+    it('should update tokens on successful refresh', async () => {
+      auth.setRefreshToken(validRefreshToken);
+
+      const newAccessToken = createMockJwt({ sub: 'user-456' }, 3600);
+      const newRefreshToken = createMockJwt({ sub: 'user-456', type: 'refresh' }, 86400);
+
+      global.fetch.mockResolvedValueOnce({
+        status: 200,
+        json: () =>
+          Promise.resolve({
+            access_token: newAccessToken,
+            refresh_token: newRefreshToken
+          })
+      });
+
+      await auth.attemptRefresh();
+
+      expect(auth.getAccessToken()).toBe(newAccessToken);
+      expect(auth.getRefreshToken()).toBe(newRefreshToken);
+    });
+
+    it('should call refresh callback on successful refresh', async () => {
+      const callback = jest.fn();
+      auth.onTokenRefreshed(callback);
+      auth.setRefreshToken(validRefreshToken);
+
+      const responseData = {
+        access_token: validAccessToken,
+        refresh_token: validRefreshToken
+      };
+
+      global.fetch.mockResolvedValueOnce({
+        status: 200,
+        json: () => Promise.resolve(responseData)
+      });
+
+      await auth.attemptRefresh();
+
+      expect(callback).toHaveBeenCalledWith(responseData);
+    });
+
+    it('should handle network errors gracefully', async () => {
+      auth.setRefreshToken(validRefreshToken);
+      global.fetch.mockRejectedValueOnce(new Error('Network error'));
+
+      // Should not throw
+      await expect(auth.attemptRefresh()).resolves.toBeUndefined();
+    });
+
+    it('should not update tokens on non-200 response', async () => {
+      auth.setRefreshToken(validRefreshToken);
+      const originalAccessToken = auth.getAccessToken();
+
+      global.fetch.mockResolvedValueOnce({
+        status: 400,
+        json: () => Promise.resolve({ error: 'invalid_grant' })
+      });
+
+      await auth.attemptRefresh();
+
+      // Access token should remain unchanged (undefined in this case)
+      expect(auth.getAccessToken()).toBe(originalAccessToken);
+    });
+  });
+
+  describe('onTokenRefreshed', () => {
+    it('should register callback for token refresh', () => {
+      const callback = jest.fn();
+      auth.onTokenRefreshed(callback);
+
+      expect(auth._refreshCallback).toBe(callback);
+    });
+  });
+
+  describe('setTokenRefreshTimeout', () => {
+    it('should schedule refresh before token expiration', () => {
+      // Token expires in 1 hour (3600 seconds)
+      auth.setTokenRefreshTimeout(validAccessToken);
+
+      // Should have scheduled a timeout
+      expect(jest.getTimerCount()).toBe(1);
+    });
+
+    it('should clear previous timeout when setting new one', () => {
+      auth.setTokenRefreshTimeout(validAccessToken);
+      auth.setTokenRefreshTimeout(validAccessToken);
+
+      // Should only have one active timeout
+      expect(jest.getTimerCount()).toBe(1);
+    });
+
+    it('should not schedule timeout for expired token', () => {
+      auth.setTokenRefreshTimeout(expiredAccessToken);
+
+      // Timer count may be 0 since the timeUntilExp is negative
+      // The important thing is it doesn't throw
+    });
+  });
+
+  describe('_shouldHandleRedirectResponse', () => {
+    it('should return true when hash contains state and code', () => {
+      window.location.hash = '#state=abc123&code=xyz789';
+
+      expect(auth._shouldHandleRedirectResponse()).toBe(true);
+    });
+
+    it('should return true when hash contains state and error', () => {
+      window.location.hash = '#state=abc123&error=access_denied';
+
+      expect(auth._shouldHandleRedirectResponse()).toBe(true);
+    });
+
+    it('should return false when hash does not contain state', () => {
+      window.location.hash = '#code=xyz789';
+
+      expect(auth._shouldHandleRedirectResponse()).toBe(false);
+    });
+
+    it('should return false when hash is empty', () => {
+      window.location.hash = '';
+
+      expect(auth._shouldHandleRedirectResponse()).toBe(false);
+    });
+  });
+
+  describe('handleRedirectResponse', () => {
+    it('should process signin response and store tokens', async () => {
+      const { OidcClient } = require('oidc-client-ts');
+      OidcClient.mockImplementation(() => ({
+        processSigninResponse: jest.fn().mockResolvedValue({
+          access_token: validAccessToken,
+          refresh_token: validRefreshToken
+        })
+      }));
+
+      const authNew = new GameGlueAuth(mockConfig);
+      await authNew.handleRedirectResponse();
+
+      expect(authNew.getAccessToken()).toBe(validAccessToken);
+      expect(authNew.getRefreshToken()).toBe(validRefreshToken);
+      expect(window.history.pushState).toHaveBeenCalled();
+    });
+
+    it('should handle error response gracefully', async () => {
+      const { OidcClient } = require('oidc-client-ts');
+      OidcClient.mockImplementation(() => ({
+        processSigninResponse: jest.fn().mockResolvedValue({
+          error: 'access_denied',
+          access_token: null
+        })
+      }));
+
+      const authNew = new GameGlueAuth(mockConfig);
+      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+
+      await authNew.handleRedirectResponse();
+
+      expect(consoleSpy).toHaveBeenCalledWith('access_denied');
+      consoleSpy.mockRestore();
+    });
+  });
+});

package/src/listener.spec.js

@@ -0,0 +1,299 @@
+const { Listener } = require('./listener');
+const { createMockSocket, mockListenerConfig } = require('./test/fixtures');
+
+describe('Listener', () => {
+  let mockSocket;
+  let listener;
+
+  beforeEach(() => {
+    mockSocket = createMockSocket();
+    listener = new Listener(mockSocket, mockListenerConfig);
+  });
+
+  describe('constructor', () => {
+    it('should initialize with config and socket', () => {
+      expect(listener._config).toEqual(mockListenerConfig);
+      expect(listener._socket).toBe(mockSocket);
+      expect(listener._callbacks).toEqual([]);
+    });
+
+    it('should copy fields array from config', () => {
+      expect(listener._fields).toEqual(['altitude', 'airspeed', 'heading']);
+      expect(listener._fields).not.toBe(mockListenerConfig.fields); // Should be a copy
+    });
+
+    it('should handle config without fields', () => {
+      const configWithoutFields = { gameId: 'msfs', userId: 'user-123' };
+      const listenerNoFields = new Listener(mockSocket, configWithoutFields);
+
+      expect(listenerNoFields._fields).toBeNull();
+    });
+  });
+
+  describe('establishConnection', () => {
+    it('should emit listen event with object payload when fields are specified', async () => {
+      const result = await listener.establishConnection();
+
+      expect(mockSocket.timeout).toHaveBeenCalledWith(5000);
+      expect(mockSocket.emit).toHaveBeenCalledWith(
+        'listen',
+        {
+          userId: 'user-123',
+          gameId: 'msfs',
+          fields: ['altitude', 'airspeed', 'heading']
+        },
+        expect.any(Function)
+      );
+      expect(result).toEqual({ status: 'success' });
+    });
+
+    it('should emit listen event with legacy string format when no fields', async () => {
+      const configNoFields = { gameId: 'msfs', userId: 'user-123' };
+      const listenerNoFields = new Listener(mockSocket, configNoFields);
+
+      await listenerNoFields.establishConnection();
+
+      expect(mockSocket.emit).toHaveBeenCalledWith(
+        'listen',
+        'user-123:msfs',
+        expect.any(Function)
+      );
+    });
+
+    it('should throw error when socket is missing', async () => {
+      const invalidListener = new Listener(null, mockListenerConfig);
+
+      await expect(invalidListener.establishConnection()).rejects.toThrow(
+        'Missing arguments in establishConnection'
+      );
+    });
+
+    it('should throw error when userId is missing', async () => {
+      const invalidConfig = { gameId: 'msfs' };
+      const invalidListener = new Listener(mockSocket, invalidConfig);
+
+      await expect(invalidListener.establishConnection()).rejects.toThrow(
+        'Missing arguments in establishConnection'
+      );
+    });
+
+    it('should throw error when gameId is missing', async () => {
+      const invalidConfig = { userId: 'user-123' };
+      const invalidListener = new Listener(mockSocket, invalidConfig);
+
+      await expect(invalidListener.establishConnection()).rejects.toThrow(
+        'Missing arguments in establishConnection'
+      );
+    });
+
+    it('should handle timeout error', async () => {
+      mockSocket.emit = jest.fn((event, data, callback) => {
+        callback(new Error('timeout'), null);
+      });
+
+      const result = await listener.establishConnection();
+
+      expect(result).toEqual({
+        status: 'failed',
+        reason: 'Listen request timed out.'
+      });
+    });
+
+    it('should handle failure response from server', async () => {
+      mockSocket.emit = jest.fn((event, data, callback) => {
+        callback(null, { status: 'failed', reason: 'Unauthorized' });
+      });
+
+      const result = await listener.establishConnection();
+
+      expect(result).toEqual({
+        status: 'failed',
+        reason: 'Unauthorized'
+      });
+    });
+  });
+
+  describe('setupEventListener', () => {
+    it('should register update event handler and return self', () => {
+      const result = listener.setupEventListener();
+
+      expect(mockSocket.on).toHaveBeenCalledWith('update', expect.any(Function));
+      expect(result).toBe(listener);
+    });
+  });
+
+  describe('subscribe', () => {
+    it('should add new fields to subscription', async () => {
+      await listener.subscribe(['fuel', 'temperature']);
+
+      expect(listener._fields).toContain('altitude');
+      expect(listener._fields).toContain('fuel');
+      expect(listener._fields).toContain('temperature');
+    });
+
+    it('should not add duplicate fields', async () => {
+      await listener.subscribe(['altitude', 'fuel']);
+
+      const altitudeCount = listener._fields.filter(f => f === 'altitude').length;
+      expect(altitudeCount).toBe(1);
+      expect(listener._fields).toContain('fuel');
+    });
+
+    it('should emit listen-update event', async () => {
+      await listener.subscribe(['fuel']);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith(
+        'listen-update',
+        expect.objectContaining({
+          userId: 'user-123',
+          gameId: 'msfs',
+          fields: expect.arrayContaining(['altitude', 'airspeed', 'heading', 'fuel'])
+        }),
+        expect.any(Function)
+      );
+    });
+
+    it('should initialize fields array if none existed', async () => {
+      const configNoFields = { gameId: 'msfs', userId: 'user-123' };
+      const listenerNoFields = new Listener(mockSocket, configNoFields);
+
+      await listenerNoFields.subscribe(['fuel', 'temperature']);
+
+      expect(listenerNoFields._fields).toEqual(['fuel', 'temperature']);
+    });
+
+    it('should throw error for non-array input', async () => {
+      await expect(listener.subscribe('fuel')).rejects.toThrow(
+        'fields must be a non-empty array'
+      );
+    });
+
+    it('should throw error for empty array', async () => {
+      await expect(listener.subscribe([])).rejects.toThrow(
+        'fields must be a non-empty array'
+      );
+    });
+  });
+
+  describe('unsubscribe', () => {
+    it('should remove fields from subscription', async () => {
+      await listener.unsubscribe(['altitude']);
+
+      expect(listener._fields).not.toContain('altitude');
+      expect(listener._fields).toContain('airspeed');
+      expect(listener._fields).toContain('heading');
+    });
+
+    it('should emit listen-update event with updated fields', async () => {
+      await listener.unsubscribe(['altitude', 'airspeed']);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith(
+        'listen-update',
+        {
+          userId: 'user-123',
+          gameId: 'msfs',
+          fields: ['heading']
+        },
+        expect.any(Function)
+      );
+    });
+
+    it('should throw error when no explicit fields exist', async () => {
+      const configNoFields = { gameId: 'msfs', userId: 'user-123' };
+      const listenerNoFields = new Listener(mockSocket, configNoFields);
+
+      await expect(listenerNoFields.unsubscribe(['fuel'])).rejects.toThrow(
+        'Cannot unsubscribe when receiving all fields'
+      );
+    });
+
+    it('should throw error for non-array input', async () => {
+      await expect(listener.unsubscribe('altitude')).rejects.toThrow(
+        'fields must be a non-empty array'
+      );
+    });
+
+    it('should throw error for empty array', async () => {
+      await expect(listener.unsubscribe([])).rejects.toThrow(
+        'fields must be a non-empty array'
+      );
+    });
+
+    it('should handle unsubscribing non-existent field gracefully', async () => {
+      await listener.unsubscribe(['nonexistent']);
+
+      expect(listener._fields).toEqual(['altitude', 'airspeed', 'heading']);
+    });
+  });
+
+  describe('getFields', () => {
+    it('should return copy of fields array', () => {
+      const fields = listener.getFields();
+
+      expect(fields).toEqual(['altitude', 'airspeed', 'heading']);
+      expect(fields).not.toBe(listener._fields); // Should be a copy
+    });
+
+    it('should return null when no explicit fields', () => {
+      const configNoFields = { gameId: 'msfs', userId: 'user-123' };
+      const listenerNoFields = new Listener(mockSocket, configNoFields);
+
+      expect(listenerNoFields.getFields()).toBeNull();
+    });
+  });
+
+  describe('sendCommand', () => {
+    it('should emit set event with correct payload', async () => {
+      const result = await listener.sendCommand('autopilot', true);
+
+      expect(mockSocket.timeout).toHaveBeenCalledWith(5000);
+      expect(mockSocket.emit).toHaveBeenCalledWith(
+        'set',
+        {
+          userId: 'user-123',
+          gameId: 'msfs',
+          data: {
+            fieldName: 'autopilot',
+            value: true
+          }
+        },
+        expect.any(Function)
+      );
+      expect(result).toEqual({ status: 'success' });
+    });
+
+    it('should handle various value types', async () => {
+      await listener.sendCommand('altitude', 35000);
+      await listener.sendCommand('flaps', 0.5);
+      await listener.sendCommand('status', 'active');
+      await listener.sendCommand('config', { mode: 'auto' });
+
+      expect(mockSocket.emit).toHaveBeenCalledTimes(4);
+    });
+
+    it('should throw error for invalid field', async () => {
+      await expect(listener.sendCommand('', true)).rejects.toThrow(
+        'field must be a non-empty string'
+      );
+      await expect(listener.sendCommand(null, true)).rejects.toThrow(
+        'field must be a non-empty string'
+      );
+      await expect(listener.sendCommand(123, true)).rejects.toThrow(
+        'field must be a non-empty string'
+      );
+    });
+
+    it('should handle timeout error', async () => {
+      mockSocket.emit = jest.fn((event, data, callback) => {
+        callback(new Error('timeout'), null);
+      });
+
+      const result = await listener.sendCommand('autopilot', true);
+
+      expect(result).toEqual({
+        status: 'failed',
+        reason: 'Command request timed out.'
+      });
+    });
+  });
+});