react-broadcast-sync 1.5.1 → 1.8.0

package/src/tests/BroadcastProvider.test.tsx

@@ -1,163 +0,0 @@
-import { render, screen, act } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import { BroadcastProvider, useBroadcastProvider } from '../BroadcastProvider';
-
-// Mock BroadcastChannel
-let mockChannels: any[] = [];
-
-class MockBroadcastChannel {
-  name: string;
-  onmessage: ((event: MessageEvent) => void) | null = null;
-  postMessage = jest.fn();
-  close = jest.fn();
-  addEventListener = jest.fn((event: string, callback: (event: MessageEvent) => void) => {
-    if (event === 'message') {
-      this.onmessage = callback;
-    }
-  });
-  removeEventListener = jest.fn();
-
-  constructor(name: string) {
-    this.name = name;
-    mockChannels.push(this);
-  }
-
-  simulateMessage(data: any) {
-    if (this.onmessage) {
-      this.onmessage({ data } as MessageEvent);
-    }
-  }
-}
-
-// Test component that uses the provider
-const TestComponent = () => {
-  const { messages, error } = useBroadcastProvider();
-  return (
-    <div>
-      <div data-testid="error">{error}</div>
-      <div data-testid="messages">
-        {messages.map(msg => (
-          <div key={msg.id} data-testid={`message-${msg.id}`}>
-            {msg.message.text}
-          </div>
-        ))}
-      </div>
-    </div>
-  );
-};
-
-describe('BroadcastProvider', () => {
-  beforeEach(() => {
-    mockChannels = [];
-    global.BroadcastChannel = MockBroadcastChannel as any;
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('creates a broadcast channel with the provided name', () => {
-    render(
-      <BroadcastProvider channelName="test-channel">
-        <TestComponent />
-      </BroadcastProvider>
-    );
-
-    // The provider creates two channels - one in the provider and one in useBroadcastChannel
-    expect(mockChannels).toHaveLength(2);
-    expect(mockChannels[0].name).toBe('test-channel');
-    expect(mockChannels[1].name).toBe('test-channel');
-  });
-
-  it('provides context values to children', () => {
-    render(
-      <BroadcastProvider channelName="test-channel">
-        <TestComponent />
-      </BroadcastProvider>
-    );
-
-    expect(screen.getByTestId('error')).toHaveTextContent('');
-    expect(screen.getByTestId('messages')).toBeEmptyDOMElement();
-  });
-
-  it('handles messages through the provider', () => {
-    render(
-      <BroadcastProvider channelName="test-channel">
-        <TestComponent />
-      </BroadcastProvider>
-    );
-
-    const message = {
-      id: 'test-1',
-      type: 'test',
-      message: { text: 'Hello' },
-      source: 'other-tab',
-      timestamp: Date.now(),
-    };
-
-    act(() => {
-      mockChannels[0].simulateMessage(message);
-    });
-
-    expect(screen.getByTestId('message-test-1')).toHaveTextContent('Hello');
-  });
-
-  it('handles errors when BroadcastChannel is not supported', () => {
-    const originalBroadcastChannel = global.BroadcastChannel;
-    delete (global as any).BroadcastChannel;
-
-    render(
-      <BroadcastProvider channelName="test-channel">
-        <TestComponent />
-      </BroadcastProvider>
-    );
-
-    expect(screen.getByTestId('error')).toHaveTextContent(
-      'BroadcastChannel is not supported in this browser. Please check browser compatibility.'
-    );
-
-    // Restore BroadcastChannel for other tests
-    global.BroadcastChannel = originalBroadcastChannel;
-  });
-
-  it('cleans up channel on unmount', () => {
-    const { unmount } = render(
-      <BroadcastProvider channelName="test-channel">
-        <TestComponent />
-      </BroadcastProvider>
-    );
-
-    unmount();
-
-    expect(mockChannels[0].close).toHaveBeenCalled();
-  });
-
-  it('handles error boundary when child component throws', () => {
-    const ThrowComponent = () => {
-      throw new Error('Test error');
-    };
-
-    const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
-
-    render(
-      <BroadcastProvider channelName="test-channel">
-        <ThrowComponent />
-      </BroadcastProvider>
-    );
-
-    expect(screen.getByText('Error occurred in BroadcastProvider')).toBeInTheDocument();
-    expect(consoleError).toHaveBeenCalledWith('BroadcastChannel error:', expect.any(Error));
-
-    consoleError.mockRestore();
-  });
-
-  it('throws error when useBroadcastProvider is used outside provider', () => {
-    const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
-
-    expect(() => {
-      render(<TestComponent />);
-    }).toThrow('useBroadcastProvider must be used within a BroadcastProvider');
-
-    consoleError.mockRestore();
-  });
-});

package/src/tests/debug.test.ts

@@ -1,239 +0,0 @@
-// Set debug mode before requiring the debug module
-process.env.REACT_APP_DEBUG_BROADCAST = 'true';
-import { debug } from '../utils/debug';
-
-describe('debug', () => {
-  const originalEnv = process.env;
-  const originalConsole = {
-    log: console.log,
-    warn: console.warn,
-    error: console.error,
-  };
-
-  beforeEach(() => {
-    process.env = { ...originalEnv };
-    console.log = jest.fn();
-    console.warn = jest.fn();
-    console.error = jest.fn();
-  });
-
-  afterEach(() => {
-    console.log = originalConsole.log;
-    console.warn = originalConsole.warn;
-    console.error = originalConsole.error;
-    process.env = originalEnv;
-  });
-
-  describe('when debug mode is disabled', () => {
-    beforeEach(() => {
-      process.env.REACT_APP_DEBUG_BROADCAST = 'false';
-    });
-
-    it('does not log anything', () => {
-      debug.channel.created('test-channel');
-      debug.message.sent({ id: '123' });
-      debug.error('test error');
-
-      expect(console.log).not.toHaveBeenCalled();
-      expect(console.warn).not.toHaveBeenCalled();
-      expect(console.error).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('when debug mode is enabled', () => {
-    beforeEach(() => {
-      process.env.REACT_APP_DEBUG_BROADCAST = 'true';
-    });
-
-    it('logs channel events', () => {
-      debug.channel.created('test-channel');
-      expect(console.log).toHaveBeenCalledWith(
-        expect.stringMatching(
-          /\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z\] \[react-broadcast-sync\]/
-        ),
-        'Channel created:',
-        'test-channel'
-      );
-
-      debug.channel.closed('test-channel');
-      expect(console.log).toHaveBeenCalledWith(
-        expect.stringMatching(
-          /\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z\] \[react-broadcast-sync\]/
-        ),
-        'Channel closed:',
-        'test-channel'
-      );
-    });
-
-    it('logs message events', () => {
-      const testMessage = { id: '123', type: 'test' };
-
-      debug.message.sent(testMessage);
-      expect(console.log).toHaveBeenCalledWith(
-        expect.stringMatching(
-          /\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z\] \[react-broadcast-sync\]/
-        ),
-        'Message sent:',
-        testMessage
-      );
-
-      debug.message.received(testMessage);
-      expect(console.log).toHaveBeenCalledWith(
-        expect.stringMatching(
-          /\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z\] \[react-broadcast-sync\]/
-        ),
-        'Message received:',
-        testMessage
-      );
-
-      debug.message.cleared('123');
-      expect(console.log).toHaveBeenCalledWith(
-        expect.stringMatching(
-          /\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z\] \[react-broadcast-sync\]/
-        ),
-        'Message cleared:',
-        '123'
-      );
-
-      debug.message.expired('123');
-      expect(console.log).toHaveBeenCalledWith(
-        expect.stringMatching(
-          /\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z\] \[react-broadcast-sync\]/
-        ),
-        'Message expired:',
-        '123'
-      );
-
-      debug.message.duplicate('123');
-      expect(console.warn).toHaveBeenCalledWith(
-        expect.stringMatching(
-          /\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z\] \[react-broadcast-sync\]/
-        ),
-        'Duplicate message ignored:',
-        '123'
-      );
-    });
-
-    it('logs cleanup events', () => {
-      debug.cleanup.started();
-      expect(console.log).toHaveBeenCalledWith(
-        expect.stringMatching(
-          /\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z\] \[react-broadcast-sync\]/
-        ),
-        'Cleanup started',
-        ''
-      );
-
-      debug.cleanup.completed(5);
-      expect(console.log).toHaveBeenCalledWith(
-        expect.stringMatching(
-          /\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z\] \[react-broadcast-sync\]/
-        ),
-        'Cleanup completed:',
-        { removedCount: 5 }
-      );
-    });
-
-    it('logs errors', () => {
-      debug.error('test error');
-      expect(console.error).toHaveBeenCalledWith(
-        expect.stringMatching(
-          /\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z\] \[react-broadcast-sync\]/
-        ),
-        'Error:',
-        'test error'
-      );
-    });
-
-    it('logs info with no data', () => {
-      debug.channel.created('test-channel');
-      expect(console.log).toHaveBeenCalledWith(
-        expect.stringMatching(/\[.*react-broadcast-sync\]/),
-        'Channel created:',
-        'test-channel'
-      );
-    });
-
-    it('logs warn with no data', () => {
-      debug.message.duplicate('123');
-      expect(console.warn).toHaveBeenCalledWith(
-        expect.stringMatching(/\[.*react-broadcast-sync\]/),
-        'Duplicate message ignored:',
-        '123'
-      );
-    });
-
-    it('logs error with no data', () => {
-      debug.error('error!');
-      expect(console.error).toHaveBeenCalledWith(
-        expect.stringMatching(/\[.*react-broadcast-sync\]/),
-        'Error:',
-        'error!'
-      );
-    });
-
-    it('logs message with no data', () => {
-      debug.cleanup.started();
-      expect(console.log).toHaveBeenCalledWith(
-        expect.stringContaining('[react-broadcast-sync]'),
-        'Cleanup started',
-        ''
-      );
-    });
-  });
-
-  describe('when process.env is undefined', () => {
-    beforeEach(() => {
-      // @ts-expect-error - Testing invalid input
-      process.env = undefined;
-    });
-
-    it('does not log anything', () => {
-      debug.channel.created('test-channel');
-      expect(console.log).not.toHaveBeenCalled();
-    });
-  });
-
-  it('logs info messages', () => {
-    debug.channel.created('test-channel');
-    expect(console.log).toHaveBeenCalledWith(
-      expect.stringContaining('[react-broadcast-sync]'),
-      'Channel created:',
-      'test-channel'
-    );
-  });
-
-  it('logs warning messages', () => {
-    debug.message.duplicate('test-id');
-    expect(console.warn).toHaveBeenCalledWith(
-      expect.stringContaining('[react-broadcast-sync]'),
-      'Duplicate message ignored:',
-      'test-id'
-    );
-  });
-
-  it('logs error messages', () => {
-    debug.error('Test error');
-    expect(console.error).toHaveBeenCalledWith(
-      expect.stringContaining('[react-broadcast-sync]'),
-      'Error:',
-      'Test error'
-    );
-  });
-
-  it('logs cleanup information', () => {
-    debug.cleanup.started();
-    expect(console.log).toHaveBeenCalledWith(
-      expect.stringContaining('[react-broadcast-sync]'),
-      'Cleanup started',
-      ''
-    );
-
-    debug.cleanup.completed(2);
-    expect(console.log).toHaveBeenCalledWith(
-      expect.stringContaining('[react-broadcast-sync]'),
-      'Cleanup completed:',
-      { removedCount: 2 }
-    );
-  });
-});

