@envive-ai/react-hooks 0.3.63 → 0.3.65

package/src/services/enviveConfigService/__tests__/fetchBootstrapConfig.test.ts

@@ -67,9 +67,9 @@ const baseParams: FetchBootstrapConfigParams = {
   source: 'app',
   namespace: 'spiffy-react-components',
   gateNames: ['use_unified_config', 'is_client_session_enabled'],
+  // url_resolving inputs (org identity is NOT sent — the server fills it from the
+  // authenticated org). Absent url ⇒ bootstrap omits the url_resolving branch.
   url: 'https://shop.example.com/products/thing',
-  orgId: 'org-1',
-  orgShortName: 'test-org',
   contextSource: 'app',
   env: 'prod',
   featureGates: { use_unified_config: true, is_empty_div_plp_enabled: true },
@@ -180,20 +180,38 @@ describe('fetchBootstrapConfig', () => {
     });
     expect(body.url_resolving).toMatchObject({
       url: 'https://shop.example.com/products/thing',
-      // Override-aware gates forwarded so client overrides reach page-variant resolution.
+      // Override-only gates forwarded so client overrides reach page-variant resolution.
       feature_gates: { use_unified_config: true, is_empty_div_plp_enabled: true },
     });
-    // No org_base_config_version — the version comes only from the URL query param
-    // (override_config_version), never from getWidgetConfig's resolution.
+    // No org_base_config_version — the version comes only from the URL query param.
     expect(body.url_resolving.org_base_config_version).toBeUndefined();
+    // org identity is NOT sent — the server fills org_id/org_short_name from the
+    // authenticated org (bootstrap-only has no getWidgetConfig to source them from).
     expect(body.url_resolving.context).toEqual({
       user_id: 'user-1',
-      org_id: 'org-1',
-      org_short_name: 'test-org',
       chat_id: 'chat-9',
       source: 'app',
       env: 'prod',
     });
+    expect(body.url_resolving.context.org_id).toBeUndefined();
+    expect(body.url_resolving.context.org_short_name).toBeUndefined();
+  });
+
+  it('omits the url_resolving branch from the request when no url is supplied', async () => {
+    makeBootstrapResponse();
+
+    // A disabled session (envive_on=false) requests config only — no page to resolve.
+    const { url, contextSource, env, featureGates, ...configOnly } = baseParams;
+    await fetchBootstrapConfig(configOnly);
+
+    const body = JSON.parse(mockFetch.mock.calls[0][1].body as string);
+    // Config inputs still sent; the whole url_resolving object is absent.
+    expect(body).toMatchObject({
+      user_id: 'user-1',
+      namespace: 'spiffy-react-components',
+      include_feature_gates: ['use_unified_config', 'is_client_session_enabled'],
+    });
+    expect(body.url_resolving).toBeUndefined();
   });
 
   it('threads a config-version query param into version + override_config_version', async () => {
@@ -207,7 +225,67 @@ describe('fetchBootstrapConfig', () => {
     expect(body.url_resolving.override_config_version).toBe('9.9.9');
   });
 
-  it('throws on a non-ok response so the caller can fall back', async () => {
+  it('degrades a malformed products_config to mock WITHOUT losing org/gates/experiments', async () => {
+    // A 2xx with valid org/gates/widget_config but a products_config that throws
+    // in transformV3ProductsConfig (invalid floating-button position). With no
+    // getWidgetConfig fallback left, this catch is the SOLE thing keeping a bad
+    // products config from aborting injection — it must null colors/frontend only
+    // and preserve org identity + gates + experiment_assignments + resolution.
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          org_config: {
+            org: { org: { id: 'org-boot', short_name: 'boot-org' } },
+            gates: [{ name: 'use_unified_config', value: true, group_name: 'Treatment' }],
+          },
+          widget_config: {
+            products_config: {
+              v_three_config: {
+                values: {
+                  colors: { values: { text_primary: '#000000' } },
+                  ui_configs: {
+                    floating_button: { position: 'top-center' }, // invalid → transform throws
+                    look_and_feel: { typography: {} },
+                  },
+                },
+              },
+            },
+            experiment_assignments: [
+              {
+                layer_name: 'ml',
+                namespace: 'ml',
+                allocated_experiment_name: 'exp_a',
+                group_name: 'A',
+              },
+            ],
+            resolution: { base_version: '2.0.0', base_version_source: 'merchant_layer' },
+          },
+          url_resolving: null,
+        }),
+    });
+
+    const { config } = await fetchBootstrapConfig(baseParams);
+
+    // org / gates / experiments survived the products-config failure.
+    expect(config.org.org.id).toBe('org-boot');
+    expect(config.gates).toContainEqual({
+      name: 'use_unified_config',
+      value: true,
+      groupName: 'Treatment',
+    });
+    expect(config.experiment_assignments).toEqual([
+      { layer_name: 'ml', namespace: 'ml', allocated_experiment_name: 'exp_a', group_name: 'A' },
+    ]);
+    // colors/frontend degraded to undefined, resolution still attached.
+    expect(config.orgConfig).toEqual({
+      colorsConfig: undefined,
+      frontendConfig: undefined,
+      resolution: { baseVersion: '2.0.0', baseVersionSource: 'merchant_layer' },
+    });
+  });
+
+  it('throws on a non-ok response so the caller aborts injection (no fallback)', async () => {
     mockFetch.mockResolvedValueOnce({ ok: false, statusText: 'Bad Gateway' });
 
     await expect(fetchBootstrapConfig(baseParams)).rejects.toThrow(
@@ -225,14 +303,13 @@ describe('fetchBootstrapConfig', () => {
       'partial org_config (no org.org)',
       { org_config: { org: {}, gates: okGates }, widget_config: okWidget },
     ],
-    ['absent gates', { org_config: { org: { org: { id: 'o' } } }, widget_config: okWidget }],
     [
-      'empty gates',
-      { org_config: { org: { org: { id: 'o' } }, gates: [] }, widget_config: okWidget },
+      'absent gates (not an array)',
+      { org_config: { org: { org: { id: 'o' } } }, widget_config: okWidget },
     ],
     ['missing widget_config', { org_config: okOrg, widget_config: null }],
   ])(
-    'throws on a 2xx with %s so the caller can fall back to getWidgetConfig',
+    'throws on a 2xx with %s so the caller aborts injection instead of using empty config',
     async (_label, payload) => {
       mockFetch.mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(payload) });
 
@@ -240,6 +317,27 @@ describe('fetchBootstrapConfig', () => {
     },
   );
 
+  it('accepts an EMPTY (but present) gates array as a valid all-disabled config', async () => {
+    // An empty gates array is a legitimate "everything off" response (no user to
+    // bucket, or every requested gate off). It must NOT be rejected as malformed:
+    // FeatureFlagService resolves every gate to false → the session disables
+    // gracefully (with the init event still firing), rather than aborting injection.
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          org_config: { org: { org: { id: 'org-boot', short_name: 'boot-org' } }, gates: [] },
+          widget_config: { products_config: {}, experiment_assignments: [] },
+          url_resolving: null,
+        }),
+    });
+
+    const { config } = await fetchBootstrapConfig(baseParams);
+
+    expect(config.org.org.id).toBe('org-boot');
+    expect(config.gates).toEqual([]);
+  });
+
   it('passes an AbortSignal to fetch (timeout wiring)', async () => {
     makeBootstrapResponse();
 
@@ -249,7 +347,7 @@ describe('fetchBootstrapConfig', () => {
     expect(options.signal).toBeInstanceOf(AbortSignal);
   });
 
-  it('aborts and rejects when the request exceeds the timeout so the caller can fall back', async () => {
+  it('aborts and rejects when the request exceeds the timeout (injection aborts, no fallback)', async () => {
     vi.useFakeTimers();
     // Mimic real fetch: reject with an AbortError once its signal aborts.
     mockFetch.mockImplementationOnce(