@shopify/ui-extensions 2025.10.0-rc.45 → 2025.10.0-rc.47

package/src/surfaces/checkout/preact/tests/buyer-journey.test.ts

@@ -1,4 +1,3 @@
-import {ExtensionHasNoMethodError} from '../../errors';
 import {
   useBuyerJourney,
   useBuyerJourneyActiveStep,
@@ -7,30 +6,43 @@ import {
   useBuyerJourneySteps,
 } from '../buyer-journey';
 
-import {createMockStatefulRemoteSubscribable, mount} from './mount';
+import {
+  createMockSubscribableSignalLike,
+  mount,
+  setupGlobalShopifyMock,
+  tearDownGlobalShopifyMock,
+  createMockExtension,
+} from './mount';
+
+// See __mocks__/preact/hooks
+jest.mock('preact/hooks');
 
-describe.skip('buyerJourney Hooks', () => {
+describe('buyerJourney Hooks', () => {
   beforeEach(() => {
     jest.spyOn(console, 'error').mockImplementation(() => {});
   });
 
   afterEach(() => {
+    tearDownGlobalShopifyMock();
     // eslint-disable-next-line no-console
     jest.mocked(console.error).mockRestore();
   });
 
   describe('useBuyerJourneySteps()', () => {
     it('raises an exception when buyerJourney api is not available', () => {
+      const target = 'purchase.checkout.header.render-after' as const;
+      setupGlobalShopifyMock<typeof target>({
+        buyerJourney: undefined,
+        extension: createMockExtension(target),
+      });
+
       expect(() => {
-        mount.hook(() => useBuyerJourneySteps(), {
-          extensionApi: {
-            buyerJourney: undefined,
-            extension: {
-              target: 'purchase.checkout.header.render-after',
-            },
-          },
-        });
-      }).toThrow(ExtensionHasNoMethodError);
+        mount.hook(() => useBuyerJourneySteps());
+      }).toThrow(
+        expect.objectContaining({
+          name: 'ExtensionHasNoMethodError',
+        }),
+      );
     });
 
     it('returns the list of steps from the buyerJourney.steps subscribable', () => {
@@ -55,33 +67,33 @@ describe.skip('buyerJourney Hooks', () => {
         },
       ];
 
-      const hook = mount.hook(() => useBuyerJourneySteps(), {
-        extensionApi: {
-          buyerJourney: {
-            steps: createMockStatefulRemoteSubscribable(steps),
-          },
-          extension: {
-            target: 'purchase.checkout.header.render-after',
-          },
+      setupGlobalShopifyMock({
+        buyerJourney: {
+          steps: createMockSubscribableSignalLike(steps),
         },
       });
 
+      const hook = mount.hook(() => useBuyerJourneySteps());
+
       expect(hook.current).toStrictEqual(steps);
     });
   });
 
   describe('useBuyerJourneyActiveStep()', () => {
     it('raises an exception when buyerJourney api is not available', () => {
+      const target = 'purchase.checkout.header.render-after' as const;
+      setupGlobalShopifyMock<typeof target>({
+        buyerJourney: undefined,
+        extension: createMockExtension(target),
+      });
+
       expect(() => {
-        mount.hook(() => useBuyerJourneyActiveStep(), {
-          extensionApi: {
-            buyerJourney: undefined,
-            extension: {
-              target: 'purchase.checkout.header.render-after',
-            },
-          },
-        });
-      }).toThrow(ExtensionHasNoMethodError);
+        mount.hook(() => useBuyerJourneyActiveStep());
+      }).toThrow(
+        expect.objectContaining({
+          name: 'ExtensionHasNoMethodError',
+        }),
+      );
     });
 
     it('returns the step that matches the activeStep.handle', () => {
@@ -107,20 +119,17 @@ describe.skip('buyerJourney Hooks', () => {
         },
       ];
 
-      const hook = mount.hook(() => useBuyerJourneyActiveStep(), {
-        extensionApi: {
-          buyerJourney: {
-            steps: createMockStatefulRemoteSubscribable(steps),
-            activeStep: createMockStatefulRemoteSubscribable({
-              handle: activeStepHandle,
-            }),
-          },
-          extension: {
-            target: 'purchase.checkout.header.render-after',
-          },
+      setupGlobalShopifyMock({
+        buyerJourney: {
+          steps: createMockSubscribableSignalLike(steps),
+          activeStep: createMockSubscribableSignalLike({
+            handle: activeStepHandle,
+          }),
         },
       });
 
+      const hook = mount.hook(() => useBuyerJourneyActiveStep());
+
       expect(hook.current).toStrictEqual(steps[0]);
     });
 
@@ -132,35 +141,29 @@ describe.skip('buyerJourney Hooks', () => {
         to: 'shopify:checkout/information',
       };
 
-      const hook = mount.hook(() => useBuyerJourneyActiveStep(), {
-        extensionApi: {
-          buyerJourney: {
-            steps: createMockStatefulRemoteSubscribable([step]),
-            activeStep: createMockStatefulRemoteSubscribable({
-              handle: 'payment',
-            }),
-          },
-          extension: {
-            target: 'purchase.checkout.header.render-after',
-          },
+      setupGlobalShopifyMock({
+        buyerJourney: {
+          steps: createMockSubscribableSignalLike([step]),
+          activeStep: createMockSubscribableSignalLike({
+            handle: 'payment' as const,
+          }),
         },
       });
 
+      const hook = mount.hook(() => useBuyerJourneyActiveStep());
+
       expect(hook.current).toBeUndefined();
     });
   });
 
   describe('useBuyerJourney()', () => {
     it('returns the buyer journey when the api is available', () => {
-      const hook = mount.hook(() => useBuyerJourney(), {
-        extensionApi: {
-          buyerJourney: {},
-          extension: {
-            target: 'purchase.checkout.header.render-after',
-          },
-        },
+      setupGlobalShopifyMock({
+        buyerJourney: {},
       });
 
+      const hook = mount.hook(() => useBuyerJourney());
+
       expect(hook.current).toStrictEqual({});
     });
   });
@@ -169,17 +172,14 @@ describe.skip('buyerJourney Hooks', () => {
     it.each([true, false])(
       'returns the buyer journey completed value: %s',
       (completed) => {
-        const hook = mount.hook(() => useBuyerJourneyCompleted(), {
-          extensionApi: {
-            buyerJourney: {
-              completed: createMockStatefulRemoteSubscribable(completed),
-            },
-            extension: {
-              target: 'purchase.checkout.header.render-after',
-            },
+        setupGlobalShopifyMock({
+          buyerJourney: {
+            completed: createMockSubscribableSignalLike(completed),
           },
         });
 
+        const hook = mount.hook(() => useBuyerJourneyCompleted());
+
         expect(hook.current).toStrictEqual(completed);
       },
     );
@@ -191,17 +191,14 @@ describe.skip('buyerJourney Hooks', () => {
         Promise.resolve({behavior: 'allow'} as const),
       );
 
-      mount.hook(() => useBuyerJourneyIntercept(mockIntercept), {
-        extensionApi: {
-          buyerJourney: {
-            intercept: (cb: () => void) => cb(),
-          },
-          extension: {
-            target: 'purchase.checkout.header.render-after',
-          },
+      setupGlobalShopifyMock({
+        buyerJourney: {
+          intercept: (cb: () => void) => cb(),
         },
       });
 
+      mount.hook(() => useBuyerJourneyIntercept(mockIntercept));
+
       expect(mockIntercept).toHaveBeenCalled();
     });
   });

package/src/surfaces/checkout/preact/tests/capabilities.test.ts

@@ -1,58 +1,62 @@
-import type {Extension} from '@shopify/ui-extensions/checkout';
+import type {Extension} from '../../api/standard/standard';
+
+// See __mocks__/preact/hooks
+jest.mock('preact/hooks');
 
 import {
   useExtensionCapabilities,
   useExtensionCapability,
 } from '../capabilities';
 
-import {mount, createMockStatefulRemoteSubscribable} from './mount';
+import {
+  mount,
+  createMockSubscribableSignalLike,
+  setupGlobalShopifyMock,
+  tearDownGlobalShopifyMock,
+} from './mount';
+
+describe('useExtensionCapabilities', () => {
+  afterEach(tearDownGlobalShopifyMock);
 
-describe.skip('useExtensionCapabilities', () => {
   it('returns a list of granted capabilities of the extension', () => {
     const capabilities = ['network_access', 'block_progress'];
 
-    const capabilitiesSubscribable = createMockStatefulRemoteSubscribable(
+    const capabilitiesSubscribable = createMockSubscribableSignalLike(
       capabilities,
     ) as Extension['capabilities'];
 
-    const {value} = mount.hook(useExtensionCapabilities, {
-      extensionApi: {
-        extension: {
-          capabilities: capabilitiesSubscribable,
-        },
+    setupGlobalShopifyMock({
+      extension: {
+        capabilities: capabilitiesSubscribable,
       },
     });
 
+    const {value} = mount.hook(useExtensionCapabilities);
+
     expect(value).toStrictEqual(capabilities);
   });
 });
 
-describe.skip('useExtensionCapability', () => {
+describe('useExtensionCapability', () => {
+  afterEach(tearDownGlobalShopifyMock);
+
   it('returns the status of a capabilities', () => {
-    const capabilities = createMockStatefulRemoteSubscribable([
+    const capabilities = createMockSubscribableSignalLike([
       'network_access',
     ]) as Extension['capabilities'];
 
-    const {value: activatedCapability} = mount.hook(
-      () => useExtensionCapability('network_access'),
-      {
-        extensionApi: {
-          extension: {
-            capabilities,
-          },
-        },
+    setupGlobalShopifyMock({
+      extension: {
+        capabilities,
       },
+    });
+
+    const {value: activatedCapability} = mount.hook(() =>
+      useExtensionCapability('network_access'),
     );
 
-    const {value: deactivatedCapability} = mount.hook(
-      () => useExtensionCapability('block_progress'),
-      {
-        extensionApi: {
-          extension: {
-            capabilities,
-          },
-        },
-      },
+    const {value: deactivatedCapability} = mount.hook(() =>
+      useExtensionCapability('block_progress'),
     );
 
     expect(activatedCapability).toBe(true);

package/src/surfaces/checkout/preact/tests/cart-line-target.test.ts

@@ -1,23 +1,30 @@
-import type {ExtensionTarget, CartLine} from '@shopify/ui-extensions/checkout';
+import type {CartLine} from '../../api/standard/standard';
 
 import {useCartLineTarget} from '../cart-line-target';
-import {ExtensionHasNoTargetError} from '../../errors';
-import {useApi} from '../api';
-
-import {createMockStatefulRemoteSubscribable, mount} from './mount';
-
-describe.skip('useCartLineTarget', () => {
-  it('throws if extension target has no api.target', async () => {
-    const runner = async () => {
-      const target: ExtensionTarget = 'purchase.checkout.block.render';
-      return mount.hook(() => useCartLineTarget(), {
-        extensionApi: {
-          extension: {target},
-        },
-      });
-    };
 
-    await expect(runner).rejects.toThrow(ExtensionHasNoTargetError);
+// See __mocks__/preact/hooks
+jest.mock('preact/hooks');
+import {
+  createMockSubscribableSignalLike,
+  mount,
+  setupGlobalShopifyMock,
+  tearDownGlobalShopifyMock,
+  createMockExtension,
+} from './mount';
+
+describe('useCartLineTarget', () => {
+  afterEach(tearDownGlobalShopifyMock);
+
+  it('throws if extension target has no api.target', () => {
+    setupGlobalShopifyMock({});
+
+    expect(() => {
+      mount.hook(() => useCartLineTarget());
+    }).toThrow(
+      expect.objectContaining({
+        name: 'ExtensionHasNoTargetError',
+      }),
+    );
   });
 
   it('returns the cart line target if it exists', async () => {
@@ -45,17 +52,17 @@ describe.skip('useCartLineTarget', () => {
       },
       attributes: [],
       discountAllocations: [],
+      parentRelationship: null,
     } as CartLine;
 
-    const target: ExtensionTarget =
-      'purchase.cart-line-item.line-components.render';
-    const {value} = mount.hook(() => useCartLineTarget(), {
-      extensionApi: {
-        extension: {target},
-        target: createMockStatefulRemoteSubscribable(line),
-      },
+    const target = 'purchase.cart-line-item.line-components.render' as const;
+    setupGlobalShopifyMock<typeof target>({
+      target: createMockSubscribableSignalLike(line),
+      extension: createMockExtension(target),
     });
 
+    const {value} = mount.hook(() => useCartLineTarget());
+
     expect(value).toStrictEqual(line);
   });
 });

package/src/surfaces/checkout/preact/tests/checkout-settings.test.ts

@@ -1,10 +1,20 @@
-import type {CheckoutSettings} from '@shopify/ui-extensions/checkout';
+import type {CheckoutSettings} from '../../api/standard/standard';
 
 import {useCheckoutSettings} from '../checkout-settings';
 
-import {mount, createMockStatefulRemoteSubscribable} from './mount';
+// See __mocks__/preact/hooks
+jest.mock('preact/hooks');
+
+import {
+  mount,
+  createMockSubscribableSignalLike,
+  setupGlobalShopifyMock,
+  tearDownGlobalShopifyMock,
+} from './mount';
+
+describe('useCheckoutSettings', () => {
+  afterEach(tearDownGlobalShopifyMock);
 
-describe.skip('useCheckoutSettings', () => {
   it('returns checkout settings from the api', () => {
     const checkoutSettings = {
       orderSubmission: 'ORDER',
@@ -14,14 +24,12 @@ describe.skip('useCheckoutSettings', () => {
       paymentTermsTemplate: undefined,
     } as CheckoutSettings;
 
-    const extensionApi = {
-      checkoutSettings: createMockStatefulRemoteSubscribable(checkoutSettings),
-    };
-
-    const {value} = mount.hook(() => useCheckoutSettings(), {
-      extensionApi,
+    setupGlobalShopifyMock({
+      checkoutSettings: createMockSubscribableSignalLike(checkoutSettings),
     });
 
+    const {value} = mount.hook(() => useCheckoutSettings());
+
     expect(value).toStrictEqual(checkoutSettings);
   });
 });

package/src/surfaces/checkout/preact/tests/checkout-token.test.ts

@@ -1,17 +1,27 @@
 import {useCheckoutToken} from '../checkout-token';
 
-import {mount, createMockStatefulRemoteSubscribable} from './mount';
+// See __mocks__/preact/hooks
+jest.mock('preact/hooks');
+
+import {
+  mount,
+  createMockSubscribableSignalLike,
+  setupGlobalShopifyMock,
+  tearDownGlobalShopifyMock,
+} from './mount';
+
+describe('useCheckoutToken', () => {
+  afterEach(tearDownGlobalShopifyMock);
 
-describe.skip('useCheckoutToken', () => {
   it('returns checkoutToken from the api', () => {
     const checkoutToken = 'checkout-token';
 
-    const {value} = mount.hook(() => useCheckoutToken(), {
-      extensionApi: {
-        checkoutToken: createMockStatefulRemoteSubscribable(checkoutToken),
-      },
+    setupGlobalShopifyMock({
+      checkoutToken: createMockSubscribableSignalLike(checkoutToken),
     });
 
+    const {value} = mount.hook(() => useCheckoutToken());
+
     expect(value).toBe(checkoutToken);
   });
 });

package/src/surfaces/checkout/preact/tests/configuration.test.ts

@@ -1,17 +1,27 @@
 import {useSettings} from '../settings';
 
-import {mount, createMockStatefulRemoteSubscribable} from './mount';
+// See __mocks__/preact/hooks
+jest.mock('preact/hooks');
+
+import {
+  mount,
+  createMockSubscribableSignalLike,
+  setupGlobalShopifyMock,
+  tearDownGlobalShopifyMock,
+} from './mount';
+
+describe('useSettings', () => {
+  afterEach(tearDownGlobalShopifyMock);
 
-describe.skip('useSettings', () => {
   it('returns settings from the api', () => {
     const settings = {title: 'checkout ui'};
 
-    const {value} = mount.hook(() => useSettings(), {
-      extensionApi: {
-        settings: createMockStatefulRemoteSubscribable(settings),
-      },
+    setupGlobalShopifyMock({
+      settings: createMockSubscribableSignalLike(settings),
     });
 
+    const {value} = mount.hook(() => useSettings());
+
     expect(value).toStrictEqual(settings);
   });
 });

package/src/surfaces/checkout/preact/tests/country.test.tsx

@@ -1,21 +1,31 @@
-import type {CountryCode} from '@shopify/ui-extensions/checkout';
+import type {CountryCode} from '../../../../shared';
 
 import {useLocalizationCountry} from '../country';
 
-import {mount, createMockStatefulRemoteSubscribable} from './mount';
+// See __mocks__/preact/hooks
+jest.mock('preact/hooks');
+
+import {
+  mount,
+  createMockSubscribableSignalLike,
+  setupGlobalShopifyMock,
+  tearDownGlobalShopifyMock,
+} from './mount';
+
+describe('useLocalizationCountry', () => {
+  afterEach(tearDownGlobalShopifyMock);
 
-describe.skip('useLocalizationCountry', () => {
   it('returns country from the api', () => {
     const country: {isoCode: CountryCode} = {isoCode: 'CA'};
 
-    const {value} = mount.hook(() => useLocalizationCountry(), {
-      extensionApi: {
-        localization: {
-          country: createMockStatefulRemoteSubscribable(country),
-        },
+    setupGlobalShopifyMock({
+      localization: {
+        country: createMockSubscribableSignalLike(country),
       },
     });
 
+    const {value} = mount.hook(() => useLocalizationCountry());
+
     expect(value).toStrictEqual(country);
   });
 });

package/src/surfaces/checkout/preact/tests/currency.test.tsx

@@ -1,21 +1,31 @@
-import type {CurrencyCode} from '@shopify/ui-extensions/checkout';
+import type {CurrencyCode} from '../../../../shared';
 
 import {useCurrency} from '../currency';
 
-import {mount, createMockStatefulRemoteSubscribable} from './mount';
+// See __mocks__/preact/hooks
+jest.mock('preact/hooks');
+
+import {
+  mount,
+  createMockSubscribableSignalLike,
+  setupGlobalShopifyMock,
+  tearDownGlobalShopifyMock,
+} from './mount';
+
+describe('useCurrency', () => {
+  afterEach(tearDownGlobalShopifyMock);
 
-describe.skip('useCurrency', () => {
   it('returns currency from the api', () => {
     const currency: {isoCode: CurrencyCode} = {isoCode: 'CAD'};
 
-    const {value} = mount.hook(() => useCurrency(), {
-      extensionApi: {
-        localization: {
-          currency: createMockStatefulRemoteSubscribable(currency),
-        },
+    setupGlobalShopifyMock({
+      localization: {
+        currency: createMockSubscribableSignalLike(currency),
       },
     });
 
+    const {value} = mount.hook(() => useCurrency());
+
     expect(value).toStrictEqual(currency);
   });
 });

package/src/surfaces/checkout/preact/tests/customer-privacy.test.ts

@@ -1,10 +1,20 @@
-import type {CustomerPrivacy} from '@shopify/ui-extensions/checkout';
+import type {CustomerPrivacy} from '../../api/standard/standard';
 
 import {useCustomerPrivacy} from '../customer-privacy';
 
-import {mount, createMockStatefulRemoteSubscribable} from './mount';
+// See __mocks__/preact/hooks
+jest.mock('preact/hooks');
+
+import {
+  mount,
+  createMockSubscribableSignalLike,
+  setupGlobalShopifyMock,
+  tearDownGlobalShopifyMock,
+} from './mount';
+
+describe('useCustomerPrivacy', () => {
+  afterEach(tearDownGlobalShopifyMock);
 
-describe.skip('useCustomerPrivacy', () => {
   it('returns customer privacy settings and data from the API', () => {
     const customerPrivacyValue: CustomerPrivacy = {
       allowedProcessing: {
@@ -26,12 +36,11 @@ describe.skip('useCustomerPrivacy', () => {
       },
     };
 
-    const extensionApi = {
-      customerPrivacy:
-        createMockStatefulRemoteSubscribable(customerPrivacyValue),
-    };
+    setupGlobalShopifyMock({
+      customerPrivacy: createMockSubscribableSignalLike(customerPrivacyValue),
+    });
 
-    const {value} = mount.hook(() => useCustomerPrivacy(), {extensionApi});
+    const {value} = mount.hook(() => useCustomerPrivacy());
 
     expect(value).toMatchObject(customerPrivacyValue);
   });