@wix/bex-core 2.328.0 → 2.330.0

package/dist/cjs/state/ImportState/__tests__/ImportState.engine.spec.js

@@ -0,0 +1,610 @@
+"use strict";
+
+var _util = require("util");
+var _mobx = require("mobx");
+var _ImportState = require("../ImportState");
+var _types = require("@wix/bex-utils/@wix/ambassador-hub-v1-job/types");
+var _hubJobClient = require("../hubJobClient");
+// The jsdom test env doesn't expose these globals, but `onFileSelected` decodes
+// the uploaded bytes with `TextDecoder` (and the test encodes CSV with
+// `TextEncoder`). Polyfill from Node's `util`.
+const globalScope = global;
+globalScope.TextEncoder = globalScope.TextEncoder ?? _util.TextEncoder;
+globalScope.TextDecoder = globalScope.TextDecoder ?? _util.TextDecoder;
+jest.mock('../hubJobClient');
+const COMPLETED_JOB = {
+  id: 'job-1',
+  status: _types.JobStatus.COMPLETED,
+  progress: {
+    itemsSuccessful: 2,
+    itemsRejected: 0,
+    total: 2,
+    current: 2
+  }
+};
+function setup(clientOverrides = {}, extraProps = {}) {
+  const client = {
+    uploadFile: jest.fn(async _file => 'file-1'),
+    submitImportJob: jest.fn(async () => 'job-1'),
+    getJob: jest.fn(async () => COMPLETED_JOB),
+    terminateJob: jest.fn(async () => undefined),
+    listMovementLogs: jest.fn(),
+    ...clientOverrides
+  };
+  _hubJobClient.createHubJobClient.mockReturnValue(client);
+  const importModalState = {
+    close: jest.fn()
+  };
+  const collection = {
+    clearResultAndMoveToStart: jest.fn()
+  };
+  const showToast = jest.fn();
+  const downloadCsv = jest.fn();
+  const translate = (key, params) => params ? `${key}:${JSON.stringify(params)}` : key;
+  const props = {
+    fields: [{
+      id: 'name',
+      header: 'Name'
+    }],
+    collectionId: 'Movies',
+    httpClient: {
+      request: jest.fn()
+    },
+    collection,
+    importModalState: importModalState,
+    translate: translate,
+    errorHandler: {
+      withErrorHandler: fn => fn()
+    },
+    showToast: showToast,
+    downloadCsv,
+    ...extraProps
+  };
+  const state = new _ImportState.ImportState(props);
+
+  // Seed a parsed CSV mapped to an existing field.
+  (0, _mobx.runInAction)(() => {
+    state.fileName = 'data.csv';
+    state.csvHeaders = ['Name'];
+    state.csvRows = [['Apple'], ['Pear']];
+    state.mappingByHeader = {
+      Name: {
+        kind: 'existing',
+        fieldId: 'name'
+      }
+    };
+  });
+  return {
+    state,
+    client,
+    importModalState,
+    collection,
+    showToast,
+    downloadCsv
+  };
+}
+describe('ImportState engine (data-hub job)', () => {
+  beforeEach(() => {
+    // The success path awaits a real setTimeout (completion linger); make sure
+    // timers are real even if the preset defaults to fake ones.
+    jest.useRealTimers();
+  });
+  it('uploads the aligned file, submits a job, and reports success', async () => {
+    const {
+      state,
+      client,
+      importModalState,
+      collection
+    } = setup();
+    await state.startImport();
+    expect(client.uploadFile).toHaveBeenCalledTimes(1);
+    expect(client.uploadFile.mock.calls[0][0]).toBeInstanceOf(File);
+    expect(client.submitImportJob).toHaveBeenCalledWith({
+      fileId: 'file-1',
+      name: 'data.csv',
+      destination: {
+        wixDataCollection: {
+          collectionId: 'Movies'
+        }
+      }
+    });
+    expect(state.result).toEqual({
+      succeeded: 2,
+      failed: 0
+    });
+    expect(state.importStatus.status).toBe('success');
+    expect(importModalState.close).toHaveBeenCalled();
+    expect(collection.clearResultAndMoveToStart).toHaveBeenCalledWith({
+      force: true
+    });
+  });
+  it('shows a partial-success toast when some rows are rejected', async () => {
+    const {
+      state,
+      showToast,
+      importModalState
+    } = setup({
+      getJob: jest.fn(async () => ({
+        id: 'job-1',
+        status: _types.JobStatus.PARTIALLY_SUCCESSFUL,
+        progress: {
+          itemsSuccessful: 1,
+          itemsRejected: 1,
+          total: 2,
+          current: 2
+        }
+      }))
+    });
+    await state.startImport();
+    expect(state.result).toEqual({
+      succeeded: 1,
+      failed: 1
+    });
+    expect(showToast).toHaveBeenCalledWith(expect.objectContaining({
+      type: 'WARNING'
+    }));
+    expect(importModalState.close).toHaveBeenCalled();
+  });
+  it('maps the failed "row N" by record (unaffected by an embedded-newline cell)', async () => {
+    const {
+      state,
+      downloadCsv,
+      showToast
+    } = setup({
+      getJob: jest.fn(async () => ({
+        id: 'job-1',
+        status: _types.JobStatus.PARTIALLY_SUCCESSFUL,
+        progress: {
+          itemsSuccessful: 2,
+          itemsRejected: 1
+        }
+      })),
+      // data-hub numbers records (csv-parse, RFC-4180): the 3rd data record is
+      // "row 4" regardless of the multi-line cell in the 1st record.
+      listMovementLogs: jest.fn(async () => ({
+        logs: [{
+          sourceItemId: 'row 4',
+          failure: {
+            code: 'x',
+            description: 'y'
+          }
+        }],
+        pagingMetadata: {
+          hasNext: false
+        }
+      }))
+    });
+
+    // Row 0 has a quoted embedded newline; the failed record is row 2 (Mango).
+    (0, _mobx.runInAction)(() => {
+      state.fileName = 'data.csv';
+      state.csvHeaders = ['Name', 'Notes'];
+      state.csvRows = [['Apple', 'line1\nline2'], ['Pear', 'ok'], ['Mango', 'bad']];
+      state.mappingByHeader = {
+        Name: {
+          kind: 'existing',
+          fieldId: 'name'
+        },
+        Notes: {
+          kind: 'existing',
+          fieldId: 'notes'
+        }
+      };
+    });
+    await state.startImport();
+    const toast = showToast.mock.calls[0][0];
+    await toast.action.onClick();
+
+    // "row 4" → csvRows[2] (Mango), NOT shifted by the embedded newline in row 0.
+    const [content] = downloadCsv.mock.calls[0];
+    expect(content).toContain('Mango');
+    expect(content).not.toContain('Apple');
+  });
+  it('downloads a re-importable CSV of the failed rows from the partial toast action', async () => {
+    const {
+      state,
+      client,
+      showToast,
+      downloadCsv
+    } = setup({
+      getJob: jest.fn(async () => ({
+        id: 'job-1',
+        status: _types.JobStatus.PARTIALLY_SUCCESSFUL,
+        progress: {
+          itemsSuccessful: 1,
+          itemsRejected: 1
+        }
+      })),
+      // csvRows[1] (the "Pear" row) failed → file line 3 → "row 3".
+      listMovementLogs: jest.fn(async () => ({
+        logs: [{
+          sourceItemId: 'row 3',
+          failure: {
+            code: 'bad',
+            description: 'x'
+          }
+        }],
+        pagingMetadata: {
+          hasNext: false
+        }
+      }))
+    });
+    await state.startImport();
+
+    // Trigger the toast's download action.
+    const toast = showToast.mock.calls[0][0];
+    await toast.action.onClick();
+    expect(client.listMovementLogs).toHaveBeenCalledWith('job-1', undefined);
+    // Original headers + only the failed row, ready to fix and re-upload.
+    expect(downloadCsv).toHaveBeenCalledWith('Name\r\nPear', 'failed-data.csv');
+  });
+  it('surfaces an error state with an application-error-shaped error when the job fails', async () => {
+    var _error$response;
+    const {
+      state,
+      importModalState,
+      collection
+    } = setup({
+      getJob: jest.fn(async () => ({
+        id: 'job-1',
+        status: _types.JobStatus.FAILED,
+        error: {
+          code: 'import_failed',
+          description: 'Bad rows'
+        }
+      }))
+    });
+    await state.startImport();
+    expect(state.importStatus.status).toBe('error');
+    // HTTP-error-shaped so the UI resolves the message via
+    // errorHandler.getResolvedError rather than reading the raw server string.
+    // The handler reads the code from `response.data.details.applicationError`.
+    const error = state.importStatus.error;
+    expect((_error$response = error.response) == null || (_error$response = _error$response.data) == null || (_error$response = _error$response.details) == null || (_error$response = _error$response.applicationError) == null ? void 0 : _error$response.code).toBe('import_failed');
+    expect(importModalState.close).not.toHaveBeenCalled();
+    expect(collection.clearResultAndMoveToStart).not.toHaveBeenCalled();
+  });
+  it('hands a failed job to onJobError, which surfaces the wrapped error', async () => {
+    var _error$response2;
+    // Wiring only: the consumer forwards `run` to their withErrorHandler exactly
+    // as documented, and the error it re-rejects is the one surfaced to the UI
+    // (with the application-error-shaped code intact). End-to-end resolution
+    // against the real error handler is covered in the cairo
+    // Table.importButton spec, which has a real errorHandler instance.
+    // Mirror `(run) => errorHandler.withErrorHandler(run, errorCodesMap)`;
+    // a passthrough stub, so this just runs `run` and re-rejects.
+    const withErrorHandler = fn => fn();
+    const onJobError = jest.fn(run => withErrorHandler(run));
+    const {
+      state
+    } = setup({
+      getJob: jest.fn(async () => ({
+        id: 'job-1',
+        status: _types.JobStatus.FAILED,
+        error: {
+          code: 'duplicate_key',
+          description: 'Bad rows'
+        }
+      }))
+    }, {
+      onJobError
+    });
+    await state.startImport();
+    expect(onJobError).toHaveBeenCalledTimes(1);
+    expect(typeof onJobError.mock.calls[0][0]).toBe('function');
+    expect(state.importStatus.status).toBe('error');
+    const error = state.importStatus.error;
+    expect((_error$response2 = error.response) == null || (_error$response2 = _error$response2.data) == null || (_error$response2 = _error$response2.details) == null || (_error$response2 = _error$response2.applicationError) == null ? void 0 : _error$response2.code).toBe('duplicate_key');
+  });
+  it('terminates the job when closed mid-import', async () => {
+    const {
+      state,
+      client,
+      importModalState
+    } = setup();
+    // Cancel during the first poll, before the job is terminal.
+    client.getJob.mockImplementation(async () => {
+      await state.close();
+      return {
+        id: 'job-1',
+        status: _types.JobStatus.IN_PROGRESS
+      };
+    });
+    await state.startImport();
+    expect(client.terminateJob).toHaveBeenCalledWith('job-1');
+    expect(importModalState.close).toHaveBeenCalled();
+  });
+  it('terminates the job when cancelled while submitImportJob is in flight', async () => {
+    const {
+      state,
+      client
+    } = setup();
+    // The user cancels while submit is still in flight: close() runs before
+    // _jobId is set (so it can't terminate), then submit resolves.
+    client.submitImportJob.mockImplementation(async () => {
+      await state.close();
+      return 'job-1';
+    });
+    await state.startImport();
+
+    // The late-cancel path must terminate the orphaned job, and polling never starts.
+    expect(client.terminateJob).toHaveBeenCalledWith('job-1');
+    expect(client.getJob).not.toHaveBeenCalled();
+  });
+  it('aborts the poll loop when disposed (unmounted) mid-import', async () => {
+    const {
+      state,
+      client
+    } = setup();
+    const dispose = state.init();
+    // Simulate the component unmounting during the first poll.
+    client.getJob.mockImplementation(async () => {
+      dispose();
+      return {
+        id: 'job-1',
+        status: _types.JobStatus.IN_PROGRESS
+      };
+    });
+    await state.startImport();
+
+    // Without the disposer the loop would keep polling the IN_PROGRESS job
+    // forever; it must stop after the first fetch.
+    expect(client.getJob).toHaveBeenCalledTimes(1);
+  });
+  it('does not restore when closed during the success completion linger', async () => {
+    const restoreFn = jest.fn().mockResolvedValue(undefined);
+    const {
+      state,
+      importModalState,
+      collection
+    } = setup({}, {
+      backup: async () => ({
+        restore: restoreFn
+      })
+    });
+
+    // A 0ms macrotask drains the pending async chain without firing the 600ms
+    // linger timer.
+    const flush = () => new Promise(resolve => setTimeout(resolve, 0));
+    const promise = state.startImport();
+    // Run backup → upload → submit → poll (terminal) → success, parking on the
+    // 600ms completion linger (still on the 'progress' step) without firing it.
+    await flush();
+    await flush();
+    await flush();
+    expect(state.importStatus.isSuccess).toBe(true);
+    expect(state.currentStep).toBe('progress');
+
+    // User closes the modal mid-linger.
+    await state.close();
+    await promise;
+
+    // A successful import must not be reverted; the modal closes and the
+    // collection refreshes.
+    expect(restoreFn).not.toHaveBeenCalled();
+    expect(importModalState.close).toHaveBeenCalled();
+    expect(collection.clearResultAndMoveToStart).toHaveBeenCalledWith({
+      force: true
+    });
+  });
+});
+describe('ImportState writePolicy (id-collision handling)', () => {
+  beforeEach(() => {
+    jest.useRealTimers();
+  });
+
+  // Seed a CSV column mapped to the `_id` field so collisions are possible.
+  function seedIdMapping(state) {
+    (0, _mobx.runInAction)(() => {
+      state.fileName = 'data.csv';
+      state.csvHeaders = ['ID', 'Name'];
+      state.csvRows = [['1', 'Apple'], ['2', 'Pear']];
+      state.mappingByHeader = {
+        ID: {
+          kind: 'existing',
+          fieldId: '_id'
+        },
+        Name: {
+          kind: 'existing',
+          fieldId: 'name'
+        }
+      };
+    });
+  }
+  it('exposes the header mapped to `_id` via idMappedHeader', () => {
+    const {
+      state
+    } = setup();
+    expect(state.idMappedHeader).toBeNull();
+    seedIdMapping(state);
+    expect(state.idMappedHeader).toBe('ID');
+  });
+  it('omits writePolicy when no column is mapped to `_id`', async () => {
+    const {
+      state,
+      client
+    } = setup();
+    await state.startImport();
+    expect(client.submitImportJob).toHaveBeenCalledWith(expect.objectContaining({
+      destination: {
+        wixDataCollection: {
+          collectionId: 'Movies'
+        }
+      }
+    }));
+  });
+  it('sends the default OVERWRITE policy when a column maps to `_id`', async () => {
+    const {
+      state,
+      client
+    } = setup();
+    seedIdMapping(state);
+    await state.startImport();
+    expect(client.submitImportJob).toHaveBeenCalledWith(expect.objectContaining({
+      destination: {
+        wixDataCollection: {
+          collectionId: 'Movies',
+          writePolicy: _types.WritePolicy.OVERWRITE
+        }
+      }
+    }));
+  });
+  it('sends SKIP_EXISTING after the user switches the policy', async () => {
+    const {
+      state,
+      client
+    } = setup();
+    seedIdMapping(state);
+    state.setWritePolicy(_types.WritePolicy.SKIP_EXISTING);
+    await state.startImport();
+    expect(client.submitImportJob).toHaveBeenCalledWith(expect.objectContaining({
+      destination: {
+        wixDataCollection: {
+          collectionId: 'Movies',
+          writePolicy: _types.WritePolicy.SKIP_EXISTING
+        }
+      }
+    }));
+  });
+  it('resets the policy back to OVERWRITE', () => {
+    const {
+      state
+    } = setup();
+    state.setWritePolicy(_types.WritePolicy.SKIP_EXISTING);
+    expect(state.writePolicy).toBe(_types.WritePolicy.SKIP_EXISTING);
+    state.reset();
+    expect(state.writePolicy).toBe(_types.WritePolicy.OVERWRITE);
+  });
+  it('resets the policy to OVERWRITE when a new file is uploaded mid-session', async () => {
+    const {
+      state
+    } = setup();
+    seedIdMapping(state);
+    // The user switched to Skip for the first file.
+    state.setWritePolicy(_types.WritePolicy.SKIP_EXISTING);
+    expect(state.writePolicy).toBe(_types.WritePolicy.SKIP_EXISTING);
+
+    // Uploading a different CSV in the same modal session must start from the
+    // documented default — otherwise the prior Skip silently carries over and
+    // rows with a colliding `_id` are skipped instead of updated.
+    const csv = 'ID,Name\nid-9,Zed\n';
+    const file = {
+      name: 'file-b.csv',
+      arrayBuffer: async () => new _util.TextEncoder().encode(csv).buffer
+    };
+    await state.onFileSelected(file);
+    expect(state.writePolicy).toBe(_types.WritePolicy.OVERWRITE);
+  });
+  it('keeps the chosen policy when the `_id` mapping is removed and re-added', () => {
+    const {
+      state
+    } = setup();
+    seedIdMapping(state);
+    state.setWritePolicy(_types.WritePolicy.SKIP_EXISTING);
+
+    // Remap the ID column away: the control hides and the destination drops
+    // writePolicy, but the user's choice is intentionally retained (editing
+    // mappings within a file never resets it — only a new file does).
+    state.setMapping('ID', null);
+    expect(state.idMappedHeader).toBeNull();
+    expect(state.writePolicy).toBe(_types.WritePolicy.SKIP_EXISTING);
+
+    // Map `_id` again — the prior choice is still in effect.
+    state.setMapping('ID', '_id');
+    expect(state.idMappedHeader).toBe('ID');
+    expect(state.writePolicy).toBe(_types.WritePolicy.SKIP_EXISTING);
+  });
+  it('omits writePolicy when the `_id` column is remapped away mid-session', async () => {
+    const {
+      state,
+      client
+    } = setup();
+    seedIdMapping(state);
+    state.setWritePolicy(_types.WritePolicy.SKIP_EXISTING);
+    // No column maps to `_id` anymore → no collisions possible → omit it.
+    state.setMapping('ID', null);
+    await state.startImport();
+    expect(client.submitImportJob).toHaveBeenCalledWith(expect.objectContaining({
+      destination: {
+        wixDataCollection: {
+          collectionId: 'Movies'
+        }
+      }
+    }));
+  });
+});
+describe('ImportState orderedHeaders (row order stability)', () => {
+  beforeEach(() => {
+    jest.useRealTimers();
+  });
+
+  // Parse a CSV whose `ID` column auto-maps to `_id` (a field with that id
+  // exists), so the `_id` row floats to the top of the ordered list.
+  async function parseWithIdColumn(state) {
+    const csv = 'Name,ID,Handle\nApple,id-1,a\nPear,id-2,p\n';
+    const file = {
+      name: 'data.csv',
+      arrayBuffer: async () => new _util.TextEncoder().encode(csv).buffer
+    };
+    await state.onFileSelected(file);
+  }
+  it('floats the `_id`-mapped column to the top for a freshly parsed file', async () => {
+    const {
+      state
+    } = setup({}, {
+      fields: [{
+        id: '_id',
+        header: 'ID'
+      }]
+    });
+    await parseWithIdColumn(state);
+    expect(state.idMappedHeader).toBe('ID');
+    expect(state.orderedHeaders).toEqual(['ID', 'Name', 'Handle']);
+  });
+  it('keeps row order stable when the `_id` mapping is cleared and re-added', async () => {
+    const {
+      state
+    } = setup({}, {
+      fields: [{
+        id: '_id',
+        header: 'ID'
+      }]
+    });
+    await parseWithIdColumn(state);
+
+    // Clearing the `_id` dropdown must not reorder the row under the cursor:
+    // the snapshot stays fixed even though `idMappedHeader` becomes null.
+    state.setMapping('ID', null);
+    expect(state.idMappedHeader).toBeNull();
+    expect(state.orderedHeaders).toEqual(['ID', 'Name', 'Handle']);
+
+    // Re-mapping `_id` also leaves the order untouched.
+    state.setMapping('ID', '_id');
+    expect(state.idMappedHeader).toBe('ID');
+    expect(state.orderedHeaders).toEqual(['ID', 'Name', 'Handle']);
+  });
+  it('re-snapshots the order for a new file and clears it on reset', async () => {
+    const {
+      state
+    } = setup({}, {
+      fields: [{
+        id: '_id',
+        header: 'ID'
+      }]
+    });
+    await parseWithIdColumn(state);
+    expect(state.orderedHeaders).toEqual(['ID', 'Name', 'Handle']);
+
+    // A file with no `_id` column keeps plain CSV order.
+    const csv = 'First,Second\n1,2\n';
+    const file = {
+      name: 'other.csv',
+      arrayBuffer: async () => new _util.TextEncoder().encode(csv).buffer
+    };
+    await state.onFileSelected(file);
+    expect(state.orderedHeaders).toEqual(['First', 'Second']);
+    state.reset();
+    expect(state.orderedHeaders).toEqual([]);
+  });
+});
+//# sourceMappingURL=ImportState.engine.spec.js.map