rudder-js-sdk/test/e2e/offerJourney.e2e.test.ts

import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import { RudderClient } from '../../src/client/RudderClient.js';
import { createFakeTokenStore } from '../helpers/FakeTokenStore.js';
import { createFakeGateway, type FakeGateway } from '../helpers/fakeGateway.js';
import { stubDeterministicUuid } from '../helpers/memoryPlanStore.js';
import { plan } from '../helpers/plan.js';
import type { NotificationEffect, StoreOfferEffect } from '../../src/index.js';

const MINUTE = 60_000;

function makeClient(): RudderClient {
  return new RudderClient({
    baseUrl: 'https://api.test.rudder.build',
    projectKey: 'test-project',
    tokenStore: createFakeTokenStore(),
    runtime: { planStateStore: null }, // exercised separately in the persistence test
  });
}

/**
 * The offer scenario both branches share:
 *
 *   login → wait 1m → offer ──onDecline──→ wait 1m → "still available"
 *                            └─onPurchase─→ "thanks for your purchase"
 */
function offerScenario() {
  return plan('offer_flow')
    .node('wait_intro', 'wait', { duration: 1, unit: 'minutes' })
    .node('offer', 'store', { storeSlug: 'starter', offerId: 'pack_1', message: 'Limited starter pack!' })
    .node('wait_reminder', 'wait', { duration: 1, unit: 'minutes' })
    .node('reminder', 'notification', { message: 'Your offer is still available!' })
    .node('thanks', 'notification', { message: 'Thanks for your purchase!' })
    .edge('wait_intro', 'onComplete', 'offer')
    .edge('offer', 'onDecline', 'wait_reminder')
    .edge('wait_reminder', 'onComplete', 'reminder')
    .edge('offer', 'onPurchase', 'thanks')
    .build();
}

describe('E2E: player offer journey', () => {
  let gateway: FakeGateway;
  let client: RudderClient;

  beforeEach(() => {
    stubDeterministicUuid();
    vi.useFakeTimers();
    gateway = createFakeGateway({
      stores: [{
        slug: 'starter',
        name: 'Starter',
        offers: [{ id: 'pack_1', name: 'Starter Pack' }],
      }],
    });
    gateway.install();
    client = makeClient();
  });

  afterEach(() => {
    vi.useRealTimers();
    vi.unstubAllGlobals();
  });

  it('authenticates the device and persists tokens for later calls', async () => {
    const res = await client.auth.loginWithDevice({ region: 'eu', language: 'en' });

    expect(res.accessToken).toBeTruthy();
    expect(client.options.tokenStore.getAccessToken()).toBe(res.accessToken);

    // The login request carried the project key + a device id.
    const login = gateway.recorded.find((r) => r.path === '/sdk/v1/authorization/device');
    expect(login?.body).toMatchObject({ key: 'test-project', region: 'eu', language: 'en' });
    expect((login?.body as { deviceId?: string }).deviceId).toBeTruthy();

    // The post-login runtime trigger carries the bearer token.
    const trigger = gateway.recorded.find((r) => r.path === '/sdk/v1/scenarios/trigger');
    expect(trigger?.authToken).toBe(res.accessToken);
  });

  it('offer appears after 1 min, player declines, reminder fires 1 min later', async () => {
    gateway.onEvent('player_login', offerScenario());

    const notifications: NotificationEffect[] = [];
    let offer: StoreOfferEffect | undefined;
    client.effects.onStoreOffer((effect) => { offer = effect; });
    client.effects.onNotification((effect) => { notifications.push(effect); });

    await client.auth.loginWithDevice();

    // Immediately after login the player is just waiting — no offer yet.
    expect(offer).toBeUndefined();

    // The offer must NOT appear before the full minute has elapsed...
    await vi.advanceTimersByTimeAsync(MINUTE - 1_000);
    expect(offer).toBeUndefined();

    // ...and surfaces exactly when the minute is up.
    await vi.advanceTimersByTimeAsync(1_000);
    await vi.waitFor(() => expect(offer).toBeDefined());
    expect(offer!.message).toBe('Limited starter pack!');

    // Player declines → the DAG moves to the reminder wait, no notification yet.
    await offer!.dismiss();
    expect(notifications).toHaveLength(0);

    // The reminder also honours the full minute, not a moment sooner.
    await vi.advanceTimersByTimeAsync(MINUTE - 1_000);
    expect(notifications).toHaveLength(0);
    await vi.advanceTimersByTimeAsync(1_000);
    expect(notifications).toHaveLength(1);
    expect(notifications[0].message).toBe('Your offer is still available!');
  });

  it('offer appears, player buys → "thanks" branch, and the purchase transacts', async () => {
    gateway.onEvent('player_login', offerScenario());

    let offer: StoreOfferEffect | undefined;
    const notifications: NotificationEffect[] = [];
    client.effects.onStoreOffer((effect) => { offer = effect; });
    client.effects.onNotification((effect) => { notifications.push(effect); });

    const accessToken = (await client.auth.loginWithDevice()).accessToken;
    await vi.advanceTimersByTimeAsync(MINUTE);
    await vi.waitFor(() => expect(offer).toBeDefined());

    // The game buys a selected offer; the session advances only after success.
    const selectedOffer = offer!.offers[0];
    const purchase = await offer!.buy(selectedOffer, { idempotencyKey: 'idem-key-123' });
    expect(purchase.success).toBe(true);

    // The purchase hit the gateway with idempotency key + bearer token.
    expect(gateway.purchases).toEqual([
      { storeSlug: 'starter', offerId: 'pack_1', idempotencyKey: 'idem-key-123', authToken: accessToken },
    ]);

    // The scenario took the onPurchase branch → "thanks", and the run finished.
    expect(notifications).toHaveLength(1);
    expect(notifications[0].message).toBe('Thanks for your purchase!');
  });

  it('declining does NOT take the purchase branch (handles are isolated)', async () => {
    gateway.onEvent('player_login', offerScenario());
    const messages: string[] = [];
    let offer: StoreOfferEffect | undefined;
    client.effects.onStoreOffer((effect) => { offer = effect; });
    client.effects.onNotification((effect) => { messages.push(effect.message); });

    await client.auth.loginWithDevice();
    await vi.advanceTimersByTimeAsync(MINUTE);
    await vi.waitFor(() => expect(offer).toBeDefined());
    await offer!.dismiss();
    await vi.advanceTimersByTimeAsync(MINUTE);

    expect(messages).toEqual(['Your offer is still available!']);
    expect(messages).not.toContain('Thanks for your purchase!');
    expect(gateway.purchases).toHaveLength(0);
  });
});