edmand46
265 lines
9.4 KiB
TypeScript
265 lines
9.4 KiB
TypeScript
import { vi } from 'vitest';
|
|
import type { PendingEffect } from '../../src/generated/scenarios.js';
|
|
import type { RemoteConfig } from '../../src/generated/remote-config.js';
|
|
import type { Store } from '../../src/generated/stores.js';
|
|
import type { StorageItem } from '../../src/generated/storage.js';
|
|
import type {
|
|
ClaimQuestResponse,
|
|
ListQuestsResponse,
|
|
} from '../../src/generated/quests.js';
|
|
|
|
export interface RecordedRequest {
|
|
method: string;
|
|
path: string;
|
|
query: URLSearchParams;
|
|
body: unknown;
|
|
authToken: string | null;
|
|
}
|
|
|
|
export interface FakeGatewayState {
|
|
scenarios: Map<string, PendingEffect[]>;
|
|
callbacks: Map<string, PendingEffect | null>;
|
|
callbackErrors: Map<string, { status: number; code?: string }>;
|
|
pendingEffects: PendingEffect[];
|
|
counterCompleted: boolean;
|
|
counterEffect?: PendingEffect;
|
|
remoteConfigs: Record<string, RemoteConfig>;
|
|
stores: Store[];
|
|
quests: ListQuestsResponse;
|
|
questClaims: Map<string, ClaimQuestResponse>;
|
|
storage: Map<string, StorageItem>;
|
|
}
|
|
|
|
export interface FakeGateway {
|
|
state: FakeGatewayState;
|
|
recorded: RecordedRequest[];
|
|
purchases: Array<{ storeSlug: string; offerSlug: string; idempotencyKey: string; authToken: string | null }>;
|
|
questClaims: Array<{ questSlug: string; authToken: string | null }>;
|
|
install(): void;
|
|
onEvent(event: string, ...effects: PendingEffect[]): void;
|
|
onCallback(nodeId: string, handle: string, next: PendingEffect | null): void;
|
|
onCallbackError(nodeId: string, handle: string, status?: number, code?: string): void;
|
|
}
|
|
|
|
function json(body: unknown, status = 200): Response {
|
|
return new Response(JSON.stringify(body), {
|
|
status,
|
|
headers: { 'Content-Type': 'application/json' },
|
|
});
|
|
}
|
|
|
|
const noContent = (): Response => new Response(null, { status: 204 });
|
|
|
|
function replaceRun(pending: PendingEffect[], next: PendingEffect[]): PendingEffect[] {
|
|
const runIds = new Set(next.map((effect) => effect.runId));
|
|
return [...pending.filter((effect) => !runIds.has(effect.runId)), ...next];
|
|
}
|
|
|
|
export function createFakeGateway(seed?: Partial<FakeGatewayState>): FakeGateway {
|
|
const state: FakeGatewayState = {
|
|
scenarios: seed?.scenarios ?? new Map(),
|
|
callbacks: seed?.callbacks ?? new Map(),
|
|
callbackErrors: seed?.callbackErrors ?? new Map(),
|
|
pendingEffects: seed?.pendingEffects ?? [],
|
|
counterCompleted: seed?.counterCompleted ?? false,
|
|
counterEffect: seed?.counterEffect,
|
|
remoteConfigs: seed?.remoteConfigs ?? {},
|
|
stores: seed?.stores ?? [],
|
|
quests: seed?.quests ?? { quests: [] },
|
|
questClaims: seed?.questClaims ?? new Map(),
|
|
storage: seed?.storage ?? new Map(),
|
|
};
|
|
|
|
const recorded: RecordedRequest[] = [];
|
|
const purchases: FakeGateway['purchases'] = [];
|
|
const questClaims: FakeGateway['questClaims'] = [];
|
|
|
|
function advanceExpiredWaits(): PendingEffect[] {
|
|
const now = Date.now();
|
|
const next: PendingEffect[] = [];
|
|
for (const effect of state.pendingEffects) {
|
|
if (
|
|
effect.type === 'wait' &&
|
|
effect.waitDeadline &&
|
|
Date.parse(effect.waitDeadline) <= now
|
|
) {
|
|
const continued = state.callbacks.get(`${effect.nodeId}:onComplete`);
|
|
if (continued === undefined) {
|
|
next.push(effect);
|
|
} else if (continued !== null) {
|
|
next.push(continued);
|
|
}
|
|
} else {
|
|
next.push(effect);
|
|
}
|
|
}
|
|
state.pendingEffects = next;
|
|
return next;
|
|
}
|
|
|
|
async function handle(req: RecordedRequest): Promise<Response> {
|
|
const { method, path, query, body } = req;
|
|
|
|
if (method === 'POST' && path === '/sdk/v1/authorization/device') {
|
|
const b = body as { deviceId?: string };
|
|
return json({
|
|
accessToken: `access-${b.deviceId ?? 'dev'}`,
|
|
refreshToken: `refresh-${b.deviceId ?? 'dev'}`,
|
|
});
|
|
}
|
|
|
|
if (method === 'GET' && path === '/sdk/v1/player/information') {
|
|
return json({ player: null, wallets: [] });
|
|
}
|
|
|
|
if (method === 'GET' && path === '/sdk/v1/sync') {
|
|
return json({});
|
|
}
|
|
|
|
if (method === 'GET' && path === '/sdk/v1/catalog') {
|
|
return json({ items: [] });
|
|
}
|
|
|
|
if (method === 'POST' && path === '/sdk/v1/scenarios/trigger') {
|
|
const event = (body as { event?: string }).event ?? '';
|
|
const effects = state.scenarios.get(event) ?? [];
|
|
state.pendingEffects = replaceRun(state.pendingEffects, effects);
|
|
return json({ effects });
|
|
}
|
|
if (method === 'GET' && path === '/sdk/v1/scenarios/pending') {
|
|
return json({ effects: advanceExpiredWaits() });
|
|
}
|
|
if (method === 'POST' && path === '/sdk/v1/scenarios/callback') {
|
|
const b = body as { nodeId?: string; handle?: string; runId?: string };
|
|
const key = `${b.nodeId}:${b.handle}`;
|
|
const err = state.callbackErrors.get(key);
|
|
if (err) {
|
|
return json({ code: err.code ?? 'callback failed', error: 'callback failed' }, err.status);
|
|
}
|
|
const next = state.callbacks.get(key);
|
|
state.pendingEffects = state.pendingEffects.filter(
|
|
(effect) => !(effect.nodeId === b.nodeId && effect.runId === (b.runId ?? effect.runId)),
|
|
);
|
|
if (next) {
|
|
state.pendingEffects = replaceRun(state.pendingEffects, [next]);
|
|
return json({ effect: next });
|
|
}
|
|
return json({});
|
|
}
|
|
if (method === 'POST' && path === '/sdk/v1/scenarios/counter') {
|
|
if (state.counterCompleted && state.counterEffect) {
|
|
state.pendingEffects = replaceRun(state.pendingEffects, [state.counterEffect]);
|
|
} else if (state.counterCompleted) {
|
|
const b = body as { nodeId?: string; runId?: string };
|
|
state.pendingEffects = state.pendingEffects.filter(
|
|
(effect) => !(effect.nodeId === b.nodeId && effect.runId === (b.runId ?? effect.runId)),
|
|
);
|
|
}
|
|
return json({ completed: state.counterCompleted, effect: state.counterEffect });
|
|
}
|
|
|
|
if (method === 'GET' && path === '/sdk/v1/remote-configs') {
|
|
return json({ configs: state.remoteConfigs });
|
|
}
|
|
if (method === 'GET' && path.startsWith('/sdk/v1/remote-configs/')) {
|
|
const key = decodeURIComponent(path.slice('/sdk/v1/remote-configs/'.length));
|
|
const cfg = state.remoteConfigs[key];
|
|
return cfg ? json(cfg) : json({ error: 'not found' }, 404);
|
|
}
|
|
|
|
if (method === 'GET' && path === '/sdk/v1/stores') {
|
|
return json({ stores: state.stores, total: state.stores.length });
|
|
}
|
|
const purchaseMatch = path.match(/^\/sdk\/v1\/stores\/([^/]+)\/offers\/([^/]+)\/purchase$/);
|
|
if (method === 'POST' && purchaseMatch) {
|
|
const b = body as { idempotencyKey?: string };
|
|
purchases.push({
|
|
storeSlug: decodeURIComponent(purchaseMatch[1]),
|
|
offerSlug: decodeURIComponent(purchaseMatch[2]),
|
|
idempotencyKey: b.idempotencyKey ?? '',
|
|
authToken: req.authToken,
|
|
});
|
|
return json({ success: true, purchaseId: `purchase-${purchases.length}` });
|
|
}
|
|
const storeMatch = path.match(/^\/sdk\/v1\/stores\/([^/]+)$/);
|
|
if (method === 'GET' && storeMatch) {
|
|
const slug = decodeURIComponent(storeMatch[1]);
|
|
const store = state.stores.find((s) => s.slug === slug);
|
|
return store ? json(store) : json({ error: 'not found' }, 404);
|
|
}
|
|
|
|
if (method === 'POST' && path === '/sdk/v1/quests/list') {
|
|
return json(state.quests);
|
|
}
|
|
if (method === 'POST' && path === '/sdk/v1/quests/claim') {
|
|
const b = body as { questSlug?: string };
|
|
const questSlug = b.questSlug ?? '';
|
|
questClaims.push({ questSlug, authToken: req.authToken });
|
|
return json(state.questClaims.get(questSlug) ?? { success: false, error: 'not found' });
|
|
}
|
|
|
|
if (path === '/sdk/v1/storage') {
|
|
if (method === 'GET') {
|
|
const typeFilter = query.get('types');
|
|
const items = [...state.storage.values()].filter(
|
|
(it) => !typeFilter || it.type === typeFilter,
|
|
);
|
|
return json({ items, nextCursor: '' });
|
|
}
|
|
if (method === 'PUT') {
|
|
const items = (body as { items?: StorageItem[] }).items ?? [];
|
|
for (const item of items) {
|
|
if (item.id) state.storage.set(item.id, item);
|
|
}
|
|
return noContent();
|
|
}
|
|
if (method === 'DELETE') {
|
|
const type = query.get('type');
|
|
for (const [id, item] of state.storage) {
|
|
if (!type || item.type === type) state.storage.delete(id);
|
|
}
|
|
return noContent();
|
|
}
|
|
}
|
|
|
|
return json({ error: `unhandled route: ${method} ${path}` }, 500);
|
|
}
|
|
|
|
function install(): void {
|
|
vi.stubGlobal(
|
|
'fetch',
|
|
vi.fn(async (input: string | URL, init?: RequestInit): Promise<Response> => {
|
|
const url = new URL(typeof input === 'string' ? input : input.toString());
|
|
const headers = new Headers(init?.headers);
|
|
const auth = headers.get('Authorization');
|
|
const req: RecordedRequest = {
|
|
method: (init?.method ?? 'GET').toUpperCase(),
|
|
path: url.pathname,
|
|
query: url.searchParams,
|
|
body: init?.body ? JSON.parse(init.body as string) : undefined,
|
|
authToken: auth ? auth.replace(/^Bearer\s+/, '') : null,
|
|
};
|
|
recorded.push(req);
|
|
return handle(req);
|
|
}),
|
|
);
|
|
}
|
|
|
|
return {
|
|
state,
|
|
recorded,
|
|
purchases,
|
|
questClaims,
|
|
install,
|
|
onEvent(event, ...effects) {
|
|
state.scenarios.set(event, effects);
|
|
},
|
|
onCallback(nodeId, handle, next) {
|
|
state.callbacks.set(`${nodeId}:${handle}`, next);
|
|
},
|
|
onCallbackError(nodeId, handle, status = 500, code) {
|
|
state.callbackErrors.set(`${nodeId}:${handle}`, { status, code });
|
|
},
|
|
};
|
|
}
|