@infosoftas/s4-orders-js-sdk 0.1.21 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (51) hide show
  1. package/.editorconfig +8 -8
  2. package/.release-it.json +10 -10
  3. package/README.md +565 -471
  4. package/package.json +62 -58
  5. package/src/App.completion.test.tsx +738 -0
  6. package/src/App.tsx +753 -639
  7. package/src/ErrorBoundary.tsx +41 -41
  8. package/src/api/InvoiceApi.ts +23 -23
  9. package/src/api/OrdersApi.ts +74 -59
  10. package/src/api/SubscribeApi.ts +18 -18
  11. package/src/bundle.ts +4 -4
  12. package/src/components/Alert/Alert.tsx +23 -23
  13. package/src/components/Button/Button.tsx +39 -39
  14. package/src/components/EHFForm/EHFForm.tsx +253 -253
  15. package/src/components/FormFields/AddressField.tsx +55 -55
  16. package/src/components/FormFields/EmailField.tsx +53 -53
  17. package/src/components/FormFields/FormFields.helper.ts +34 -34
  18. package/src/components/FormFields/FormFieldsMapper.ts +34 -34
  19. package/src/components/FormFields/InputField.tsx +52 -52
  20. package/src/components/FormFields/NameField.tsx +52 -52
  21. package/src/components/FormFields/PhoneField.tsx +53 -53
  22. package/src/components/FormFields/TermsCheckbox.tsx +70 -70
  23. package/src/components/FormFields/ToggleFiled.tsx +52 -52
  24. package/src/components/FormFields/fieldValidators.ts +71 -71
  25. package/src/components/MainIframe/MainIframe.tsx +42 -42
  26. package/src/components/OIOForm/OIOForm.tsx +307 -307
  27. package/src/components/OrderDenialModal/OrderDenialModal.tsx +102 -102
  28. package/src/components/OrderForm/ContactDetailsSection.tsx +71 -71
  29. package/src/components/OrderForm/OrderForm.tsx +420 -420
  30. package/src/components/OrderForm/PaymentMethodContent.tsx +62 -62
  31. package/src/components/OrderForm/PaymentMethodSection.tsx +79 -79
  32. package/src/components/OrderForm/SubmitConfirmationDialog.tsx +55 -55
  33. package/src/components/OrderForm/orderFormState.ts +171 -171
  34. package/src/components/OrderForm/useSlotElement.tsx +89 -89
  35. package/src/constants/index.ts +13 -13
  36. package/src/enums/api.ts +5 -5
  37. package/src/enums/general.ts +40 -40
  38. package/src/hooks/useIframe.tsx +59 -59
  39. package/src/hooks/useMessageEvent.tsx +194 -194
  40. package/src/hooks/useOrderForm.tsx +403 -403
  41. package/src/hooks/useQueryParams.ts +5 -5
  42. package/src/index.tsx +30 -30
  43. package/src/lib/utils.ts +1 -1
  44. package/src/types/api.ts +28 -28
  45. package/src/types/general.ts +154 -136
  46. package/src/types/order.ts +91 -70
  47. package/src/utils/fetcher.ts +131 -113
  48. package/src/utils/helper.ts +78 -78
  49. package/src/utils/order.helper.ts +272 -272
  50. package/src/utils/waitForOrderCompletion.ts +125 -0
  51. package/tsconfig.json +38 -38
