unit test thunk

Author: kpamaran

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 '../components/mock-data-generator-modal/types';
+import { CollectionActions } from '../modules/collection-tab';
+import { type MockDataSchemaResponse } from '@mongodb-js/compass-generative-ai';
 
 const defaultMetadata = {
   namespace: 'test.foo',
@@ -62,7 +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'];
 
@@ -99,6 +112,7 @@ describe('Collection Tab Content store', function () {
       },
       {
         dataService,
+        atlasAiService,
         localAppRegistry,
         collection: mockCollection as any,
         workspaces: workspaces as any,
@@ -272,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({
+        namespace: 'some_db.some_collection',
+        schemaAnalysis: {
+          status: SCHEMA_ANALYSIS_STATE_COMPLETE,
+          processedSchema: {
+            name: {
+              type: 'String',
+              probability: 1.0,
+              sampleValues: ['John', 'Jane', 'Bob'],
+            },
+            age: {
+              type: 'Number',
+              probability: 0.9,
+              sampleValues: [25, 30],
+            },
+            isActive: {
+              type: 'Boolean',
+              probability: 0.8,
+              sampleValues: [true, false],
+            },
+          },
+          schemaMetadata: {
+            maxNestingDepth: 1,
+            validationRules: null,
+          },
+        },
+        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().resolves(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({
+        namespace: 'some_db.some_collection',
+        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().resolves({}),
+      };
+
+      // 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;
+    });
+  });
 });