package/src/tests/messageUtils.test.ts

@@ -1,252 +0,0 @@
-import {
-  generateRandomPart,
-  generateSourceName,
-  generateMessageId,
-  isValidMessage,
-  isMessageExpired,
-  createMessage,
-  getInternalMessageType,
-  isInternalType,
-  isValidInternalClearMessage,
-  debounce,
-} from '../utils/messageUtils';
-
-beforeEach(() => {
-  jest.useFakeTimers();
-});
-afterEach(() => {
-  jest.useRealTimers();
-});
-
-describe('messageUtils', () => {
-  it('generateRandomPart returns a non-empty string', () => {
-    const part = generateRandomPart();
-    expect(typeof part).toBe('string');
-    expect(part).toHaveLength(9);
-  });
-
-  it('generateSourceName includes "tab-" prefix', () => {
-    expect(generateSourceName()).toMatch(/^tab-/);
-  });
-
-  it('generateMessageId returns a base64 string', () => {
-    const id = generateMessageId('source-1', Date.now());
-    expect(typeof id).toBe('string');
-    expect(id).toMatch(/^[A-Za-z0-9+/]+={0,2}$/);
-  });
-
-  it('isValidMessage identifies a valid message object', () => {
-    expect(isValidMessage({ id: '123' })).toBe(true);
-    expect(isValidMessage(null)).toBe(false);
-    expect(isValidMessage({})).toBe(false);
-  });
-
-  it('isMessageExpired works correctly', () => {
-    const now = Date.now();
-    expect(isMessageExpired({ expirationDate: now - 1000 })).toBe(true);
-    expect(isMessageExpired({ expirationDate: now + 1000 })).toBe(false);
-    expect(isMessageExpired({})).toBe(false);
-  });
-
-  it('createMessage returns a valid message object', () => {
-    const source = 'tab-abc';
-    const msg = createMessage('type1', { hello: 'world' }, source, { expirationDuration: 1000 });
-    expect(msg).toHaveProperty('id');
-    expect(msg).toHaveProperty('type', 'type1');
-    expect(msg).toHaveProperty('message.hello', 'world');
-    expect(msg).toHaveProperty('source', source);
-    expect(msg.expirationDate).toBeGreaterThan(Date.now());
-  });
-
-  it('createMessage uses provided expirationDate when given', () => {
-    const expirationDate = Date.now() + 5000;
-    const message = createMessage('type', {}, 'source', { expirationDate });
-    expect(message.expirationDate).toBe(expirationDate);
-  });
-
-  it('getInternalMessageType produces unique hashes for different channels', () => {
-    const one = getInternalMessageType('CLEAR_SENT_MESSAGES', 'chanA');
-    const two = getInternalMessageType('CLEAR_SENT_MESSAGES', 'chanB');
-    expect(one).not.toBe(two);
-  });
-
-  it('getInternalMessageType generates consistent hash string', () => {
-    const type = getInternalMessageType('CLEAR_SENT_MESSAGES', 'my-channel', 'ns');
-    expect(type).toContain('__INTERNAL__');
-    expect(type).toContain('CLEAR_SENT_MESSAGES');
-  });
-
-  it('isInternalType detects internal message types', () => {
-    const type = getInternalMessageType('CLEAR_SENT_MESSAGES', 'chan');
-    expect(isInternalType(type)).toBe(true);
-    expect(isInternalType('normal-type')).toBe(false);
-  });
-
-  it('isValidInternalClearMessage detects valid structure', () => {
-    const valid = {
-      id: 'abc',
-      type: getInternalMessageType('CLEAR_SENT_MESSAGES', 'ch'),
-      source: 'tab-1',
-    };
-    const invalid = { id: 123, type: 'bad', source: 'tab-1' };
-    expect(isValidInternalClearMessage(valid)).toBe(true);
-    expect(isValidInternalClearMessage(invalid)).toBe(false);
-  });
-});
-
-describe('debounce', () => {
-  it('debounce delays function call and can cancel/flush', () => {
-    const fn = jest.fn();
-    const debounced = debounce(fn, 100);
-
-    debounced();
-    expect(fn).not.toHaveBeenCalled();
-
-    debounced.flush();
-    expect(fn).toHaveBeenCalled();
-
-    debounced();
-    debounced.cancel();
-    jest.advanceTimersByTime(150);
-    expect(fn).toHaveBeenCalledTimes(1);
-  });
-
-  it('debounce handles multiple calls and preserves this context', () => {
-    const obj = {
-      value: 0,
-      increment: function () {
-        this.value++;
-      },
-    };
-    const debounced = debounce(obj.increment.bind(obj), 100);
-
-    debounced();
-    debounced();
-    debounced.flush();
-    expect(obj.value).toBe(1);
-  });
-
-  it('debounce flush returns undefined when no pending call', () => {
-    const fn = jest.fn();
-    const debounced = debounce(fn, 100);
-
-    expect(debounced.flush()).toBeUndefined();
-    expect(fn).not.toHaveBeenCalled();
-  });
-
-  it('debounce handles function with return value', () => {
-    const fn = jest.fn().mockReturnValue('test');
-    const debounced = debounce(fn, 100);
-
-    debounced();
-    expect(debounced.flush()).toBe('test');
-  });
-
-  it('debounce.cancel cancels the timeout', () => {
-    const fn = jest.fn();
-    const debounced = debounce(fn, 100);
-    debounced();
-    debounced.cancel();
-    jest.advanceTimersByTime(200);
-    expect(fn).not.toHaveBeenCalled();
-  });
-
-  it('debounce.flush executes immediately', () => {
-    const fn = jest.fn();
-    const debounced = debounce(fn, 100);
-    debounced('test');
-    debounced.flush();
-    expect(fn).toHaveBeenCalledWith('test');
-  });
-
-  it('debounce handles multiple calls with different arguments', () => {
-    const fn = jest.fn();
-    const debounced = debounce(fn, 100);
-
-    debounced('first');
-    debounced('second');
-    debounced('third');
-
-    expect(fn).not.toHaveBeenCalled();
-    debounced.flush();
-    expect(fn).toHaveBeenCalledTimes(1);
-    expect(fn).toHaveBeenCalledWith('third');
-  });
-
-  it('debounce handles cancel and flush in sequence', () => {
-    const fn = jest.fn();
-    const debounced = debounce(fn, 100);
-
-    debounced('test');
-    debounced.cancel();
-    expect(debounced.flush()).toBeUndefined();
-    expect(fn).not.toHaveBeenCalled();
-  });
-
-  it('debounce.flush executes the function with latest arguments immediately', () => {
-    jest.useFakeTimers();
-
-    const fn = jest.fn((x: number) => x + 1);
-    const debounced = debounce(fn, 200);
-
-    debounced(41);
-
-    expect(fn).not.toHaveBeenCalled();
-
-    const flushResult = debounced.flush();
-
-    expect(fn).toHaveBeenCalledTimes(1);
-    expect(fn).toHaveBeenCalledWith(41);
-    expect(flushResult).toBe(42);
-
-    jest.useRealTimers();
-  });
-
-  it('debounce.flush does nothing if timeout is set but lastArgs were reset manually', () => {
-    const fn = jest.fn();
-
-    const debounced = debounce(fn, 100);
-
-    // Call once, schedule the debounce
-    debounced('first');
-
-    // Simulate internal cleanup (cannot access lastArgs directly, so instead cancel it)
-    debounced.cancel(); // This will clear lastArgs and lastThis but not call fn
-
-    const result = debounced.flush(); // Should do nothing
-
-    expect(fn).not.toHaveBeenCalled();
-    expect(result).toBeUndefined();
-  });
-
-  it('debounce.flush handles case where timeoutId exists but lastArgs is null', () => {
-    const fn = jest.fn();
-    const debounced = debounce(fn, 100);
-
-    // Schedule a call
-    debounced('test');
-
-    // Force the timeout to be set but clear lastArgs
-    jest.advanceTimersByTime(50); // Advance partially through the timeout
-    debounced.cancel(); // This clears lastArgs but might not clear timeoutId immediately
-
-    // Call flush when timeoutId exists but lastArgs is null
-    const result = debounced.flush();
-    expect(result).toBeUndefined();
-    expect(fn).not.toHaveBeenCalled();
-  });
-
-  it('debounce.flush handles multiple calls with different arguments and preserves return value', () => {
-    const fn = jest.fn((x: number) => x * 2);
-    const debounced = debounce(fn, 100);
-
-    debounced(1);
-    debounced(2);
-    debounced(3);
-
-    const result = debounced.flush();
-    expect(result).toBe(6); // 3 * 2
-    expect(fn).toHaveBeenCalledTimes(1);
-    expect(fn).toHaveBeenCalledWith(3);
-  });
-});