gameglue 1.1.1 → 1.1.2

package/src/test/fixtures.js

@@ -0,0 +1,106 @@
+// Test fixtures for GameGlueJS SDK
+
+// Helper to create a JWT with custom payload
+function createMockJwt(payload, expiresInSeconds = 3600) {
+  const header = { alg: 'RS256', typ: 'JWT' };
+  const now = Math.floor(Date.now() / 1000);
+  const defaultPayload = {
+    sub: 'user-123',
+    exp: now + expiresInSeconds,
+    iat: now,
+    aud: 'gameglue-client',
+    iss: 'https://auth.gameglue.gg/realms/GameGlue',
+    scope: 'openid gg:broadcast msfs:read',
+    ...payload
+  };
+
+  const base64Header = Buffer.from(JSON.stringify(header)).toString('base64url');
+  const base64Payload = Buffer.from(JSON.stringify(defaultPayload)).toString('base64url');
+  // Fake signature (not cryptographically valid, but works for decoding tests)
+  const signature = 'fake_signature_for_testing';
+
+  return `${base64Header}.${base64Payload}.${signature}`;
+}
+
+// Valid access token (expires in 1 hour)
+const validAccessToken = createMockJwt({ sub: 'user-123' }, 3600);
+
+// Expired access token
+const expiredAccessToken = createMockJwt({ sub: 'user-123' }, -100);
+
+// Valid refresh token
+const validRefreshToken = createMockJwt({ sub: 'user-123', type: 'refresh' }, 86400);
+
+// Mock user configuration
+const mockConfig = {
+  clientId: 'test-client-id',
+  redirect_uri: 'http://localhost:3000/callback',
+  scopes: ['msfs:read', 'gg:broadcast']
+};
+
+// Mock listener configuration
+const mockListenerConfig = {
+  gameId: 'msfs',
+  userId: 'user-123',
+  fields: ['altitude', 'airspeed', 'heading']
+};
+
+// Mock socket instance
+function createMockSocket() {
+  const eventHandlers = {};
+  const ioEventHandlers = {};
+
+  return {
+    auth: { token: null },
+    connected: true,
+    on: jest.fn((event, handler) => {
+      eventHandlers[event] = handler;
+    }),
+    emit: jest.fn((event, data, callback) => {
+      // Simulate successful responses
+      if (callback) {
+        if (event === 'listen') {
+          callback(null, { status: 'success' });
+        } else if (event === 'listen-update') {
+          callback(null, { status: 'success' });
+        } else if (event === 'set') {
+          callback(null, { status: 'success' });
+        } else {
+          callback(null, { status: 'success' });
+        }
+      }
+    }),
+    timeout: jest.fn(function() {
+      return this;
+    }),
+    disconnect: jest.fn(),
+    io: {
+      on: jest.fn((event, handler) => {
+        ioEventHandlers[event] = handler;
+      })
+    },
+    // Helpers for tests to trigger events
+    _trigger: (event, data) => {
+      if (eventHandlers[event]) {
+        eventHandlers[event](data);
+      }
+    },
+    _triggerIo: (event, data) => {
+      if (ioEventHandlers[event]) {
+        ioEventHandlers[event](data);
+      }
+    },
+    _getHandler: (event) => eventHandlers[event],
+    _getIoHandler: (event) => ioEventHandlers[event]
+  };
+}
+
+module.exports = {
+  createMockJwt,
+  validAccessToken,
+  expiredAccessToken,
+  validRefreshToken,
+  mockConfig,
+  mockListenerConfig,
+  createMockSocket
+};

package/src/test/setup.js

@@ -0,0 +1,50 @@
+// Jest setup file for GameGlueJS SDK
+
+// Create a proper localStorage mock with internal store
+let localStore = {};
+
+const localStorageMock = {
+  getItem: jest.fn((key) => localStore[key] || null),
+  setItem: jest.fn((key, value) => {
+    localStore[key] = String(value);
+  }),
+  removeItem: jest.fn((key) => {
+    delete localStore[key];
+  }),
+  clear: jest.fn(() => {
+    localStore = {};
+  }),
+  get length() {
+    return Object.keys(localStore).length;
+  },
+  key: jest.fn((i) => Object.keys(localStore)[i] || null)
+};
+
+// Override localStorage on window (jsdom provides window)
+Object.defineProperty(window, 'localStorage', {
+  value: localStorageMock,
+  writable: true
+});
+
+// Also set on global for Node environment
+Object.defineProperty(global, 'localStorage', {
+  value: localStorageMock,
+  writable: true
+});
+
+// Mock window.history.pushState
+window.history.pushState = jest.fn();
+
+// Reset mocks and store before each test
+beforeEach(() => {
+  localStore = {};
+  localStorageMock.getItem.mockClear();
+  localStorageMock.setItem.mockClear();
+  localStorageMock.removeItem.mockClear();
+  localStorageMock.clear.mockClear();
+
+  // Reset window.location.hash using the proper jsdom approach
+  window.location.hash = '';
+
+  jest.clearAllMocks();
+});

package/src/utils.spec.js

@@ -0,0 +1,64 @@
+const { storage, isBrowser } = require('./utils');
+
+describe('utils', () => {
+  describe('isBrowser', () => {
+    it('should return false in Node.js/Jest environment', () => {
+      // In Jest (Node.js), process is defined, so isBrowser returns false
+      const result = isBrowser();
+      expect(result).toBe(false);
+    });
+
+    it('should return boolean', () => {
+      const result = isBrowser();
+      expect(typeof result).toBe('boolean');
+    });
+  });
+
+  describe('storage', () => {
+    describe('in Node.js environment (isBrowser = false)', () => {
+      // In Jest, isBrowser() returns false, so storage uses in-memory map
+
+      beforeEach(() => {
+        // Clear storage by setting and getting values
+        // The in-memory store persists between tests within a module
+      });
+
+      describe('set', () => {
+        it('should store a value', () => {
+          storage.set('test-key', 'test-value');
+          const result = storage.get('test-key');
+          expect(result).toBe('test-value');
+        });
+
+        it('should handle various value types', () => {
+          storage.set('string-key', 'string-value');
+          storage.set('number-key', '12345');
+          storage.set('token-key', 'eyJhbGciOiJSUzI1NiJ9.eyJzdWIiOiJ0ZXN0In0.sig');
+
+          expect(storage.get('string-key')).toBe('string-value');
+          expect(storage.get('number-key')).toBe('12345');
+          expect(storage.get('token-key')).toBe('eyJhbGciOiJSUzI1NiJ9.eyJzdWIiOiJ0ZXN0In0.sig');
+        });
+
+        it('should overwrite existing values', () => {
+          storage.set('overwrite-key', 'initial');
+          storage.set('overwrite-key', 'updated');
+          expect(storage.get('overwrite-key')).toBe('updated');
+        });
+      });
+
+      describe('get', () => {
+        it('should retrieve a stored value', () => {
+          storage.set('retrieve-key', 'retrieve-value');
+          const result = storage.get('retrieve-key');
+          expect(result).toBe('retrieve-value');
+        });
+
+        it('should return undefined for non-existent keys', () => {
+          const result = storage.get('definitely-non-existent-key-' + Date.now());
+          expect(result).toBeUndefined();
+        });
+      });
+    });
+  });
+});