add tests

Author: paula-stacho

packages/compass-e2e-tests/helpers/selectors.ts

@@ -1161,6 +1161,8 @@ export const ValidationActionSelector =
   '[data-testid="validation-action-selector"]';
 export const ValidationLevelSelector =
   '[data-testid="validation-level-selector"]';
+export const GenerateValidationRulesButton =
+  '[data-testid="generate-rules-button"]';
 
 // Find (Documents and Schema tabs)
 export const queryBar = (tabName: string): string => {

packages/compass-e2e-tests/tests/collection-validation-tab.test.ts

@@ -8,6 +8,7 @@ import {
 import type { Compass } from '../helpers/compass';
 import * as Selectors from '../helpers/selectors';
 import { createNumbersCollection } from '../helpers/insert-data';
+import { expect } from 'chai';
 
 const NO_PREVIEW_DOCUMENTS = 'No Preview Documents';
 const PASSING_VALIDATOR = '{ $jsonSchema: {} }';
@@ -52,6 +53,43 @@ describe('Collection validation tab', function () {
     await browser.setValidation(validation);
   }
 
+  context('when the schema validation is empty', function () {
+    before(async function () {
+      await browser.setFeature('enableExportSchema', true);
+    });
+
+    it.only('provides users with a button to generate rules', async function () {
+      await browser.clickVisible(Selectors.GenerateValidationRulesButton);
+      const editor = browser.$(Selectors.ValidationEditor);
+      await editor.waitForDisplayed();
+
+      // rules are generated
+      const generatedRules = await browser.getCodemirrorEditorText(
+        Selectors.ValidationEditor
+      );
+      expect(JSON.parse(generatedRules)).to.deep.equal({
+        $jsonSchema: {
+          bsonType: 'object',
+          required: ['_id', 'i', 'j'],
+          properties: {
+            _id: {
+              bsonType: 'objectId',
+            },
+            i: {
+              bsonType: 'int',
+            },
+            j: {
+              bsonType: 'int',
+            },
+          },
+        },
+      });
+
+      // generated rules can be edited and saved
+      await browser.setValidation('{ $jsonSchema: { "blah": "string" } }');
+    });
+  });
+
   context('when the schema validation is set or modified', function () {
     it('provides users with a single button to load sample documents', async function () {
       await addValidation(PASSING_VALIDATOR);

packages/compass-schema-validation/src/components/validation-states.spec.tsx

@@ -31,8 +31,8 @@ const { renderWithConnections } = createPluginTestHelpers(
 describe('ValidationStates [Component]', function () {
   let props: any;
 
-  const render = (props: any) => {
-    return renderWithConnections(<ValidationStates {...props} />);
+  const render = (props: any, options: any = {}) => {
+    return renderWithConnections(<ValidationStates {...props} />, options);
   };
 
   beforeEach(function () {
@@ -255,13 +255,18 @@ describe('ValidationStates [Component]', function () {
       props.isZeroState = true;
       props.isLoaded = true;
       props.serverVersion = '3.2.0';
-
-      render(props);
     });
 
     it('renders the zero state', function () {
+      render(props);
       expect(screen.getByTestId('empty-content')).to.exist;
     });
+
+    it('when enableExportSchema is set, shows button for rules generation', function () {
+      render(props, { preferences: { enableExportSchema: true } });
+      const btn = screen.getByRole('button', { name: 'Generate rules' });
+      expect(btn).to.be.visible;
+    });
   });
 
   context('when it is not in the zero state and not loaded', function () {

packages/compass-schema-validation/src/modules/index.ts

@@ -36,6 +36,7 @@ import {
   INITIAL_STATE as RULES_GENERATION_STATE,
   rulesGenerationReducer,
 } from './rules-generation';
+import type { analyzeSchema } from '@mongodb-js/compass-schema';
 
 /**
  * Reset action constant.
@@ -84,6 +85,7 @@ export type SchemaValidationExtraArgs = {
   logger: Logger;
   track: TrackFunction;
   rulesGenerationAbortControllerRef: { current?: AbortController };
+  analyzeSchema: typeof analyzeSchema;
 };
 
 export type SchemaValidationThunkAction<

packages/compass-schema-validation/src/modules/rules-generation.ts

@@ -1,7 +1,6 @@
 import type { SchemaValidationThunkAction } from '.';
 import { zeroStateChanged } from './zero-state';
 import { enableEditRules } from './edit-mode';
-import { analyzeSchema } from '@mongodb-js/compass-schema';
 import type { MongoError } from 'mongodb';
 import type { Action, AnyAction, Reducer } from 'redux';
 import { validationLevelChanged, validatorChanged } from './validation';
@@ -161,7 +160,13 @@ export const generateValidationRules = (): SchemaValidationThunkAction<
   return async (
     dispatch,
     getState,
-    { dataService, logger, preferences, rulesGenerationAbortControllerRef }
+    {
+      dataService,
+      logger,
+      preferences,
+      rulesGenerationAbortControllerRef,
+      analyzeSchema,
+    }
   ) => {
     dispatch({ type: RulesGenerationActions.generationStarted });
 

packages/compass-schema-validation/src/stores/store.spec.ts

@@ -20,6 +20,11 @@ import { createNoopTrack } from '@mongodb-js/compass-telemetry/provider';
 import type { ConnectionInfoRef } from '@mongodb-js/compass-connections/provider';
 import { type WorkspacesService } from '@mongodb-js/compass-workspaces/provider';
 import Sinon from 'sinon';
+import {
+  generateValidationRules,
+  stopRulesGeneration,
+} from '../modules/rules-generation';
+import { waitFor } from '@mongodb-js/testing-library-compass';
 
 const topologyDescription = {
   type: 'Unknown',
@@ -39,14 +44,16 @@ const fakeDataService = {
     new Promise(() => {
       /* never resolves */
     }),
+  isCancelError: () => false,
+  sample: () => [{ prop1: 'abc' }],
 } as any;
 
 const fakeWorkspaces = {
   onTabReplace: () => {},
   onTabClose: () => {},
 } as unknown as WorkspacesService;
 
-const getMockedStore = async () => {
+const getMockedStore = async (analyzeSchema: any) => {
   const globalAppRegistry = new AppRegistry();
   const connectionInfoRef = {
     current: {},
@@ -63,11 +70,16 @@ const getMockedStore = async () => {
       track: createNoopTrack(),
       connectionInfoRef,
     },
-    createActivateHelpers()
+    createActivateHelpers(),
+    analyzeSchema
   );
   return activateResult;
 };
 
+const schemaAccessor = {
+  getMongoDBJsonSchema: () => ({ required: ['prop1'] }),
+};
+
 describe('Schema Validation Store', function () {
   let store: Store<RootState, RootAction>;
   let deactivate: null | (() => void) = null;
@@ -77,7 +89,8 @@ describe('Schema Validation Store', function () {
     sandbox = Sinon.createSandbox();
     fakeWorkspaces.onTabClose = sandbox.stub();
     fakeWorkspaces.onTabReplace = sandbox.stub();
-    const activateResult = await getMockedStore();
+    const fakeAnalyzeSchema = sandbox.fake.resolves(schemaAccessor);
+    const activateResult = await getMockedStore(fakeAnalyzeSchema);
     store = activateResult.store;
     deactivate = activateResult.deactivate;
   });
@@ -278,5 +291,121 @@ describe('Schema Validation Store', function () {
         store.dispatch(validationLevelChanged(validationLevel));
       });
     });
+
+    context('when the action is generateValidationRules', function () {
+      it('executes rules generation', async function () {
+        store.dispatch(generateValidationRules() as any);
+
+        await waitFor(() => {
+          expect(store.getState().rulesGeneration.isInProgress).to.equal(true);
+        });
+        await waitFor(() => {
+          expect(
+            JSON.parse(store.getState().validation.validator)
+          ).to.deep.equal({
+            $jsonSchema: {
+              required: ['prop1'],
+            },
+          });
+          expect(store.getState().rulesGeneration.isInProgress).to.equal(false);
+          expect(store.getState().rulesGeneration.error).to.be.undefined;
+        });
+      });
+
+      it('rules generation can be aborted', async function () {
+        store.dispatch(generateValidationRules() as any);
+
+        await waitFor(() => {
+          expect(store.getState().rulesGeneration.isInProgress).to.equal(true);
+        });
+
+        store.dispatch(stopRulesGeneration() as any);
+        await waitFor(() => {
+          expect(store.getState().validation.validator).to.equal('');
+          expect(store.getState().rulesGeneration.isInProgress).to.equal(false);
+          expect(store.getState().rulesGeneration.error).to.be.undefined;
+        });
+      });
+
+      context('rules generation failure', function () {
+        it('handles general error', async function () {
+          const fakeAnalyzeSchema = sandbox.fake.rejects(
+            new Error('Such a failure')
+          );
+          const activateResult = await getMockedStore(fakeAnalyzeSchema);
+          store = activateResult.store;
+          deactivate = activateResult.deactivate;
+          store.dispatch(generateValidationRules() as any);
+
+          await waitFor(() => {
+            expect(store.getState().rulesGeneration.isInProgress).to.equal(
+              true
+            );
+          });
+
+          await waitFor(() => {
+            expect(store.getState().rulesGeneration.isInProgress).to.equal(
+              false
+            );
+            expect(store.getState().rulesGeneration.error).to.deep.equal({
+              errorMessage: 'Such a failure',
+              errorType: 'general',
+            });
+          });
+        });
+
+        it('handles complexity error', async function () {
+          const fakeAnalyzeSchema = sandbox.fake.rejects(
+            new Error('Schema analysis aborted: Fields count above 1000')
+          );
+          const activateResult = await getMockedStore(fakeAnalyzeSchema);
+          store = activateResult.store;
+          deactivate = activateResult.deactivate;
+          store.dispatch(generateValidationRules() as any);
+
+          await waitFor(() => {
+            expect(store.getState().rulesGeneration.isInProgress).to.equal(
+              true
+            );
+          });
+
+          await waitFor(() => {
+            expect(store.getState().rulesGeneration.isInProgress).to.equal(
+              false
+            );
+            expect(store.getState().rulesGeneration.error).to.deep.equal({
+              errorMessage: 'Schema analysis aborted: Fields count above 1000',
+              errorType: 'highComplexity',
+            });
+          });
+        });
+
+        it('handles timeout error', async function () {
+          const timeoutError: any = new Error('Too long, didnt execute');
+          timeoutError.code = 50;
+          const fakeAnalyzeSchema = sandbox.fake.rejects(timeoutError);
+          const activateResult = await getMockedStore(fakeAnalyzeSchema);
+          store = activateResult.store;
+          deactivate = activateResult.deactivate;
+          store.dispatch(generateValidationRules() as any);
+
+          await waitFor(() => {
+            expect(store.getState().rulesGeneration.isInProgress).to.equal(
+              true
+            );
+          });
+
+          await waitFor(() => {
+            expect(store.getState().rulesGeneration.isInProgress).to.equal(
+              false
+            );
+            expect(store.getState().rulesGeneration.error).to.deep.equal({
+              errorMessage: 'Too long, didnt execute',
+              errorType: 'timeout',
+            });
+          });
+        });
+      });
+    });
   });
 });

packages/compass-schema-validation/src/stores/store.ts

@@ -14,6 +14,7 @@ import type { PreferencesAccess } from 'compass-preferences-model';
 import type { Logger } from '@mongodb-js/compass-logging/provider';
 import type { TrackFunction } from '@mongodb-js/compass-telemetry';
 import { type WorkspacesService } from '@mongodb-js/compass-workspaces/provider';
+import { analyzeSchema as compassAnalyzeSchema } from '@mongodb-js/compass-schema';
 
 /**
  * The lowest supported version.
@@ -43,7 +44,8 @@ export function configureStore(
     | 'logger'
     | 'track'
     | 'connectionInfoRef'
-  >
+  >,
+  analyzeSchema = compassAnalyzeSchema
 ) {
   const rulesGenerationAbortControllerRef = {
     current: undefined,
@@ -58,6 +60,7 @@ export function configureStore(
       thunk.withExtraArgument({
         ...services,
         rulesGenerationAbortControllerRef,
+        analyzeSchema,
       })
     )
   );
@@ -78,7 +81,8 @@ export function onActivated(
     workspaces,
     track,
   }: SchemaValidationServices,
-  { on, cleanup, addCleanup }: ActivateHelpers
+  { on, cleanup, addCleanup }: ActivateHelpers,
+  analyzeSchema?: typeof compassAnalyzeSchema
 ) {
   const store = configureStore(
     {
@@ -100,7 +104,8 @@ export function onActivated(
       workspaces,
       logger,
       track,
-    }
+    },
+    analyzeSchema
   );
 
   // isWritable can change later