packages/chargebee/src/chargebee.test.ts

   1 import type { ChargebeeInstanceConfiguration } from '../lib';
   2 import { createChargebee, getChargebeeInstance, isChargebeeLoaded, pollUntilLoaded, resetChargebee } from './chargebee';
   3
   4 beforeEach(() => {
   5     (global as any).Chargebee = {
   6         init: jest.fn().mockReturnValue({
   7             chargebeeMock: true,
   8         }),
   9     };
  10
  11     resetChargebee();
  12 });
  13
  14 it('should create instance', () => {
  15     const config: ChargebeeInstanceConfiguration = {
  16         publishableKey: 'pk_test_123',
  17         site: 'test-site',
  18         domain: 'proton.me',
  19     };
  20     const result = createChargebee(config);
  21     expect(result).toEqual({ chargebeeMock: true });
  22     expect((global as any).Chargebee.init).toHaveBeenCalledWith(config);
  23 });
  24
  25 it('should save instance', () => {
  26     const config: ChargebeeInstanceConfiguration = {
  27         publishableKey: 'pk_test_123',
  28         site: 'test-site',
  29         domain: 'proton.me',
  30     };
  31     const result = createChargebee(config);
  32
  33     expect(getChargebeeInstance()).toEqual(result);
  34     expect(getChargebeeInstance()).toEqual({
  35         chargebeeMock: true,
  36     });
  37 });
  38
  39 it('should throw error if not initialized', () => {
  40     expect(() => getChargebeeInstance()).toThrow();
  41 });
  42
  43 describe('isChargebeeLoaded', () => {
  44     it('should return true when Chargebee is loaded', () => {
  45         (global as any).Chargebee = {};
  46         expect(isChargebeeLoaded()).toBe(true);
  47     });
  48
  49     it('should return false when Chargebee is not loaded', () => {
  50         (global as any).Chargebee = undefined;
  51         expect(isChargebeeLoaded()).toBe(false);
  52     });
  53 });
  54
  55 describe('pollUntilLoaded', () => {
  56     beforeEach(() => {
  57         jest.clearAllMocks();
  58         jest.useFakeTimers();
  59     });
  60
  61     afterEach(() => {
  62         jest.useRealTimers();
  63     });
  64
  65     it('should resolve when Chargebee is loaded', async () => {
  66         (global as any).Chargebee = {};
  67
  68         const promise = pollUntilLoaded();
  69         await jest.runAllTimersAsync();
  70
  71         await expect(promise).resolves.toBeUndefined();
  72     });
  73
  74     it('should wait and resolve when Chargebee is loaded after some time', async () => {
  75         delete (global as any).Chargebee;
  76         let resolved = false; // Flag to track promise resolution
  77         const promise = pollUntilLoaded().then(() => {
  78             resolved = true;
  79         }); // Set flag when resolved
  80
  81         await jest.advanceTimersByTimeAsync(20000);
  82
  83         // Check that the promise has not resolved yet
  84         expect(resolved).toBe(false); // This line checks that the promise is still pending
  85
  86         (global as any).Chargebee = {};
  87         await jest.advanceTimersByTimeAsync(1000);
  88
  89         await expect(promise).resolves.toBeUndefined();
  90     });
  91
  92     it('should throw an error when Chargebee did not load', async () => {
  93         delete (global as any).Chargebee;
  94         const promise = pollUntilLoaded();
  95
  96         let reason: any;
  97         promise.catch((error) => {
  98             reason = error;
  99         });
 100
 101         await jest.runAllTimersAsync();
 102
 103         expect(reason).toEqual(new Error('Chargebee did not load'));
 104     });
 105 });