chore(databases-collections): re-introduce old tests; add plugin service mock helper; add new plugin tests

gribnoysup · gribnoysup · commit 20f2bf62bdfc · 2023-11-13T12:11:33.000+01:00
diff --git a/packages/databases-collections/src/modules/create-namespace.spec.ts b/packages/databases-collections/src/modules/create-namespace.spec.ts
@@ -0,0 +1,92 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { handleFLE2Options } from './create-namespace';
+import type { Binary } from 'bson';
+import { UUID } from 'bson';
+
+describe('create collection module', function () {
+  describe('#handleFLE2Options', function () {
+    let ds: { createDataKey: sinon.SinonStub<any[], Promise<Binary>> };
+    let uuid: Binary;
+
+    beforeEach(function () {
+      uuid = new UUID().toBinary();
+      ds = {
+        createDataKey: sinon.stub().resolves(uuid),
+      };
+    });
+
+    it('parses an encryptedFields config', async function () {
+      expect(
+        await handleFLE2Options(ds, {
+          encryptedFields: '',
+        })
+      ).to.deep.equal({});
+      expect(
+        await handleFLE2Options(ds, {
+          encryptedFields: '{}',
+        })
+      ).to.deep.equal({});
+      expect(
+        await handleFLE2Options(ds, {
+          encryptedFields: '{ foo: "bar" }',
+        })
+      ).to.deep.equal({ encryptedFields: { foo: 'bar' } });
+    });
+
+    it('rejects unparseable encryptedFields config', async function () {
+      try {
+        await handleFLE2Options(ds, {
+          encryptedFields: '{',
+        });
+        expect.fail('missed exception');
+      } catch (err) {
+        expect((err as Error).message).to.include(
+          'Could not parse encryptedFields config'
+        );
+      }
+    });
+
+    it('creates data keys for missing fields if kms and key encryption key are provided', async function () {
+      expect(
+        await handleFLE2Options(ds, {
+          encryptedFields: '{ fields: [{ path: "foo", bsonType: "string" }] }',
+          kmsProvider: 'local',
+          keyEncryptionKey: '',
+        })
+      ).to.deep.equal({
+        encryptedFields: {
+          fields: [{ path: 'foo', bsonType: 'string', keyId: uuid }],
+        },
+      });
+    });
+
+    it('does not create data keys if encryptedFields.fields is not an array', async function () {
+      expect(
+        await handleFLE2Options(ds, {
+          encryptedFields: '{ fields: {x: "y"} }',
+          kmsProvider: 'local',
+          keyEncryptionKey: '',
+        })
+      ).to.deep.equal({
+        encryptedFields: {
+          fields: { x: 'y' },
+        },
+      });
+    });
+
+    it('fails when creating data keys fails', async function () {
+      ds.createDataKey.rejects(new Error('createDataKey failed'));
+      try {
+        await handleFLE2Options(ds, {
+          encryptedFields: '{ fields: [{ path: "foo", bsonType: "string" }] }',
+          kmsProvider: 'local',
+          keyEncryptionKey: '',
+        });
+        expect.fail('missed exception');
+      } catch (err) {
+        expect((err as Error).message).to.equal('createDataKey failed');
+      }
+    });
+  });
+});
diff --git a/packages/databases-collections/src/stores/create-namespace.spec.tsx b/packages/databases-collections/src/stores/create-namespace.spec.tsx
@@ -0,0 +1,94 @@
+import React from 'react';
+import Sinon from 'sinon';
+import { CreateNamespacePlugin } from '../index';
+import AppRegistry from 'hadron-app-registry';
+import {
+  render,
+  cleanup,
+  screen,
+  waitForElementToBeRemoved,
+} from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { expect } from 'chai';
+
+describe('DropNamespacePlugin', function () {
+  const sandbox = Sinon.createSandbox();
+  const appRegistry = sandbox.spy(new AppRegistry());
+  const dataService = {
+    createCollection: sandbox.stub().resolves({}),
+    createDataKey: sandbox.stub().resolves({}),
+    configuredKMSProviders: sandbox.stub().returns([]),
+  };
+  const instance = {
+    on: sandbox.stub(),
+    off: sandbox.stub(),
+    build: { version: '999.999.999' },
+    topologyDescription: { type: 'Unknown' },
+  };
+
+  beforeEach(function () {
+    const Plugin = CreateNamespacePlugin.withMockServices({
+      globalAppRegistry: appRegistry,
+      dataService,
+      instance: instance as any,
+    });
+    render(<Plugin></Plugin>);
+  });
+
+  afterEach(function () {
+    sandbox.resetHistory();
+    cleanup();
+  });
+
+  it('should handle create database flow on `open-create-database` event', async function () {
+    appRegistry.emit('open-create-database');
+
+    expect(screen.getByRole('heading', { name: 'Create Database' })).to.exist;
+
+    userEvent.type(
+      screen.getByRole('textbox', { name: 'Database Name' }),
+      'db'
+    );
+
+    userEvent.type(
+      screen.getByRole('textbox', { name: 'Collection Name' }),
+      'coll1'
+    );
+
+    userEvent.click(screen.getByRole('button', { name: 'Create Database' }));
+
+    await waitForElementToBeRemoved(
+      screen.queryByRole('heading', { name: 'Create Database' })
+    );
+
+    expect(dataService.createCollection).to.have.been.calledOnceWith(
+      'db.coll1',
+      {}
+    );
+  });
+
+  it('should handle create collection flow on `open-create-collection` event', async function () {
+    appRegistry.emit('open-create-collection', { database: 'db' });
+
+    expect(screen.getByRole('heading', { name: 'Create Collection' })).to.exist;
+
+    expect(screen.queryByRole('textbox', { name: 'Database Name' })).to.not
+      .exist;
+
+    userEvent.type(
+      screen.getByRole('textbox', { name: 'Collection Name' }),
+      'coll2'
+    );
+
+    userEvent.click(screen.getByRole('button', { name: 'Create Collection' }));
+
+    await waitForElementToBeRemoved(
+      screen.queryByRole('heading', { name: 'Create Collection' })
+    );
+
+    expect(dataService.createCollection).to.have.been.calledOnceWith(
+      'db.coll2',
+      {}
+    );
+  });
+});
diff --git a/packages/databases-collections/src/stores/drop-namespace.spec.tsx b/packages/databases-collections/src/stores/drop-namespace.spec.tsx
@@ -1,6 +1,6 @@
 import React from 'react';
 import Sinon from 'sinon';
