test thunk behavior

Author: kpamaran

packages/compass-collection/src/modules/collection-tab.ts

@@ -96,7 +96,7 @@ export type CollectionState = {
   fakerSchemaGeneration: MockDataGeneratorState;
 };
 
-enum CollectionActions {
+export enum CollectionActions {
   CollectionMetadataFetched = 'compass-collection/CollectionMetadataFetched',
   SchemaAnalysisStarted = 'compass-collection/SchemaAnalysisStarted',
   SchemaAnalysisFinished = 'compass-collection/SchemaAnalysisFinished',
@@ -587,7 +587,7 @@ export const generateFakerMappings = (
         fakerSchema: response,
         requestId: requestId,
       });
-    } catch {
+    } catch (e) {
       logger.log.error(
         mongoLogId(1_001_000_312),
         'Collection',

packages/compass-collection/src/stores/collection-tab.spec.ts

@@ -13,6 +13,16 @@ import { createNoopLogger } from '@mongodb-js/compass-logging/provider';
 import { ReadOnlyPreferenceAccess } from 'compass-preferences-model/provider';
 import { ExperimentTestName } from '@mongodb-js/compass-telemetry/provider';
 import { type CollectionMetadata } from 'mongodb-collection-model';
+import {
+  SCHEMA_ANALYSIS_STATE_COMPLETE,
+  SCHEMA_ANALYSIS_STATE_INITIAL,
+} from '../schema-analysis-types';
+import {
+  MOCK_DATA_GENERATOR_STATE_GENERATING,
+  MOCK_DATA_GENERATOR_STATE_IDLE,
+} from '../mock-data-generator-types';
+import { CollectionActions } from '../modules/collection-tab';
+import { type MockDataSchemaResponse } from '@mongodb-js/compass-generative-ai';
 
 const defaultMetadata = {
   namespace: 'test.foo',
@@ -62,8 +72,10 @@ describe('Collection Tab Content store', function () {
   const analyzeCollectionSchemaStub = sandbox
     .stub(collectionTabModule, 'analyzeCollectionSchema')
     .returns(async () => {});
+
   const dataService = {} as any;
   const atlasAiService = {} as any;
+
   let store: ReturnType<typeof activatePlugin>['store'];
   let deactivate: ReturnType<typeof activatePlugin>['deactivate'];
 
@@ -274,4 +286,194 @@ describe('Collection Tab Content store', function () {
       expect(analyzeCollectionSchemaStub).to.not.have.been.called;
     });
   });
+
+  describe('generateFakerMappings thunk', function () {
+    it('can complete successfully', async function () {
+      const dispatch = sandbox.spy();
+      const getState = sandbox.stub().returns({
+        schemaAnalysis: {
+          status: SCHEMA_ANALYSIS_STATE_COMPLETE,
+          processedSchema: {
+            collectionName: 'foo',
+            databaseName: 'test',
+            schema: {
+              name: {
+                type: 'String',
+                sampleValues: ['John', 'Jane', 'Bob'],
+                probability: 1.0,
+              },
+              age: {
+                type: 'Number',
+                sampleValues: [25, 30, 35],
+                probability: 0.9,
+              },
+              isActive: {
+                type: 'Boolean',
+                sampleValues: [true, false],
+                probability: 0.8,
+              },
+            },
+          },
+        },
+        fakerSchemaGeneration: { status: MOCK_DATA_GENERATOR_STATE_IDLE },
+      });
+      const logger = {
+        log: { error: sandbox.spy() },
+        debug: sandbox.spy(),
+      };
+
+      const mockDataSchemaResponse: MockDataSchemaResponse = {
+        content: {
+          fields: [
+            {
+              fieldPath: 'name',
+              probability: 1.0,
+              mongoType: 'string',
+              fakerMethod: 'person.firstName',
+              fakerArgs: [],
+              isArray: false,
+            },
+            {
+              fieldPath: 'age',
+              probability: 1.0,
+              mongoType: 'number',
+              fakerMethod: 'number.int',
+              fakerArgs: [],
+              isArray: false,
+            },
+            {
+              fieldPath: 'isActive',
+              probability: 1.0,
+              mongoType: 'boolean',
+              fakerMethod: 'datatype.boolean',
+              fakerArgs: [],
+              isArray: false,
+            },
+          ],
+        },
+      };
+      const atlasAiService = {
+        getMockDataSchema: sandbox
+          .stub()
+          .returns(Promise.resolve(mockDataSchemaResponse)),
+      };
+
+      // Act
+      const thunk = collectionTabModule.generateFakerMappings(
+        mockAtlasConnectionInfo.current
+      );
+      await thunk(dispatch, getState, { logger, atlasAiService } as any);
+
+      // Assert
+      expect(dispatch).to.have.been.calledTwice;
+
+      const calls = dispatch.getCalls();
+      const startedCall = calls[0];
+      const completedCall = calls[1];
+
+      expect(startedCall).to.be.calledWith({
+        type: CollectionActions.FakerMappingGenerationStarted,
+        requestId: Sinon.match.string,
+      });
+
+      expect(completedCall).to.be.calledWith({
+        type: CollectionActions.FakerMappingGenerationCompleted,
+        fakerSchema: mockDataSchemaResponse,
+        requestId: Sinon.match.string,
+      });
+    });
+
+    it('can dispatch a failure', async function () {
+      const dispatch = sandbox.spy();
+      const getState = sandbox.stub().returns({
+        schemaAnalysis: {
+          status: SCHEMA_ANALYSIS_STATE_COMPLETE,
+          processedSchema: undefined,
+        },
+        fakerSchemaGeneration: { status: MOCK_DATA_GENERATOR_STATE_IDLE },
+      });
+      const logger = {
+        log: { error: sandbox.spy() },
+        debug: sandbox.spy(),
+      };
+
+      const atlasAiService = {
+        getMockDataSchema: sandbox.stub().returns(Promise.resolve({})),
+      };
+
+      // Act
+      const thunk = collectionTabModule.generateFakerMappings(
+        mockAtlasConnectionInfo.current
+      );
+      await thunk(dispatch, getState, { logger, atlasAiService } as any);
+
+      // Assert
+      expect(dispatch).to.have.been.calledTwice;
+
+      const calls = dispatch.getCalls();
+      const startedCall = calls[0];
+      const completedCall = calls[1];
+
+      expect(startedCall).to.be.calledWith({
+        type: CollectionActions.FakerMappingGenerationStarted,
+        requestId: Sinon.match.string,
+      });
+
+      expect(completedCall).to.be.calledWith({
+        type: CollectionActions.FakerMappingGenerationFailed,
+        error: Sinon.match.string,
+        requestId: Sinon.match.string,
+      });
+    });
+
+    it('should not initiate if schemaAnalysis is incomplete', async function () {
+      // Arrange
+      const dispatch = sandbox.spy();
+      const getState = sandbox.stub().returns({
+        schemaAnalysis: { status: SCHEMA_ANALYSIS_STATE_INITIAL },
+        fakerSchemaGeneration: { status: MOCK_DATA_GENERATOR_STATE_IDLE },
+      });
+      const logger = {
+        log: { error: sandbox.spy() },
+        debug: sandbox.spy(),
+      };
+      const atlasAiService = {};
+
+      // Act
+      const thunk = collectionTabModule.generateFakerMappings(
+        mockAtlasConnectionInfo.current
+      );
+      await thunk(dispatch, getState, { logger, atlasAiService } as any);
+
+      // Assert
+      expect(dispatch).to.not.have.been.called;
+      expect(logger.log.error).to.have.been.calledOnce;
+    });
+
+    it('should not initiate if fakerSchemaGeneration is in progress', async function () {
+      // Arrange
+      const dispatch = sandbox.spy();
+      const getState = sandbox.stub().returns({
+        schemaAnalysis: { status: SCHEMA_ANALYSIS_STATE_COMPLETE },
+        fakerSchemaGeneration: { status: MOCK_DATA_GENERATOR_STATE_GENERATING },
+      });
+      const logger = {
+        log: { error: sandbox.spy() },
+        debug: sandbox.spy(),
+      };
+      const atlasAiService = {
+        getMockDataSchema: sandbox.stub().returns(Promise.resolve({})),
+      };
+
+      // Act
+      const thunk = collectionTabModule.generateFakerMappings(
+        mockAtlasConnectionInfo.current
+      );
+      await thunk(dispatch, getState, { logger, atlasAiService } as any);
+
+      // Assert
+      expect(dispatch).to.not.have.been.called;
+      expect(logger.debug).to.have.been.calledOnce;
+    });
+  });
 });