@@ -0,0 +1,738 @@
1
+ // @vitest-environment jsdom
2
+
3
+ import {
4
+ act,
5
+ cleanup,
6
+ fireEvent,
7
+ render,
8
+ screen,
9
+ } from '@testing-library/react';
10
+ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
11
+
12
+ import App from './App';
13
+ import { MessageEventTypeEnum } from './enums/general';
14
+ import type { ConfigType } from './types/general';
15
+ import type { OrderInfoType } from './types/order';
16
+
17
+ vi.mock('./components/OrderForm/OrderForm', () => ({
18
+ default: ({
19
+ callback,
20
+ }: {
21
+ callback: (url: string | null, data: OrderInfoType) => void;
22
+ }) => (
23
+ <button
24
+ onClick={() =>
25
+ callback(null, {
26
+ orderId: 'invoice-order',
27
+ paymentMethod: 'Invoice',
28
+ subscriberId: 'subscriber-7',
29
+ })
30
+ }
31
+ >
32
+ Submit invoice
33
+ </button>
34
+ ),
35
+ }));
36
+
37
+ const response = (body: unknown, status = 200, headers?: HeadersInit) =>
38
+ new Response(JSON.stringify(body), { status, headers });
39
+
40
+ const fetchMock = vi.fn<typeof fetch>();
41
+ const settings = {
42
+ successText: 'Order completed',
43
+ failureText: 'Order failed',
44
+ orderProcessingText: 'Processing order',
45
+ orderReceivedText: 'Order received',
46
+ orderDelayedText: 'Order received, taking longer than expected',
47
+ };
48
+
49
+ const renderApp = (props: Partial<ConfigType> = {}) =>
50
+ render(
51
+ <App
52
+ apiKey="tenant-key"
53
+ apiUrl="https://orders.example.test"
54
+ domElementId="sdk-order"
55
+ templatePackageId="template-1"
56
+ subscriberId=""
57
+ userId=""
58
+ identityProviderId=""
59
+ organizationId="organization-1"
60
+ settings={settings}
61
+ {...props}
62
+ />
63
+ );
64
+
65
+ const paymentReturn = () =>
66
+ window.dispatchEvent(
67
+ new MessageEvent('message', {
68
+ data: {
69
+ type: MessageEventTypeEnum.COMPLETE,
70
+ orderId: 'returned-order',
71
+ agreementId: 'agreement-3',
72
+ },
73
+ })
74
+ );
75
+
76
+ const advance = async (ms = 0) => {
77
+ await act(async () => {
78
+ await vi.advanceTimersByTimeAsync(ms);
79
+ });
80
+ };
81
+
82
+ const completionMessages = () =>
83
+ vi
84
+ .mocked(window.postMessage)
85
+ .mock.calls.map(([message]) => message as { type?: string })
86
+ .filter(
87
+ (message) =>
88
+ message.type === MessageEventTypeEnum.ORDER_FLOW_COMPLETE
89
+ );
90
+
91
+ describe('SDK-managed order completion', () => {
92
+ beforeEach(() => {
93
+ vi.useFakeTimers();
94
+ fetchMock.mockReset();
95
+ vi.stubGlobal('fetch', fetchMock);
96
+ window.history.replaceState({}, '', '/');
97
+ sessionStorage.clear();
98
+ localStorage.clear();
99
+ vi.spyOn(window, 'postMessage').mockImplementation(() => undefined);
100
+ vi.spyOn(console, 'log').mockImplementation(() => undefined);
101
+ });
102
+
103
+ afterEach(() => {
104
+ cleanup();
105
+ vi.useRealTimers();
106
+ vi.restoreAllMocks();
107
+ vi.unstubAllGlobals();
108
+ });
109
+
110
+ it('waits for Completed and emits the exact submitted ID after a full redirect', async () => {
111
+ fetchMock
112
+ .mockResolvedValueOnce(
113
+ response({ id: 'returned-order', status: 'InProgress' })
114
+ )
115
+ .mockResolvedValueOnce(
116
+ response({ id: 'returned-order', status: 'InProgress' })
117
+ )
118
+ .mockResolvedValueOnce(
119
+ response({ id: 'returned-order', status: 'Completed' })
120
+ );
121
+ const orderAcceptedCallback = vi.fn();
122
+ renderApp({
123
+ orderAcceptedCallback,
124
+ userId: 'user-9',
125
+ identityProviderId: 'identity-2',
126
+ });
127
+ act(paymentReturn);
128
+ await advance();
129
+
130
+ expect(screen.queryByText('Order completed')).toBeNull();
131
+ expect(screen.getByText('Processing order')).toBeTruthy();
132
+ expect(completionMessages()).toHaveLength(0);
133
+ expect(orderAcceptedCallback).toHaveBeenCalledWith({
134
+ orderId: 'returned-order',
135
+ orderInfo: null,
136
+ });
137
+ expect(fetchMock.mock.calls[0][0]).toBe(
138
+ 'https://orders.example.test/order/returned-order/complete'
139
+ );
140
+ expect(JSON.parse(fetchMock.mock.calls[0][1]?.body as string)).toEqual({
141
+ userId: 'user-9',
142
+ identityProviderId: 'identity-2',
143
+ });
144
+ expect(fetchMock.mock.calls[1][0]).toBe(
145
+ 'https://orders.example.test/order/returned-order'
146
+ );
147
+ expect(
148
+ new Headers(fetchMock.mock.calls[1][1]?.headers).get(
149
+ 'S4-ORDERS-API-KEY'
150
+ )
151
+ ).toBe('tenant-key');
152
+ await advance(499);
153
+ expect(fetchMock).toHaveBeenCalledTimes(2);
154
+ await advance(1);
155
+ expect(screen.getByText('Order completed')).toBeTruthy();
156
+ expect(completionMessages()).toEqual([
157
+ expect.objectContaining({
158
+ orderId: 'returned-order',
159
+ isCompleted: true,
160
+ orderInfo: null,
161
+ }),
162
+ ]);
163
+ });
164
+
165
+ it('shows received-but-delayed at ten seconds without success, resubmission or further reads', async () => {
166
+ fetchMock.mockImplementation(async (_url, init) =>
167
+ response({
168
+ id: 'returned-order',
169
+ status: init?.method === 'POST' ? 'Completed' : 'InProgress',
170
+ })
171
+ );
172
+ const orderCompletionDelayedCallback = vi.fn();
173
+ renderApp({ orderCompletionDelayedCallback });
174
+ act(paymentReturn);
175
+ await advance(9999);
176
+ expect(
177
+ screen.queryByText('Order received, taking longer than expected')
178
+ ).toBeNull();
179
+ await advance(1);
180
+ expect(
181
+ screen.getByText('Order received, taking longer than expected')
182
+ ).toBeTruthy();
183
+ expect(
184
+ screen.queryByRole('button', { name: 'Submit invoice' })
185
+ ).toBeNull();
186
+ expect(orderCompletionDelayedCallback).toHaveBeenCalledExactlyOnceWith({
187
+ orderId: 'returned-order',
188
+ orderInfo: null,
189
+ reason: 'timeout',
190
+ });
191
+ expect(completionMessages()).toHaveLength(0);
192
+ const calls = fetchMock.mock.calls.length;
193
+ await advance(20000);
194
+ act(paymentReturn);
195
+ await advance();
196
+ expect(fetchMock).toHaveBeenCalledTimes(calls);
197
+ });
198
+
199
+ it('bounds a hung status read and ignores its eventual Completed response', async () => {
200
+ let finish!: (value: Response) => void;
201
+ fetchMock.mockResolvedValueOnce(response(null)).mockImplementationOnce(
202
+ () =>
203
+ new Promise((resolve) => {
204
+ finish = resolve;
205
+ })
206
+ );
207
+ const orderCompletionDelayedCallback = vi.fn();
208
+ renderApp({ orderCompletionDelayedCallback });
209
+ act(paymentReturn);
210
+ await advance();
211
+ await advance(10000);
212
+ expect(
213
+ screen.getByText('Order received, taking longer than expected')
214
+ ).toBeTruthy();
215
+ expect(fetchMock).toHaveBeenCalledTimes(2);
216
+ expect(fetchMock.mock.calls[1][1]?.signal?.aborted).toBe(true);
217
+ await act(async () => {
218
+ finish(response({ id: 'returned-order', status: 'Completed' }));
219
+ });
220
+ expect(screen.queryByText('Order completed')).toBeNull();
221
+ expect(orderCompletionDelayedCallback).toHaveBeenCalledOnce();
222
+ expect(completionMessages()).toHaveLength(0);
223
+ });
224
+
225
+ it('lets external mode receive acceptance without polling or announcing success', async () => {
226
+ fetchMock.mockResolvedValueOnce(response(null));
227
+ const orderAcceptedCallback = vi.fn();
228
+ renderApp({ completionMode: 'external', orderAcceptedCallback });
229
+ act(paymentReturn);
230
+ await advance(20000);
231
+ expect(orderAcceptedCallback).toHaveBeenCalledExactlyOnceWith({
232
+ orderId: 'returned-order',
233
+ orderInfo: null,
234
+ });
235
+ expect(screen.getByText('Order received')).toBeTruthy();
236
+ expect(screen.queryByText('Order completed')).toBeNull();
237
+ expect(fetchMock).toHaveBeenCalledTimes(1);
238
+ expect(completionMessages()).toHaveLength(0);
239
+ });
240
+
241
+ it.each(['Cancelled', 'Rejected'])(
242
+ 'reports %s without success or reopening submission',
243
+ async (status) => {
244
+ fetchMock
245
+ .mockResolvedValueOnce(response(null))
246
+ .mockResolvedValueOnce(
247
+ response({ id: 'returned-order', status })
248
+ );
249
+ const orderCompletionFailedCallback = vi.fn();
250
+ renderApp({ orderCompletionFailedCallback });
251
+ act(paymentReturn);
252
+ await advance(10000);
253
+ expect(screen.getByText('Order failed')).toBeTruthy();
254
+ expect(
255
+ screen.queryByRole('button', { name: 'Submit invoice' })
256
+ ).toBeNull();
257
+ expect(
258
+ orderCompletionFailedCallback
259
+ ).toHaveBeenCalledExactlyOnceWith({
260
+ orderId: 'returned-order',
261
+ orderInfo: null,
262
+ status,
263
+ });
264
+ expect(fetchMock).toHaveBeenCalledTimes(2);
265
+ expect(completionMessages()).toHaveLength(0);
266
+ }
267
+ );
268
+
269
+ it('does not overlap reads or repeat POST for duplicate payment returns', async () => {
270
+ let finish!: (value: Response) => void;
271
+ fetchMock
272
+ .mockResolvedValueOnce(response(null))
273
+ .mockImplementationOnce(
274
+ () =>
275
+ new Promise((resolve) => {
276
+ finish = resolve;
277
+ })
278
+ )
279
+ .mockResolvedValueOnce(
280
+ response({ id: 'returned-order', status: 'Completed' })
281
+ );
282
+ renderApp();
283
+ act(() => {
284
+ paymentReturn();
285
+ paymentReturn();
286
+ });
287
+ await advance(1500);
288
+ expect(fetchMock).toHaveBeenCalledTimes(2);
289
+ await act(async () => {
290
+ finish(response({ id: 'returned-order', status: 'InProgress' }));
291
+ });
292
+ await advance(499);
293
+ expect(fetchMock).toHaveBeenCalledTimes(2);
294
+ await advance(1);
295
+ expect(screen.getByText('Order completed')).toBeTruthy();
296
+ act(paymentReturn);
297
+ await advance();
298
+ expect(fetchMock).toHaveBeenCalledTimes(3);
299
+ expect(completionMessages()).toHaveLength(1);
300
+ });
301
+
302
+ it('aborts on unmount without callbacks or a stale success event', async () => {
303
+ let finish!: (value: Response) => void;
304
+ fetchMock.mockResolvedValueOnce(response(null)).mockImplementationOnce(
305
+ () =>
306
+ new Promise((resolve) => {
307
+ finish = resolve;
308
+ })
309
+ );
310
+ const orderCompletionDelayedCallback = vi.fn();
311
+ const view = renderApp({ orderCompletionDelayedCallback });
312
+ act(paymentReturn);
313
+ await advance();
314
+ view.unmount();
315
+ expect(fetchMock.mock.calls[1][1]?.signal?.aborted).toBe(true);
316
+ await act(async () => {
317
+ finish(response({ id: 'returned-order', status: 'Completed' }));
318
+ });
319
+ await advance(10000);
320
+ expect(orderCompletionDelayedCallback).not.toHaveBeenCalled();
321
+ expect(completionMessages()).toHaveLength(0);
322
+ });
323
+
324
+ it('uses invoice submission ID and order information without requiring payment messages', async () => {
325
+ fetchMock
326
+ .mockResolvedValueOnce(response(null))
327
+ .mockResolvedValueOnce(
328
+ response({ id: 'invoice-order', status: 'Completed' })
329
+ );
330
+ renderApp();
331
+ fireEvent.click(screen.getByRole('button', { name: 'Submit invoice' }));
332
+ await advance();
333
+ expect(screen.getByText('Order completed')).toBeTruthy();
334
+ expect(completionMessages()).toEqual([
335
+ expect.objectContaining({
336
+ orderId: 'invoice-order',
337
+ orderInfo: {
338
+ orderId: 'invoice-order',
339
+ subscriberId: 'subscriber-7',
340
+ paymentMethod: 'Invoice',
341
+ },
342
+ }),
343
+ ]);
344
+ });
345
+
346
+ it('preserves POST validation failures without starting polling or acceptance callbacks', async () => {
347
+ fetchMock.mockResolvedValueOnce(
348
+ response(
349
+ {
350
+ status: 400,
351
+ title: 'Invalid order',
352
+ errors: { email: ['Email is invalid'] },
353
+ },
354
+ 400
355
+ )
356
+ );
357
+ const orderAcceptedCallback = vi.fn();
358
+ renderApp({ orderAcceptedCallback });
359
+ act(paymentReturn);
360
+ await advance();
361
+ expect(screen.getByText('Invalid order')).toBeTruthy();
362
+ expect(screen.getByText('Email is invalid')).toBeTruthy();
363
+ expect(
364
+ screen.getByRole('button', { name: 'Submit invoice' })
365
+ ).toBeTruthy();
366
+ expect(fetchMock).toHaveBeenCalledTimes(1);
367
+ expect(orderAcceptedCallback).not.toHaveBeenCalled();
368
+ expect(completionMessages()).toHaveLength(0);
369
+ });
370
+
371
+ it('preserves Vipps conflict cancellation', async () => {
372
+ fetchMock
373
+ .mockResolvedValueOnce(
374
+ response({ status: 409, title: 'Payment conflict' }, 409)
375
+ )
376
+ .mockResolvedValueOnce(response(null));
377
+ window.history.replaceState(
378
+ {},
379
+ '',
380
+ '/?orderId=returned-order&agreementId=agreement-3'
381
+ );
382
+ const cancelVippsCallback = vi.fn();
383
+ renderApp({ cancelVippsCallback });
384
+ await advance();
385
+ expect(cancelVippsCallback).toHaveBeenCalledOnce();
386
+ expect(
387
+ fetchMock.mock.calls.map(([, options]) => options?.method)
388
+ ).toEqual(['POST', 'DELETE']);
389
+ expect(completionMessages()).toHaveLength(0);
390
+ });
391
+
392
+ it('retries network, temporary 404 and 503 errors before confirming completion', async () => {
393
+ fetchMock
394
+ .mockResolvedValueOnce(response(null))
395
+ .mockRejectedValueOnce(new TypeError('Network unavailable'))
396
+ .mockResolvedValueOnce(response({ title: 'Not visible yet' }, 404))
397
+ .mockResolvedValueOnce(response({ title: 'Try later' }, 503))
398
+ .mockResolvedValueOnce(
399
+ response({ id: 'returned-order', status: 'Completed' })
400
+ );
401
+ renderApp();
402
+ act(paymentReturn);
403
+ await advance(1499);
404
+ expect(completionMessages()).toHaveLength(0);
405
+ await advance(1);
406
+ expect(screen.getByText('Order completed')).toBeTruthy();
407
+ expect(fetchMock).toHaveBeenCalledTimes(5);
408
+ });
409
+
410
+ it.each([
411
+ ['seconds', '2'],
412
+ ['HTTP date', new Date(Date.UTC(2026, 10, 16, 12, 0, 2)).toUTCString()],
413
+ ])('honors Retry-After expressed as %s', async (_label, retryAfter) => {
414
+ vi.setSystemTime(new Date(Date.UTC(2026, 10, 16, 12, 0, 0)));
415
+ fetchMock
416
+ .mockResolvedValueOnce(response(null))
417
+ .mockResolvedValueOnce(
418
+ response(null, 429, { 'Retry-After': retryAfter })
419
+ )
420
+ .mockResolvedValueOnce(
421
+ response({ id: 'returned-order', status: 'Completed' })
422
+ );
423
+ renderApp();
424
+ act(paymentReturn);
425
+ await advance(1999);
426
+ expect(fetchMock).toHaveBeenCalledTimes(2);
427
+ expect(completionMessages()).toHaveLength(0);
428
+ await advance(1);
429
+ expect(screen.getByText('Order completed')).toBeTruthy();
430
+ });
431
+
432
+ it('does not extend the deadline for a long Retry-After', async () => {
433
+ fetchMock
434
+ .mockResolvedValueOnce(response(null))
435
+ .mockResolvedValueOnce(
436
+ response(null, 429, { 'Retry-After': '60' })
437
+ );
438
+ const orderCompletionDelayedCallback = vi.fn();
439
+ renderApp({ orderCompletionDelayedCallback });
440
+ act(paymentReturn);
441
+ await advance(10000);
442
+ expect(
443
+ screen.getByText('Order received, taking longer than expected')
444
+ ).toBeTruthy();
445
+ expect(orderCompletionDelayedCallback).toHaveBeenCalledOnce();
446
+ expect(fetchMock).toHaveBeenCalledTimes(2);
447
+ expect(completionMessages()).toHaveLength(0);
448
+ });
449
+
450
+ it('does not retry a rate-limited read when Retry-After is unavailable to the browser', async () => {
451
+ fetchMock
452
+ .mockResolvedValueOnce(response(null))
453
+ .mockResolvedValueOnce(response(null, 429));
454
+ renderApp();
455
+ act(paymentReturn);
456
+ await advance(9999);
457
+ expect(fetchMock).toHaveBeenCalledTimes(2);
458
+ await advance(1);
459
+ expect(
460
+ screen.getByText('Order received, taking longer than expected')
461
+ ).toBeTruthy();
462
+ expect(completionMessages()).toHaveLength(0);
463
+ });
464
+
465
+ it.each(['-1', '1.5', '0x1'])(
466
+ 'does not retry a rate-limited read for invalid Retry-After %s',
467
+ async (retryAfter) => {
468
+ fetchMock
469
+ .mockResolvedValueOnce(response(null))
470
+ .mockResolvedValueOnce(
471
+ response(null, 429, { 'Retry-After': retryAfter })
472
+ )
473
+ .mockResolvedValueOnce(
474
+ response({ id: 'returned-order', status: 'Completed' })
475
+ );
476
+ const orderCompletionDelayedCallback = vi.fn();
477
+ renderApp({ orderCompletionDelayedCallback });
478
+ act(paymentReturn);
479
+ await advance(9999);
480
+ expect(fetchMock).toHaveBeenCalledTimes(2);
481
+ expect(orderCompletionDelayedCallback).not.toHaveBeenCalled();
482
+ await advance(1);
483
+ expect(
484
+ screen.getByText('Order received, taking longer than expected')
485
+ ).toBeTruthy();
486
+ expect(
487
+ orderCompletionDelayedCallback
488
+ ).toHaveBeenCalledExactlyOnceWith({
489
+ orderId: 'returned-order',
490
+ orderInfo: null,
491
+ reason: 'timeout',
492
+ });
493
+ expect(fetchMock).toHaveBeenCalledTimes(2);
494
+ expect(completionMessages()).toHaveLength(0);
495
+ }
496
+ );
497
+
498
+ it.each([
499
+ [401, 'Not JSON'],
500
+ [403, 'Not JSON'],
501
+ [400, 'Not JSON'],
502
+ [400, 'null'],
503
+ ] as const)(
504
+ 'stops status reads on HTTP %s (%s) without claiming order rejection',
505
+ async (status, body) => {
506
+ fetchMock
507
+ .mockResolvedValueOnce(response(null))
508
+ .mockResolvedValueOnce(new Response(body, { status }));
509
+ const orderCompletionDelayedCallback = vi.fn();
510
+ const orderCompletionFailedCallback = vi.fn();
511
+ renderApp({
512
+ orderCompletionDelayedCallback,
513
+ orderCompletionFailedCallback,
514
+ });
515
+ act(paymentReturn);
516
+ await advance(10000);
517
+ expect(
518
+ orderCompletionDelayedCallback
519
+ ).toHaveBeenCalledExactlyOnceWith({
520
+ orderId: 'returned-order',
521
+ orderInfo: null,
522
+ reason: 'statusUnavailable',
523
+ });
524
+ expect(
525
+ screen.getByText('Order received, taking longer than expected')
526
+ ).toBeTruthy();
527
+ expect(orderCompletionFailedCallback).not.toHaveBeenCalled();
528
+ expect(fetchMock).toHaveBeenCalledTimes(2);
529
+ expect(completionMessages()).toHaveLength(0);
530
+ }
531
+ );
532
+
533
+ it.each([
534
+ null,
535
+ { id: 'returned-order' },
536
+ { id: 'returned-order', status: 'FutureStatus' },
537
+ { id: 'different-order', status: 'Completed' },
538
+ ])(
539
+ 'never treats an unknown or malformed status response as success: %j',
540
+ async (body) => {
541
+ fetchMock
542
+ .mockResolvedValueOnce(response(null))
543
+ .mockResolvedValueOnce(response(body));
544
+ const orderCompletionDelayedCallback = vi.fn();
545
+ renderApp({ orderCompletionDelayedCallback });
546
+ act(paymentReturn);
547
+ await advance(10000);
548
+ expect(
549
+ screen.getByText('Order received, taking longer than expected')
550
+ ).toBeTruthy();
551
+ expect(orderCompletionDelayedCallback).toHaveBeenCalledWith({
552
+ orderId: 'returned-order',
553
+ orderInfo: null,
554
+ reason: 'statusUnavailable',
555
+ });
556
+ expect(fetchMock).toHaveBeenCalledTimes(2);
557
+ expect(completionMessages()).toHaveLength(0);
558
+ }
559
+ );
560
+
561
+ it.each(['Created', 'InProgress'])(
562
+ 'keeps polling while the order status is %s',
563
+ async (status) => {
564
+ fetchMock
565
+ .mockResolvedValueOnce(response(null))
566
+ .mockResolvedValueOnce(
567
+ response({ id: 'returned-order', status })
568
+ )
569
+ .mockResolvedValueOnce(
570
+ response({ id: 'returned-order', status: 'Completed' })
571
+ );
572
+ renderApp();
573
+ act(paymentReturn);
574
+ await advance();
575
+ expect(fetchMock).toHaveBeenCalledTimes(2);
576
+ await advance(500);
577
+ expect(fetchMock).toHaveBeenCalledTimes(3);
578
+ expect(screen.getByText('Order completed')).toBeTruthy();
579
+ expect(completionMessages()).toHaveLength(1);
580
+ }
581
+ );
582
+
583
+ it.each(['Pending', 'Processing', 'Draft', 'Failed', 'created', ''])(
584
+ 'stops polling for non-pollable status "%s"',
585
+ async (status) => {
586
+ fetchMock
587
+ .mockResolvedValueOnce(response(null))
588
+ .mockResolvedValueOnce(
589
+ response({ id: 'returned-order', status })
590
+ )
591
+ .mockResolvedValueOnce(
592
+ response({ id: 'returned-order', status: 'Completed' })
593
+ );
594
+ const orderCompletionDelayedCallback = vi.fn();
595
+ renderApp({ orderCompletionDelayedCallback });
596
+ act(paymentReturn);
597
+ await advance(10000);
598
+ expect(
599
+ orderCompletionDelayedCallback
600
+ ).toHaveBeenCalledExactlyOnceWith({
601
+ orderId: 'returned-order',
602
+ orderInfo: null,
603
+ reason: 'statusUnavailable',
604
+ });
605
+ expect(fetchMock).toHaveBeenCalledTimes(2);
606
+ expect(completionMessages()).toHaveLength(0);
607
+ }
608
+ );
609
+
610
+ it('clears the loading skeleton when a pending POST is aborted by cancel', async () => {
611
+ fetchMock.mockImplementationOnce(() => new Promise(() => undefined));
612
+ fetchMock.mockResolvedValue(response(null));
613
+ renderApp();
614
+ act(paymentReturn);
615
+ await advance();
616
+ expect(screen.getByTestId('sdk-order-loading-skeleton')).toBeTruthy();
617
+ act(() =>
618
+ window.dispatchEvent(
619
+ new MessageEvent('message', {
620
+ data: { type: MessageEventTypeEnum.CANCEL },
621
+ })
622
+ )
623
+ );
624
+ await advance();
625
+ expect(screen.queryByTestId('sdk-order-loading-skeleton')).toBeNull();
626
+ });
627
+
628
+ it('isolates host callback failures from accepted order state and polling', async () => {
629
+ vi.spyOn(console, 'error').mockImplementation(() => undefined);
630
+ fetchMock
631
+ .mockResolvedValueOnce(response(null))
632
+ .mockResolvedValueOnce(
633
+ response({ id: 'returned-order', status: 'Completed' })
634
+ );
635
+ renderApp({
636
+ orderAcceptedCallback: () => {
637
+ throw new Error('Host callback error');
638
+ },
639
+ orderCompletedCallback: async () => {
640
+ throw new Error('Async callback error');
641
+ },
642
+ });
643
+ act(paymentReturn);
644
+ await advance();
645
+ expect(screen.getByText('Order completed')).toBeTruthy();
646
+ expect(
647
+ screen.queryByRole('button', { name: 'Submit invoice' })
648
+ ).toBeNull();
649
+ expect(completionMessages()).toHaveLength(1);
650
+ });
651
+
652
+ it('does not start status reads after acceptance callback unmounts SDK', async () => {
653
+ fetchMock.mockResolvedValueOnce(response(null));
654
+ let unmount!: () => void;
655
+ const view = renderApp({ orderAcceptedCallback: () => unmount() });
656
+ unmount = view.unmount;
657
+ act(paymentReturn);
658
+ await advance(10000);
659
+ expect(fetchMock).toHaveBeenCalledTimes(1);
660
+ expect(completionMessages()).toHaveLength(0);
661
+ });
662
+
663
+ it('ignores a pending POST response after unmount', async () => {
664
+ let finish!: (value: Response) => void;
665
+ fetchMock.mockImplementationOnce(
666
+ () =>
667
+ new Promise((resolve) => {
668
+ finish = resolve;
669
+ })
670
+ );
671
+ const orderAcceptedCallback = vi.fn();
672
+ const view = renderApp({ orderAcceptedCallback });
673
+ act(paymentReturn);
674
+ view.unmount();
675
+ await act(async () => {
676
+ finish(response(null));
677
+ });
678
+ await advance(10000);
679
+ expect(orderAcceptedCallback).not.toHaveBeenCalled();
680
+ expect(fetchMock).toHaveBeenCalledTimes(1);
681
+ expect(completionMessages()).toHaveLength(0);
682
+ });
683
+
684
+ it('ignores an old status response after cancelling and starting another order', async () => {
685
+ let finish!: (value: Response) => void;
686
+ fetchMock
687
+ .mockResolvedValueOnce(response(null))
688
+ .mockImplementationOnce(
689
+ () =>
690
+ new Promise((resolve) => {
691
+ finish = resolve;
692
+ })
693
+ )
694
+ .mockResolvedValueOnce(response(null))
695
+ .mockResolvedValueOnce(response(null))
696
+ .mockResolvedValueOnce(
697
+ response({ id: 'invoice-order', status: 'Completed' })
698
+ );
699
+ renderApp();
700
+ act(paymentReturn);
701
+ await advance();
702
+ act(() =>
703
+ window.dispatchEvent(
704
+ new MessageEvent('message', {
705
+ data: { type: MessageEventTypeEnum.CANCEL },
706
+ })
707
+ )
708
+ );
709
+ await advance();
710
+ expect(fetchMock.mock.calls[1][1]?.signal?.aborted).toBe(true);
711
+ expect(fetchMock.mock.calls[2][0]).toBe(
712
+ 'https://orders.example.test/order/returned-order'
713
+ );
714
+ expect(fetchMock.mock.calls[2][1]?.method).toBe('DELETE');
715
+ fireEvent.click(screen.getByRole('button', { name: 'Submit invoice' }));
716
+ await advance();
717
+ await act(async () => {
718
+ finish(response({ id: 'returned-order', status: 'Completed' }));
719
+ });
720
+ expect(completionMessages()).toEqual([
721
+ expect.objectContaining({ orderId: 'invoice-order' }),
722
+ ]);
723
+ expect(screen.getByText('Order completed')).toBeTruthy();
724
+ });
725
+
726
+ it('shows a useful delayed message even when settings contain no custom polling text', async () => {
727
+ fetchMock.mockImplementation(async () =>
728
+ response({ id: 'returned-order', status: 'InProgress' })
729
+ );
730
+ renderApp({ settings: {} });
731
+ act(paymentReturn);
732
+ await advance(10000);
733
+ expect(screen.getByRole('status').textContent).toContain(
734
+ 'Your order was received, but things are taking longer than expected.'
735
+ );
736
+ expect(completionMessages()).toHaveLength(0);
737
+ });
738
+ });