datajunction-ui 0.0.1-a42.dev0 → 0.0.1-a43.dev0

package/src/app/pages/AddEditNodePage/__tests__/AddEditNodePageFormSuccess.test.jsx

@@ -4,8 +4,10 @@ import fetchMock from 'jest-fetch-mock';
 import userEvent from '@testing-library/user-event';
 import {
   initializeMockDJClient,
+  renderCreateMetric,
   renderCreateNode,
   renderEditNode,
+  renderEditTransformNode,
   testElement,
 } from './index.test';
 import { mocks } from '../../../../mocks/mockNodes';
@@ -21,11 +23,11 @@ describe('AddEditNodePage submission succeeded', () => {
     window.scrollTo = jest.fn();
   });
 
-  it('for creating a node', async () => {
+  it('for creating a dimension/transform node', async () => {
     const mockDjClient = initializeMockDJClient();
     mockDjClient.DataJunctionAPI.createNode.mockReturnValue({
       status: 200,
-      json: { name: 'default.some_test_metric' },
+      json: { name: 'default.some_test_dim' },
     });
 
     mockDjClient.DataJunctionAPI.tagsNode.mockReturnValue({
@@ -43,11 +45,11 @@ describe('AddEditNodePage submission succeeded', () => {
 
     await userEvent.type(
       screen.getByLabelText('Display Name *'),
-      'Some Test Metric',
+      'Some Test Dim',
     );
     await userEvent.type(
       screen.getByLabelText('Query *'),
-      'SELECT * FROM test',
+      'SELECT a, b, c FROM test',
     );
     await userEvent.click(screen.getByText('Create dimension'));
 
@@ -55,29 +57,162 @@ describe('AddEditNodePage submission succeeded', () => {
       expect(mockDjClient.DataJunctionAPI.createNode).toBeCalled();
       expect(mockDjClient.DataJunctionAPI.createNode).toBeCalledWith(
         'dimension',
-        'default.some_test_metric',
-        'Some Test Metric',
+        'default.some_test_dim',
+        'Some Test Dim',
         '',
-        'SELECT * FROM test',
-        'draft',
+        'SELECT a, b, c FROM test',
+        'published',
         'default',
         null,
         undefined,
         undefined,
+        undefined,
       );
-      expect(screen.getByText(/default.some_test_metric/)).toBeInTheDocument();
+      expect(screen.getByText(/default.some_test_dim/)).toBeInTheDocument();
     });
 
+    // After successful creation, it should return a success message
+    expect(screen.getByTestId('success')).toHaveTextContent(
+      'Successfully created node default.some_test_dim',
+    );
+  }, 60000);
+
+  it('for creating a metric node', async () => {
+    const mockDjClient = initializeMockDJClient();
+    mockDjClient.DataJunctionAPI.createNode.mockReturnValue({
+      status: 200,
+      json: { name: 'default.some_test_metric' },
+    });
+
+    mockDjClient.DataJunctionAPI.tagsNode.mockReturnValue({
+      status: 200,
+      json: { message: 'Success' },
+    });
+
+    mockDjClient.DataJunctionAPI.nodesWithType
+      .mockReturnValueOnce(['default.test1'])
+      .mockReturnValueOnce(['default.test2'])
+      .mockReturnValueOnce([]);
+
+    mockDjClient.DataJunctionAPI.listTags.mockReturnValue([
+      { name: 'purpose', display_name: 'Purpose' },
+      { name: 'intent', display_name: 'Intent' },
+    ]);
+
+    mockDjClient.DataJunctionAPI.listMetricMetadata.mockReturnValue(
+      mocks.metricMetadata,
+    );
+
+    const element = testElement(mockDjClient);
+    const { container } = renderCreateMetric(element);
+
+    await userEvent.type(
+      screen.getByLabelText('Display Name *'),
+      'Some Test Metric',
+    );
+    const selectUpstream = screen.getByTestId('select-upstream-node');
+    fireEvent.keyDown(selectUpstream.firstChild, { key: 'ArrowDown' });
+    fireEvent.click(screen.getByText('default.repair_orders'));
+
+    await userEvent.type(
+      screen.getByLabelText('Aggregate Expression *'),
+      'SUM(a)',
+    );
+    await userEvent.click(screen.getByText('Create metric'));
+
+    await waitFor(
+      () => {
+        expect(mockDjClient.DataJunctionAPI.createNode).toBeCalled();
+        expect(mockDjClient.DataJunctionAPI.createNode).toBeCalledWith(
+          'metric',
+          'default.some_test_metric',
+          'Some Test Metric',
+          '',
+          'SELECT SUM(a) FROM default.repair_orders',
+          'published',
+          'default',
+          null,
+          undefined,
+          undefined,
+          undefined,
+        );
+        expect(
+          screen.getByText(/default.some_test_metric/),
+        ).toBeInTheDocument();
+      },
+      { timeout: 10000 },
+    );
+
     // After successful creation, it should return a success message
     expect(screen.getByTestId('success')).toHaveTextContent(
       'Successfully created node default.some_test_metric',
     );
   }, 60000);
 
-  it('for editing a node', async () => {
+  it('for editing a transform or dimension node', async () => {
+    const mockDjClient = initializeMockDJClient();
+
+    mockDjClient.DataJunctionAPI.node.mockReturnValue(mocks.mockTransformNode);
+    mockDjClient.DataJunctionAPI.patchNode = jest.fn();
+    mockDjClient.DataJunctionAPI.patchNode.mockReturnValue({
+      status: 201,
+      json: { name: 'default.repair_order_transform', type: 'transform' },
+    });
+
+    mockDjClient.DataJunctionAPI.tagsNode.mockReturnValue({
+      status: 200,
+      json: { message: 'Success' },
+    });
+
+    mockDjClient.DataJunctionAPI.listTags.mockReturnValue([
+      { name: 'purpose', display_name: 'Purpose' },
+      { name: 'intent', display_name: 'Intent' },
+    ]);
+
+    const element = testElement(mockDjClient);
+    const { getByTestId } = renderEditTransformNode(element);
+
+    await userEvent.type(screen.getByLabelText('Display Name *'), '!!!');
+    await userEvent.type(screen.getByLabelText('Description'), '!!!');
+    await userEvent.click(screen.getByText('Save'));
+
+    const selectTags = getByTestId('select-tags');
+    fireEvent.keyDown(selectTags.firstChild, { key: 'ArrowDown' });
+    fireEvent.click(screen.getByText('Purpose'));
+
+    await waitFor(async () => {
+      expect(mockDjClient.DataJunctionAPI.patchNode).toBeCalledTimes(1);
+      expect(mockDjClient.DataJunctionAPI.patchNode).toBeCalledWith(
+        'default.repair_order_transform',
+        'Default: Repair Order Transform!!!',
+        'Repair order dimension!!!',
+        'SELECT repair_order_id, municipality_id, hard_hat_id, dispatcher_id FROM default.repair_orders',
+        'published',
+        [],
+        undefined,
+        undefined,
+        undefined,
+      );
+      expect(mockDjClient.DataJunctionAPI.tagsNode).toBeCalledTimes(1);
+      expect(mockDjClient.DataJunctionAPI.tagsNode).toBeCalledWith(
+        'default.repair_order_transform',
+        [],
+      );
+
+      expect(mockDjClient.DataJunctionAPI.listMetricMetadata).toBeCalledTimes(
+        0,
+      );
+      expect(
+        await screen.getByText(/Successfully updated transform node/),
+      ).toBeInTheDocument();
+    });
+  }, 1000000);
+
+  it('for editing a metric node', async () => {
     const mockDjClient = initializeMockDJClient();
 
     mockDjClient.DataJunctionAPI.node.mockReturnValue(mocks.mockMetricNode);
+    mockDjClient.DataJunctionAPI.metric.mockReturnValue(mocks.mockMetricNode);
     mockDjClient.DataJunctionAPI.patchNode = jest.fn();
     mockDjClient.DataJunctionAPI.patchNode.mockReturnValue({
       status: 201,
@@ -102,8 +237,8 @@ describe('AddEditNodePage submission succeeded', () => {
     await userEvent.click(screen.getByText('Save'));
 
     const selectTags = getByTestId('select-tags');
-    await fireEvent.keyDown(selectTags.firstChild, { key: 'ArrowDown' });
-    await fireEvent.click(screen.getByText('Purpose'));
+    fireEvent.keyDown(selectTags.firstChild, { key: 'ArrowDown' });
+    fireEvent.click(screen.getByText('Purpose'));
 
     await waitFor(async () => {
       expect(mockDjClient.DataJunctionAPI.patchNode).toBeCalledTimes(1);
@@ -111,11 +246,12 @@ describe('AddEditNodePage submission succeeded', () => {
         'default.num_repair_orders',
         'Default: Num Repair Orders!!!',
         'Number of repair orders!!!',
-        'SELECT count(repair_order_id) default_DOT_num_repair_orders FROM default.repair_orders',
+        'SELECT count(repair_order_id) FROM default.repair_orders',
         'published',
-        null,
+        [],
         'neutral',
         'unitless',
+        undefined,
       );
       expect(mockDjClient.DataJunctionAPI.tagsNode).toBeCalledTimes(1);
       expect(mockDjClient.DataJunctionAPI.tagsNode).toBeCalledWith(

package/src/app/pages/AddEditNodePage/__tests__/index.test.jsx

@@ -6,7 +6,6 @@ import fetchMock from 'jest-fetch-mock';
 import { AddEditNodePage } from '../index.jsx';
 import { mocks } from '../../../../mocks/mockNodes';
 import DJClientContext from '../../../providers/djclient';
-import userEvent from '@testing-library/user-event';
 
 fetchMock.enableMocks();
 
@@ -52,7 +51,13 @@ export const initializeMockDJClient = () => {
       patchNode: jest.fn(),
       node: jest.fn(),
       tagsNode: jest.fn(),
-      listTags: jest.fn(),
+      listTags: jest.fn().mockReturnValue([]),
+      metric: jest.fn().mockReturnValue(mocks.mockMetricNode),
+      nodesWithType: jest
+        .fn()
+        .mockReturnValueOnce(['a'])
+        .mockReturnValueOnce(['b'])
+        .mockReturnValueOnce(['default.repair_orders']),
       listMetricMetadata: jest.fn().mockReturnValue({
         directions: ['higher_is_better', 'lower_is_better', 'neutral'],
         units: [
@@ -82,6 +87,16 @@ export const renderCreateNode = element => {
   );
 };
 
+export const renderCreateMetric = element => {
+  return render(
+    <MemoryRouter initialEntries={['/create/metric/default']}>
+      <Routes>
+        <Route path="create/:nodeType/:initialNamespace" element={element} />
+      </Routes>
+    </MemoryRouter>,
+  );
+};
+
 export const renderEditNode = element => {
   return render(
     <MemoryRouter initialEntries={['/nodes/default.num_repair_orders/edit']}>
@@ -92,6 +107,18 @@ export const renderEditNode = element => {
   );
 };
 
+export const renderEditTransformNode = element => {
+  return render(
+    <MemoryRouter
+      initialEntries={['/nodes/default.repair_order_transform/edit']}
+    >
+      <Routes>
+        <Route path="nodes/:name/edit" element={element} />
+      </Routes>
+    </MemoryRouter>,
+  );
+};
+
 describe('AddEditNodePage', () => {
   beforeEach(() => {
     fetchMock.resetMocks();
@@ -135,12 +162,12 @@ describe('AddEditNodePage', () => {
       // The description should be populated
       expect(screen.getByText('Number of repair orders')).toBeInTheDocument();
 
-      // The query should be populated
-      expect(
-        screen.getByText(
-          'SELECT count(repair_order_id) default_DOT_num_repair_orders FROM default.repair_orders',
-        ),
-      ).toBeInTheDocument();
+      // The upstream node should be populated
+      expect(screen.getByText('default.repair_orders')).toBeInTheDocument();
+
+      // The aggregate expression should be populated
+      expect(screen.getByText('count')).toBeInTheDocument();
+      expect(screen.getByText('(repair_order_id)')).toBeInTheDocument();
     });
   });