@wix/bex-core 2.331.0 → 2.333.0

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

@@ -19,10 +19,19 @@ const COMPLETED_JOB = {
     itemsSuccessful: 2,
     itemsRejected: 0,
     total: 2,
-    current: 2
+    current: 2,
+    itemsSuccessfulInfo: {
+      itemsCreated: 1,
+      itemsUpdated: 1
+    }
   }
 };
-function setup(clientOverrides = {}, extraProps = {}) {
+
+// Convenience flat overrides, assembled into the `dataSource` union below;
+// `config` fully replaces the assembled config (for schema-backed configs).
+// `detectColumnType` is an infra prop.
+
+function setup(clientOverrides = {}, extra = {}) {
   const client = {
     uploadFile: jest.fn(async _file => 'file-1'),
     submitImportJob: jest.fn(async () => 'job-1'),
@@ -41,12 +50,55 @@ function setup(clientOverrides = {}, extraProps = {}) {
   const showToast = jest.fn();
   const downloadCsv = jest.fn();
   const translate = (key, params) => params ? `${key}:${JSON.stringify(params)}` : key;
-  const props = {
-    fields: [{
+  const {
+    detectColumnType,
+    config: configOverride,
+    collectionId,
+    destination,
+    updateSchema,
+    createFields,
+    fieldManagement,
+    mergeFields,
+    fields,
+    idFieldKey,
+    backup,
+    jobApplicationErrorMap
+  } = extra;
+  const dataSource = destination ? {
+    destination,
+    ...(createFields && {
+      createFields
+    }),
+    ...(fieldManagement && {
+      fieldManagement
+    })
+  } : {
+    collectionId: collectionId ?? 'Movies',
+    ...(updateSchema && {
+      updateSchema
+    })
+  };
+  const config = configOverride ?? {
+    fields: fields ?? [{
       id: 'name',
       header: 'Name'
     }],
-    collectionId: 'Movies',
+    dataSource,
+    ...(mergeFields && {
+      mergeFields
+    }),
+    ...(idFieldKey && {
+      idFieldKey
+    }),
+    ...(backup && {
+      backup
+    }),
+    ...(jobApplicationErrorMap && {
+      jobApplicationErrorMap
+    })
+  };
+  const props = {
+    config,
     httpClient: {
       request: jest.fn()
     },
@@ -58,7 +110,7 @@ function setup(clientOverrides = {}, extraProps = {}) {
     },
     showToast: showToast,
     downloadCsv,
-    ...extraProps
+    detectColumnType
   };
   const state = new _ImportState.ImportState(props);
 
@@ -85,8 +137,8 @@ function setup(clientOverrides = {}, extraProps = {}) {
 }
 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.
+    // The poll loop awaits real setTimeouts between polls; 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 () => {
@@ -108,17 +160,63 @@ describe('ImportState engine (data-hub job)', () => {
         }
       }
     });
+
+    // created/updated come from the job's itemsSuccessfulInfo.
     expect(state.result).toEqual({
       succeeded: 2,
-      failed: 0
+      failed: 0,
+      created: 1,
+      updated: 1
     });
     expect(state.importStatus.status).toBe('success');
-    expect(importModalState.close).toHaveBeenCalled();
+    // The modal stays open on the summary step; the collection is refreshed now
+    // so the table is current once the user closes it via `done`.
+    expect(state.currentStep).toBe('summary');
+    expect(importModalState.close).not.toHaveBeenCalled();
     expect(collection.clearResultAndMoveToStart).toHaveBeenCalledWith({
       force: true
     });
   });
-  it('shows a partial-success toast when some rows are rejected', async () => {
+  it('holds the completed (100%) progress bar on the progress step before the summary (CAIRO-4476)', async () => {
+    const {
+      state
+    } = setup();
+
+    // The job reports counts only when it finishes, so the bar can only reach
+    // 100% at the very end. Capture the step + counts at the moment the linger
+    // starts to prove the user sees the completed bar before the summary
+    // replaces it.
+    let atLinger = null;
+    const spy = jest
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    .spyOn(state, '_lingerOnCompletion').mockImplementation(() => {
+      atLinger = {
+        step: state.currentStep,
+        processed: state.processedCount,
+        total: state.totalCount
+      };
+      return Promise.resolve();
+    });
+    await state.startImport();
+    expect(atLinger).toEqual({
+      step: 'progress',
+      processed: 2,
+      total: 2
+    });
+    expect(state.currentStep).toBe('summary');
+    spy.mockRestore();
+  });
+  it('closes the modal only when the user dismisses the summary via done', async () => {
+    const {
+      state,
+      importModalState
+    } = setup();
+    await state.startImport();
+    expect(importModalState.close).not.toHaveBeenCalled();
+    state.done();
+    expect(importModalState.close).toHaveBeenCalled();
+  });
+  it('shows the summary step (no toast) when some rows are rejected', async () => {
     const {
       state,
       showToast,
@@ -131,25 +229,30 @@ describe('ImportState engine (data-hub job)', () => {
           itemsSuccessful: 1,
           itemsRejected: 1,
           total: 2,
-          current: 2
+          current: 2,
+          itemsSuccessfulInfo: {
+            itemsCreated: 1,
+            itemsUpdated: 0
+          }
         }
       }))
     });
     await state.startImport();
     expect(state.result).toEqual({
       succeeded: 1,
-      failed: 1
+      failed: 1,
+      created: 1,
+      updated: 0
     });
-    expect(showToast).toHaveBeenCalledWith(expect.objectContaining({
-      type: 'WARNING'
-    }));
-    expect(importModalState.close).toHaveBeenCalled();
+    expect(state.currentStep).toBe('summary');
+    // The completion toast is gone — the summary step reports the outcome.
+    expect(showToast).not.toHaveBeenCalled();
+    expect(importModalState.close).not.toHaveBeenCalled();
   });
   it('maps the failed "row N" by record (unaffected by an embedded-newline cell)', async () => {
     const {
       state,
-      downloadCsv,
-      showToast
+      downloadCsv
     } = setup({
       getJob: jest.fn(async () => ({
         id: 'job-1',
@@ -192,19 +295,17 @@ describe('ImportState engine (data-hub job)', () => {
       };
     });
     await state.startImport();
-    const toast = showToast.mock.calls[0][0];
-    await toast.action.onClick();
+    await state.downloadFailedRows();
 
     // "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 () => {
+  it('downloads a re-importable CSV of the failed rows, each prefixed with its failure reason', async () => {
     const {
       state,
       client,
-      showToast,
       downloadCsv
     } = setup({
       getJob: jest.fn(async () => ({
@@ -221,7 +322,7 @@ describe('ImportState engine (data-hub job)', () => {
           sourceItemId: 'row 3',
           failure: {
             code: 'bad',
-            description: 'x'
+            description: 'Invalid value'
           }
         }],
         pagingMetadata: {
@@ -230,13 +331,12 @@ describe('ImportState engine (data-hub job)', () => {
       }))
     });
     await state.startImport();
-
-    // Trigger the toast's download action.
-    const toast = showToast.mock.calls[0][0];
-    await toast.action.onClick();
+    await state.downloadFailedRows();
     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');
+    // A leading reason column (the translated header) + original headers, then
+    // the failed row prefixed with the server's failure reason — ready to fix
+    // and re-upload. `translate` here echoes the key for the column header.
+    expect(downloadCsv).toHaveBeenCalledWith('cairo.import.failureReasonColumn,Name\r\nInvalid value,Pear', 'failed-data.csv');
   });
   it('surfaces an error state with an application-error-shaped error when the job fails', async () => {
     var _error$response;
@@ -264,17 +364,18 @@ describe('ImportState engine (data-hub job)', () => {
     expect(importModalState.close).not.toHaveBeenCalled();
     expect(collection.clearResultAndMoveToStart).not.toHaveBeenCalled();
   });
-  it('hands a failed job to onJobError, which surfaces the wrapped error', async () => {
+  it('resolves a failed job through the consumer jobApplicationErrorMap', 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));
+    // ImportState wraps the failure with `errorHandler.withErrorHandler(run,
+    // jobApplicationErrorMap)` itself; the consumer only supplies the per-code
+    // map. The surfaced error keeps the application-error-shaped code intact.
+    // End-to-end resolution against the real error handler (getResolvedError) is
+    // covered in the cairo Table.importButton spec.
+    const jobApplicationErrorMap = {
+      duplicate_key: () => ({
+        message: 'Bad rows'
+      })
+    };
     const {
       state
     } = setup({
@@ -287,11 +388,9 @@ describe('ImportState engine (data-hub job)', () => {
         }
       }))
     }, {
-      onJobError
+      jobApplicationErrorMap
     });
     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');
@@ -351,7 +450,7 @@ describe('ImportState engine (data-hub 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 () => {
+  it('does not restore a completed import when the summary is closed', async () => {
     const restoreFn = jest.fn().mockResolvedValue(undefined);
     const {
       state,
@@ -362,30 +461,19 @@ describe('ImportState engine (data-hub job)', () => {
         restore: restoreFn
       })
     });
+    await state.startImport();
 
-    // 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();
+    // The import finished on the summary step and the collection was refreshed.
     expect(state.importStatus.isSuccess).toBe(true);
-    expect(state.currentStep).toBe('progress');
+    expect(state.currentStep).toBe('summary');
+    expect(collection.clearResultAndMoveToStart).toHaveBeenCalledWith({
+      force: true
+    });
 
-    // User closes the modal mid-linger.
+    // Closing the summary must not revert a successful import.
     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)', () => {
@@ -671,5 +759,526 @@ describe('ImportState platformized destination (non–Wix-Data)', () => {
     const wixData = setup().state;
     expect(wixData.canConfigureWritePolicy).toBe(true);
   });
+  describe('DataExtension create fields (destination branch)', () => {
+    it('enables create-new-field when the destination branch supplies createFields', () => {
+      const withCreate = setup({}, {
+        destination: {
+          storesCatalogProducts: {}
+        },
+        createFields: jest.fn(async () => undefined)
+      }).state;
+      expect(withCreate.canCreateNewField).toBe(true);
+      const withoutCreate = setup({}, {
+        destination: {
+          storesCatalogProducts: {}
+        }
+      }).state;
+      expect(withoutCreate.canCreateNewField).toBe(false);
+    });
+    it('hands createFields the deduped pending columns (source builds its own def)', async () => {
+      const createFields = jest.fn(async () => undefined);
+      const {
+        state,
+        client
+      } = setup({}, {
+        destination: {
+          storesCatalogProducts: {}
+        },
+        createFields
+      });
+      (0, _mobx.runInAction)(() => {
+        state.csvHeaders = ['Name', 'Color'];
+        state.csvRows = [['Apple', 'Red'], ['Pear', 'Green']];
+        state.mappingByHeader = {
+          Name: {
+            kind: 'existing',
+            fieldId: 'name'
+          },
+          Color: {
+            kind: 'new',
+            fieldType: 'text'
+          }
+        };
+      });
+      await state.startImport();
+      expect(createFields).toHaveBeenCalledTimes(1);
+      // Core passes the neutral pending column (deduped key + name + the mapping);
+      // the DataExtension source turns it into its own field shape.
+      expect(createFields).toHaveBeenCalledWith([{
+        key: 'color',
+        displayName: 'Color',
+        mapping: {
+          kind: 'new',
+          fieldType: 'text'
+        }
+      }]);
+      // The consumer's destination is still sent verbatim.
+      expect(client.submitImportJob).toHaveBeenCalledWith(expect.objectContaining({
+        destination: {
+          storesCatalogProducts: {}
+        }
+      }));
+    });
+    it('carries the edited mapping config (precise type, permissions, PII) in the pending column', async () => {
+      const createFields = jest.fn(async () => undefined);
+      const {
+        state
+      } = setup({}, {
+        destination: {
+          storesCatalogProducts: {}
+        },
+        createFields
+      });
+      const config = {
+        deType: 'decimal',
+        isPii: true,
+        permissions: {
+          installedApps: {
+            defaultRead: true,
+            defaultWrite: false
+          }
+        }
+      };
+      (0, _mobx.runInAction)(() => {
+        state.csvHeaders = ['Name', 'Count'];
+        state.csvRows = [['Apple', '3']];
+        state.mappingByHeader = {
+          Name: {
+            kind: 'existing',
+            fieldId: 'name'
+          },
+          Count: {
+            kind: 'new',
+            fieldType: 'number',
+            displayName: 'Count',
+            config
+          }
+        };
+      });
+      await state.startImport();
+      expect(createFields).toHaveBeenCalledWith([{
+        key: 'count',
+        displayName: 'Count',
+        mapping: {
+          kind: 'new',
+          fieldType: 'number',
+          displayName: 'Count',
+          config
+        }
+      }]);
+    });
+  });
+  describe('created fields (CAIRO-4400)', () => {
+    const RETURNED_FIELDS = {
+      name: {
+        id: 'name',
+        displayName: 'Name',
+        type: 'SHORT_TEXT'
+      },
+      color: {
+        id: 'color',
+        displayName: 'Color',
+        type: 'SHORT_TEXT'
+      }
+    };
+
+    // Maps an extra column to a NEW field so `_resolveFieldMapping` calls
+    // `updateSchema`. `updateSchema`'s presence is also what enables new mappings.
+    function withNewFieldMapping(state) {
+      (0, _mobx.runInAction)(() => {
+        state.csvHeaders = ['Name', 'Color'];
+        state.csvRows = [['Apple', 'Red'], ['Pear', 'Green']];
+        state.mappingByHeader = {
+          Name: {
+            kind: 'existing',
+            fieldId: 'name'
+          },
+          Color: {
+            kind: 'new',
+            fieldType: 'text'
+          }
+        };
+      });
+    }
+    it('calls mergeFields with updateSchema’s returned map after a successful import', async () => {
+      const mergeFields = jest.fn();
+      const updateSchema = jest.fn(async () => RETURNED_FIELDS);
+      const {
+        state,
+        collection
+      } = setup({}, {
+        updateSchema,
+        mergeFields
+      });
+      withNewFieldMapping(state);
+      await state.startImport();
+      expect(updateSchema).toHaveBeenCalledTimes(1);
+      expect(mergeFields).toHaveBeenCalledTimes(1);
+      expect(mergeFields).toHaveBeenCalledWith(RETURNED_FIELDS);
+      // The merge runs alongside the data refetch on the success path.
+      expect(collection.clearResultAndMoveToStart).toHaveBeenCalled();
+    });
+    it('does not call mergeFields for a plain import (no new fields)', async () => {
+      const mergeFields = jest.fn();
+      const updateSchema = jest.fn(async () => RETURNED_FIELDS);
+      const {
+        state
+      } = setup({}, {
+        updateSchema,
+        mergeFields
+      });
+      await state.startImport();
+      expect(updateSchema).not.toHaveBeenCalled();
+      expect(mergeFields).not.toHaveBeenCalled();
+    });
+    it('does not call mergeFields when updateSchema returns nothing', async () => {
+      const mergeFields = jest.fn();
+      const updateSchema = jest.fn(async () => undefined);
+      const {
+        state
+      } = setup({}, {
+        updateSchema,
+        mergeFields
+      });
+      withNewFieldMapping(state);
+      await state.startImport();
+      expect(updateSchema).toHaveBeenCalledTimes(1);
+      expect(mergeFields).not.toHaveBeenCalled();
+    });
+    it('does not call mergeFields when updateSchema returns an empty map', async () => {
+      // A `{}` return is truthy; without a size guard it would reach a full-replace
+      // mergeFields({}) and wipe every column. Treat it as "nothing to merge".
+      const mergeFields = jest.fn();
+      const updateSchema = jest.fn(async () => ({}));
+      const {
+        state
+      } = setup({}, {
+        updateSchema,
+        mergeFields
+      });
+      withNewFieldMapping(state);
+      await state.startImport();
+      expect(updateSchema).toHaveBeenCalledTimes(1);
+      expect(mergeFields).not.toHaveBeenCalled();
+    });
+    it('does not call mergeFields when the import fails after creating fields', async () => {
+      const mergeFields = jest.fn();
+      const updateSchema = jest.fn(async () => RETURNED_FIELDS);
+      const {
+        state
+      } = setup({
+        uploadFile: jest.fn(async () => {
+          throw new Error('upload failed');
+        })
+      }, {
+        updateSchema,
+        mergeFields
+      });
+      withNewFieldMapping(state);
+      await state.startImport();
+
+      // Fields were created pre-upload, but a failed import must not merge them.
+      expect(updateSchema).toHaveBeenCalledTimes(1);
+      expect(state.importStatus.status).toBe('error');
+      expect(mergeFields).not.toHaveBeenCalled();
+    });
+    it('keeps the import successful when mergeFields throws (no void → duplicate-rows)', async () => {
+      const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+      const mergeFields = jest.fn(() => {
+        throw new Error('merge boom');
+      });
+      const updateSchema = jest.fn(async () => RETURNED_FIELDS);
+      const {
+        state,
+        collection
+      } = setup({}, {
+        updateSchema,
+        mergeFields
+      });
+      withNewFieldMapping(state);
+      await state.startImport();
+      expect(mergeFields).toHaveBeenCalledTimes(1);
+      // A throwing merge is swallowed — the completed import is untouched.
+      expect(state.importStatus.status).toBe('success');
+      expect(state.currentStep).toBe('summary');
+      expect(collection.clearResultAndMoveToStart).toHaveBeenCalled();
+      consoleError.mockRestore();
+    });
+  });
+  describe('schema-backed config (live getters + create-field permission)', () => {
+    // A schema-backed config: the CMS `dataSource` branch a SchemaImportRef
+    // satisfies. It supplies `updateSchema` only when create is permitted — its
+    // presence is the create-new-field opt-in (no separate flag).
+    const schemaConfig = (over = {}) => ({
+      fields: over.fields ?? [{
+        id: 'name',
+        header: 'Name'
+      }],
+      dataSource: {
+        collectionId: over.collectionId ?? 'RefCollection',
+        ...(over.updateSchema && {
+          updateSchema: over.updateSchema
+        })
+      },
+      ...(over.idFieldKey && {
+        idFieldKey: over.idFieldKey
+      }),
+      ...(over.mergeFields && {
+        mergeFields: over.mergeFields
+      })
+    });
+    it('reads fields live from the config rather than snapshotting them', () => {
+      const config = schemaConfig();
+      const {
+        state
+      } = setup({}, {
+        config
+      });
+      expect(state.fields).toBe(config.fields);
+
+      // A later change to the config is reflected — values are read on demand,
+      // so a live (getter-backed) config needn't be resolved before the ctor.
+      const updated = [{
+        id: 'name',
+        header: 'Name'
+      }, {
+        id: 'year',
+        header: 'Year'
+      }];
+      config.fields = updated;
+      expect(state.fields).toBe(updated);
+    });
+    it('gates create-new-field on the presence of a create callback (updateSchema)', () => {
+      // No create callback ⇒ create-new-field off (the source didn't permit it).
+      const off = setup({}, {
+        config: schemaConfig()
+      });
+      expect(off.state.canCreateNewField).toBe(false);
+
+      // A create callback present ⇒ on.
+      const on = setup({}, {
+        config: schemaConfig({
+          updateSchema: jest.fn()
+        })
+      });
+      expect(on.state.canCreateNewField).toBe(true);
+    });
+    it('builds the destination from the config collectionId', async () => {
+      const {
+        state,
+        client
+      } = setup({}, {
+        config: schemaConfig({
+          collectionId: 'RefCollection'
+        })
+      });
+      await state.startImport();
+      expect(client.submitImportJob).toHaveBeenCalledWith(expect.objectContaining({
+        destination: {
+          wixDataCollection: {
+            collectionId: 'RefCollection'
+          }
+        }
+      }));
+    });
+    it('creates new fields through the config updateSchema', async () => {
+      const updateSchema = jest.fn(async () => ({
+        name: {
+          id: 'name',
+          displayName: 'Name',
+          type: 'SHORT_TEXT'
+        },
+        year: {
+          id: 'year',
+          displayName: 'Year',
+          type: 'NUMBER'
+        }
+      }));
+      const {
+        state
+      } = setup({}, {
+        config: schemaConfig({
+          updateSchema
+        })
+      });
+      (0, _mobx.runInAction)(() => {
+        state.csvHeaders = ['Name', 'Year'];
+        state.csvRows = [['Apple', '1999']];
+        state.mappingByHeader = {
+          Name: {
+            kind: 'existing',
+            fieldId: 'name'
+          },
+          Year: {
+            kind: 'new',
+            fieldType: 'number'
+          }
+        };
+      });
+      await state.startImport();
+      expect(updateSchema).toHaveBeenCalledTimes(1);
+    });
+    it('detects the id-mapped column using the config idFieldKey', () => {
+      const {
+        state
+      } = setup({}, {
+        config: schemaConfig({
+          idFieldKey: 'movieId'
+        })
+      });
+      (0, _mobx.runInAction)(() => {
+        state.mappingByHeader = {
+          Ref: {
+            kind: 'existing',
+            fieldId: 'movieId'
+          }
+        };
+      });
+      expect(state.idMappedHeader).toBe('Ref');
+    });
+  });
+});
+describe('ImportState required fields (CAIRO-4452)', () => {
+  beforeEach(() => {
+    jest.useRealTimers();
+  });
+  it('is satisfied when a required field has a column mapped to it', () => {
+    const {
+      state
+    } = setup({}, {
+      config: {
+        fields: [{
+          id: 'name',
+          header: 'Name',
+          required: true
+        }],
+        dataSource: {
+          collectionId: 'Movies'
+        }
+      }
+    });
+
+    // The seeded mapping maps the "Name" column to the `name` field.
+    expect(state.hasMissingRequiredFields).toBe(false);
+    expect(state.missingRequiredFields).toEqual([]);
+  });
+  it('flags a required field the user set to "don\'t import"', () => {
+    const {
+      state
+    } = setup({}, {
+      config: {
+        fields: [{
+          id: 'name',
+          header: 'Name',
+          required: true
+        }],
+        dataSource: {
+          collectionId: 'Movies'
+        }
+      }
+    });
+    state.setMapping('Name', null);
+    expect(state.hasMissingRequiredFields).toBe(true);
+    expect(state.missingRequiredFields.map(f => f.id)).toEqual(['name']);
+  });
+  it('ignores unmapped fields that are not required', () => {
+    const {
+      state
+    } = setup({}, {
+      config: {
+        fields: [{
+          id: 'name',
+          header: 'Name'
+        }, {
+          id: 'year',
+          header: 'Year',
+          required: false
+        }],
+        dataSource: {
+          collectionId: 'Movies'
+        }
+      }
+    });
+    state.setMapping('Name', null);
+    expect(state.hasMissingRequiredFields).toBe(false);
+  });
+  it('is not satisfied by a create-new-field mapping', () => {
+    const {
+      state
+    } = setup({}, {
+      config: {
+        fields: [{
+          id: 'name',
+          header: 'Name',
+          required: true
+        }],
+        dataSource: {
+          collectionId: 'Movies',
+          updateSchema: async () => undefined
+        }
+      }
+    });
+
+    // Mapping the column to a brand-new field can't fill the existing required
+    // field, so it stays missing.
+    state.setNewFieldMapping('Name');
+    expect(state.hasMissingRequiredFields).toBe(true);
+  });
+  it('blocks startImport and shows an error toast when a required field is missing', async () => {
+    const {
+      state,
+      client,
+      showToast
+    } = setup({}, {
+      config: {
+        fields: [{
+          id: 'name',
+          header: 'Name',
+          required: true
+        }, {
+          id: 'year',
+          header: 'Year'
+        }],
+        dataSource: {
+          collectionId: 'Movies'
+        }
+      }
+    });
+
+    // Keep a mapping (so the import isn't blocked by "no mappings") but leave the
+    // required `name` field unmapped.
+    (0, _mobx.runInAction)(() => {
+      state.csvHeaders = ['Name', 'Year'];
+      state.csvRows = [['Apple', '2020']];
+    });
+    state.setMapping('Name', null);
+    state.setMapping('Year', 'year');
+    await state.startImport();
+    expect(client.uploadFile).not.toHaveBeenCalled();
+    expect(client.submitImportJob).not.toHaveBeenCalled();
+    expect(state.currentStep).not.toBe('progress');
+    expect(showToast).toHaveBeenCalledWith(expect.objectContaining({
+      type: 'ERROR'
+    }));
+  });
+  it('proceeds with import when all required fields are mapped', async () => {
+    const {
+      state,
+      client
+    } = setup({}, {
+      config: {
+        fields: [{
+          id: 'name',
+          header: 'Name',
+          required: true
+        }],
+        dataSource: {
+          collectionId: 'Movies'
+        }
+      }
+    });
+    await state.startImport();
+    expect(client.submitImportJob).toHaveBeenCalledTimes(1);
+  });
 });
 //# sourceMappingURL=ImportState.engine.spec.js.map