datajunction-ui 0.0.1-a1 → 0.0.1-a101

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({
@@ -42,42 +44,179 @@ describe('AddEditNodePage submission succeeded', () => {
     const { container } = renderCreateNode(element);
 
     await userEvent.type(
-      screen.getByLabelText('Display Name'),
-      'Some Test Metric',
+      screen.getByLabelText('Display Name *'),
+      'Some Test Dim',
+    );
+    await userEvent.type(
+      screen.getByLabelText('Query *'),
+      'SELECT a, b, c FROM test',
     );
-    await userEvent.type(screen.getByLabelText('Query'), 'SELECT * FROM test');
     await userEvent.click(screen.getByText('Create dimension'));
 
     await waitFor(() => {
       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,
-      );
-      expect(mockDjClient.DataJunctionAPI.tagsNode).toBeCalled();
-      expect(mockDjClient.DataJunctionAPI.tagsNode).toBeCalledWith(
-        'default.some_test_metric',
+        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.mockMetricNode);
+    mockDjClient.DataJunctionAPI.getNodeForEditing.mockReturnValue(
+      mocks.mockGetTransformNode,
+    );
+    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,
+      );
+      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.getNodeForEditing.mockReturnValue(
+      mocks.mockGetMetricNode,
+    );
     mockDjClient.DataJunctionAPI.patchNode = jest.fn();
     mockDjClient.DataJunctionAPI.patchNode.mockReturnValue({
       status: 201,
@@ -97,13 +236,13 @@ describe('AddEditNodePage submission succeeded', () => {
     const element = testElement(mockDjClient);
     const { getByTestId } = renderEditNode(element);
 
-    await userEvent.type(screen.getByLabelText('Display Name'), '!!!');
+    await userEvent.type(screen.getByLabelText('Display Name *'), '!!!');
     await userEvent.type(screen.getByLabelText('Description'), '!!!');
     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,19 +250,23 @@ 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',
         ['repair_order_id', 'country'],
+        'neutral',
+        'unitless',
+        5,
+        undefined,
       );
       expect(mockDjClient.DataJunctionAPI.tagsNode).toBeCalledTimes(1);
       expect(mockDjClient.DataJunctionAPI.tagsNode).toBeCalledWith(
         'default.num_repair_orders',
-        [{ display_name: 'Purpose', name: 'purpose' }],
+        ['purpose'],
       );
 
-      expect(
-        await screen.getByDisplayValue('repair_order_id, country'),
-      ).toBeInTheDocument();
+      expect(mockDjClient.DataJunctionAPI.listMetricMetadata).toBeCalledTimes(
+        1,
+      );
       expect(
         await screen.getByText(/Successfully updated metric node/),
       ).toBeInTheDocument();

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();
 
@@ -36,6 +35,7 @@ export const initializeMockDJClient = () => {
         ];
       },
       metrics: {},
+      getNodeForEditing: jest.fn(),
       namespaces: () => {
         return [
           {
@@ -52,7 +52,20 @@ 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: [
+          { name: 'dollar', label: 'Dollar' },
+          { name: 'second', label: 'Second' },
+        ],
+      }),
     },
   };
 };
@@ -75,6 +88,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']}>
@@ -85,6 +108,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();
@@ -104,13 +139,17 @@ describe('AddEditNodePage', () => {
       ).toMatchSnapshot();
 
       // The namespace should be set to the one provided in params
-      expect(screen.getByText('default')).toBeInTheDocument();
+      screen
+        .getAllByText('default')
+        .forEach(element => expect(element).toBeInTheDocument());
     });
   });
 
   it('Edit node page renders with the selected node', async () => {
     const mockDjClient = initializeMockDJClient();
-    mockDjClient.DataJunctionAPI.node.mockReturnValue(mocks.mockMetricNode);
+    mockDjClient.DataJunctionAPI.getNodeForEditing.mockReturnValue(
+      mocks.mockGetMetricNode,
+    );
 
     const element = testElement(mockDjClient);
     renderEditNode(element);
@@ -128,28 +167,23 @@ 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();
     });
   });
 
   it('Verify edit page node not found', async () => {
     const mockDjClient = initializeMockDJClient();
-    mockDjClient.DataJunctionAPI.node = jest.fn();
-    mockDjClient.DataJunctionAPI.node.mockReturnValue({
-      message: 'A node with name `default.num_repair_orders` does not exist.',
-      errors: [],
-      warnings: [],
-    });
+    mockDjClient.DataJunctionAPI.getNodeForEditing.mockReturnValue(null);
     const element = testElement(mockDjClient);
     renderEditNode(element);
 
     await waitFor(() => {
-      expect(mockDjClient.DataJunctionAPI.node).toBeCalledTimes(1);
+      expect(mockDjClient.DataJunctionAPI.getNodeForEditing).toBeCalledTimes(1);
       expect(
         screen.getByText('Node default.num_repair_orders does not exist!'),
       ).toBeInTheDocument();
@@ -158,18 +192,14 @@ describe('AddEditNodePage', () => {
 
   it('Verify only transforms, metrics, and dimensions can be edited', async () => {
     const mockDjClient = initializeMockDJClient();
-    mockDjClient.DataJunctionAPI.node = jest.fn();
-    mockDjClient.DataJunctionAPI.node.mockReturnValue({
-      namespace: 'default',
-      type: 'source',
-      name: 'default.repair_orders',
-      display_name: 'Default: Repair Orders',
-    });
+    mockDjClient.DataJunctionAPI.getNodeForEditing.mockReturnValue(
+      mocks.mockGetSourceNode,
+    );
     const element = testElement(mockDjClient);
     renderEditNode(element);
 
     await waitFor(() => {
-      expect(mockDjClient.DataJunctionAPI.node).toBeCalledTimes(1);
+      expect(mockDjClient.DataJunctionAPI.getNodeForEditing).toBeCalledTimes(1);
       expect(
         screen.getByText(
           'Node default.num_repair_orders is of type source and cannot be edited',