daily-notification-plugin/tests/advanced-scenarios.test.ts

import { describe, it, expect, beforeEach, jest } from '@jest/globals';
import { DailyNotificationPlugin, NotificationEvent } from '../src/definitions';
import { DailyNotification } from '../src/daily-notification';

describe('DailyNotification Advanced Scenarios', () => {
  let plugin: DailyNotification;
  let mockPlugin: jest.Mocked<DailyNotificationPlugin>;

  beforeEach(() => {
    mockPlugin = {
      scheduleDailyNotification: jest.fn(),
      getLastNotification: jest.fn(),
      cancelAllNotifications: jest.fn(),
      getNotificationStatus: jest.fn(),
      updateSettings: jest.fn(),
      checkPermissions: jest.fn(),
      requestPermissions: jest.fn(),
    };
    plugin = new DailyNotification(mockPlugin);
  });

  describe('Multiple Schedules', () => {
    it('should handle multiple notification schedules', async () => {
      const schedules = [
        { time: '09:00', title: 'Morning Update' },
        { time: '12:00', title: 'Lunch Update' },
        { time: '18:00', title: 'Evening Update' },
      ];

      for (const schedule of schedules) {
        await plugin.scheduleDailyNotification({
          url: 'https://api.example.com/updates',
          time: schedule.time,
          title: schedule.title,
        });
      }

      expect(mockPlugin.scheduleDailyNotification).toHaveBeenCalledTimes(3);
      expect(mockPlugin.scheduleDailyNotification).toHaveBeenCalledWith(
        expect.objectContaining({
          time: '09:00',
          title: 'Morning Update',
        })
      );
    });

    it('should handle schedule conflicts', async () => {
      await plugin.scheduleDailyNotification({
        url: 'https://api.example.com/updates',
        time: '09:00',
      });

      await expect(
        plugin.scheduleDailyNotification({
          url: 'https://api.example.com/updates',
          time: '09:00',
        })
      ).rejects.toThrow('Notification already scheduled for this time');
    });
  });

  describe('Timezone Handling', () => {
    it('should handle timezone changes', async () => {
      const options = {
        url: 'https://api.example.com/updates',
        time: '09:00',
        timezone: 'America/New_York',
      };

      await plugin.scheduleDailyNotification(options);
      expect(mockPlugin.scheduleDailyNotification).toHaveBeenCalledWith(
        expect.objectContaining({
          timezone: 'America/New_York',
        })
      );
    });

    it('should handle invalid timezone', async () => {
      await expect(
        plugin.scheduleDailyNotification({
          url: 'https://api.example.com/updates',
          time: '09:00',
          timezone: 'Invalid/Timezone',
        })
      ).rejects.toThrow('Invalid timezone');
    });
  });

  describe('Offline Support', () => {
    it('should handle offline scenarios', async () => {
      const options = {
        url: 'https://api.example.com/updates',
        time: '09:00',
        offlineFallback: true,
        cacheDuration: 3600,
      };

      await plugin.scheduleDailyNotification(options);
      expect(mockPlugin.scheduleDailyNotification).toHaveBeenCalledWith(
        expect.objectContaining({
          offlineFallback: true,
          cacheDuration: 3600,
        })
      );
    });

    it('should handle network errors gracefully', async () => {
      mockPlugin.getLastNotification.mockRejectedValueOnce(
        new Error('Network error')
      );

      await expect(plugin.getLastNotification()).rejects.toThrow('Network error');
    });
  });

  describe('Retry Logic', () => {
    it('should implement retry with exponential backoff', async () => {
      const options = {
        url: 'https://api.example.com/updates',
        time: '09:00',
        retryCount: 3,
        retryInterval: 1000,
      };

      await plugin.scheduleDailyNotification(options);
      expect(mockPlugin.scheduleDailyNotification).toHaveBeenCalledWith(
        expect.objectContaining({
          retryCount: 3,
          retryInterval: 1000,
        })
      );
    });

    it('should handle max retries exceeded', async () => {
      mockPlugin.getLastNotification.mockRejectedValueOnce(
        new Error('Max retries exceeded')
      );

      await expect(plugin.getLastNotification()).rejects.toThrow(
        'Max retries exceeded'
      );
    });
  });

  describe('Event Handling', () => {
    it('should handle notification events', async () => {
      const event = new Event('notification') as NotificationEvent;
      event.detail = {
        id: 'test-id',
        action: 'click',
        data: { url: 'https://example.com' },
      };

      const handler = jest.fn();
      plugin.on('notification', handler);
      document.dispatchEvent(event);

      expect(handler).toHaveBeenCalledWith(event);
    });

    it('should handle multiple event listeners', async () => {
      const event = new Event('notification') as NotificationEvent;
      event.detail = {
        id: 'test-id',
        action: 'click',
      };

      const handler1 = jest.fn();
      const handler2 = jest.fn();
      plugin.on('notification', handler1);
      plugin.on('notification', handler2);
      document.dispatchEvent(event);

      expect(handler1).toHaveBeenCalledWith(event);
      expect(handler2).toHaveBeenCalledWith(event);
    });
  });

  describe('Settings Management', () => {
    it('should handle settings updates', async () => {
      const settings = {
        time: '10:00',
        sound: true,
        priority: 'high' as const,
        timezone: 'America/New_York',
      };

      await plugin.updateSettings(settings);
      expect(mockPlugin.updateSettings).toHaveBeenCalledWith(settings);
    });

    it('should validate settings before update', async () => {
      await expect(
        plugin.updateSettings({
          time: 'invalid-time',
          sound: true,
        })
      ).rejects.toThrow('Invalid time format');
    });
  });
});