-import { DropNamespaceComponent, activatePlugin } from './drop-namespace';
+import { DropNamespacePlugin } from '../index';
 import AppRegistry from 'hadron-app-registry';
 import toNS from 'mongodb-ns';
 import { render, cleanup, screen, waitFor } from '@testing-library/react';
@@ -14,19 +14,17 @@ describe('DropNamespacePlugin', function () {
     dropDatabase: sandbox.stub().resolves(true),
     dropCollection: sandbox.stub().resolves(true),
   };
-  const logger = { track: sandbox.stub() };
 
   beforeEach(function () {
-    render(<DropNamespaceComponent></DropNamespaceComponent>);
-    activatePlugin(
-      {},
-      { globalAppRegistry: appRegistry, dataService, logger: logger as any }
-    );
+    const Plugin = DropNamespacePlugin.withMockServices({
+      globalAppRegistry: appRegistry,
+      dataService,
+    });
+    render(<Plugin></Plugin>);
   });
 
   afterEach(function () {
     sandbox.resetHistory();
-    appRegistry.deactivate();
     cleanup();
   });
 
diff --git a/packages/hadron-app-registry/src/react-context.tsx b/packages/hadron-app-registry/src/react-context.tsx
@@ -9,8 +9,15 @@ import { globalAppRegistry, AppRegistry } from './app-registry';
 import createDebug from 'debug';
 const debug = createDebug('hadron-app-registry:react');
 
-const GlobalAppRegistryContext = createContext(globalAppRegistry);
-const LocalAppRegistryContext = createContext<AppRegistry | null>(null);
+/**
+ * @internal exported for the mock plugin helper implementation
+ */
+export const GlobalAppRegistryContext = createContext(globalAppRegistry);
+
+/**
+ * @internal exported for the mock plugin helper implementation
+ */
+export const LocalAppRegistryContext = createContext<AppRegistry | null>(null);
 
 type AppRegistryProviderProps =
   | {
diff --git a/packages/hadron-app-registry/src/register-plugin.tsx b/packages/hadron-app-registry/src/register-plugin.tsx
@@ -2,8 +2,18 @@ import React, { useRef, useState } from 'react';
 import type { Store as RefluxStore } from 'reflux';
 import { Provider as ReduxStoreProvider } from 'react-redux';
 import type { Actions } from './actions';
-import { type Store, type AppRegistry, isReduxStore } from './app-registry';
-import { useGlobalAppRegistry, useLocalAppRegistry } from './react-context';
+import {
+  type Store,
+  AppRegistry,
+  isReduxStore,
+  globalAppRegistry,
+} from './app-registry';
+import {
+  GlobalAppRegistryContext,
+  LocalAppRegistryContext,
+  useGlobalAppRegistry,
+  useLocalAppRegistry,
+} from './react-context';
 
 function LegacyRefluxProvider({
   store,
@@ -78,8 +88,29 @@ export type HadronPluginConfig<T, S extends Record<string, () => unknown>> = {
   };
 };
 
-export type HadronPluginComponent<T> = React.FunctionComponent<T> & {
+export type HadronPluginComponent<
+  T,
+  S extends Record<string, () => unknown>
+> = React.FunctionComponent<T> & {
   displayName: string;
+  /**
+   * Convenience method for testing: allows to override services and app
+   * registries available in the plugin context
+   *
+   * @example
+   * const PluginWithLogger = registerHadronPlugin({ ... }, { logger: loggerLocator });
+   *
+   * const MockPlugin = PluginWithLogger.withMockServices({ logger: Sinon.stub() });
+   *
+   * @param mocks Overrides for the services locator values and registries
+   *              passed to the plugin in runtime. When `globalAppRegistry`
+   *              override is passed, it will be also used for the
+   *              localAppRegistry override unless `localAppRegistry` is also
+   *              explicitly passed as a mock service.
+   */
+  withMockServices(
+    mocks: Partial<Registries & Services<S>>
+  ): React.FunctionComponent<T>;
 };
 
 /**
@@ -138,7 +169,7 @@ export type HadronPluginComponent<T> = React.FunctionComponent<T> & {
 export function registerHadronPlugin<
   T,
   S extends Record<string, () => unknown>
->(config: HadronPluginConfig<T, S>, services?: S): HadronPluginComponent<T> {
+>(config: HadronPluginConfig<T, S>, services?: S): HadronPluginComponent<T, S> {
   const Component = config.component;
   const registryName = `${config.name}.Plugin`;
 
@@ -194,6 +225,36 @@ export function registerHadronPlugin<
     },
     {
       displayName: config.name,
+      withMockServices(
+        mocks: Partial<Registries & Services<S>>
+      ): React.FunctionComponent<T> {
+        const {
+          globalAppRegistry: _globalAppRegistry,
+          localAppRegistry: _localAppRegistry,
+          ...mockServices
+        } = mocks;
+        const mockServiceLocators = Object.fromEntries(
+          Object.keys(services ?? {}).map((s) => {
+            return [s, mockServices[s] ? () => mockServices[s] : services?.[s]];
+          })
+        ) as unknown as S;
+        const MockPlugin = registerHadronPlugin(config, mockServiceLocators);
+        return function MockPluginWithContext(props: T) {
+          return (
+            <GlobalAppRegistryContext.Provider
+              value={_globalAppRegistry ?? globalAppRegistry}
+            >
+              <LocalAppRegistryContext.Provider
+                value={
+                  _localAppRegistry ?? _globalAppRegistry ?? new AppRegistry()
+                }
+              >
+                <MockPlugin {...(props as any)}></MockPlugin>
+              </LocalAppRegistryContext.Provider>
+            </GlobalAppRegistryContext.Provider>
+          );
+        };
+      },
     }
   );
 }
