datajunction-ui 0.0.27-alpha.0 → 0.0.29

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

@@ -253,3 +253,180 @@ describe('SQLBuilderPage - Data fetching', () => {
     });
   });
 });
+
+describe('SQLBuilderPage - Data execution and display', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockDjClient.metrics.mockResolvedValue(mockMetrics);
+    mockDjClient.commonDimensions.mockResolvedValue(mockCommonDimensions);
+    mockDjClient.sqls.mockResolvedValue({
+      sql: 'SELECT dateint, SUM(metric) FROM table GROUP BY 1',
+    });
+    mockDjClient.data.mockResolvedValue({});
+  });
+
+  it('handles dimensions with bool type by setting valueEditorType', async () => {
+    mockDjClient.commonDimensions.mockResolvedValue(mockDimensionsWithBool);
+
+    render(
+      <DJClientContext.Provider value={{ DataJunctionAPI: mockDjClient }}>
+        <SQLBuilderPage />
+      </DJClientContext.Provider>,
+    );
+
+    await waitFor(() => {
+      expect(mockDjClient.metrics).toHaveBeenCalled();
+    });
+
+    // Select metric to trigger commonDimensions fetch
+    const selectMetrics = screen.getAllByTestId('select-metrics')[0];
+    fireEvent.keyDown(selectMetrics.firstChild, { key: 'ArrowDown' });
+    await waitFor(() => {
+      expect(screen.getByText('default.num_repair_orders')).toBeInTheDocument();
+    });
+    fireEvent.click(screen.getByText('default.num_repair_orders'));
+
+    // Close menu to trigger onMenuClose and fetch dimensions
+    fireEvent.keyDown(selectMetrics.firstChild, { key: 'Escape' });
+
+    // Bool dimension should be processed (attributeToFormInput handles bool)
+    await waitFor(() => {
+      expect(mockDjClient.commonDimensions).toHaveBeenCalled();
+    });
+  });
+
+  it('handles timestamp dimensions with datetime input type', async () => {
+    render(
+      <DJClientContext.Provider value={{ DataJunctionAPI: mockDjClient }}>
+        <SQLBuilderPage />
+      </DJClientContext.Provider>,
+    );
+
+    await waitFor(() => {
+      expect(mockDjClient.metrics).toHaveBeenCalled();
+    });
+
+    // Select metric
+    const selectMetrics = screen.getAllByTestId('select-metrics')[0];
+    fireEvent.keyDown(selectMetrics.firstChild, { key: 'ArrowDown' });
+    await waitFor(() => {
+      expect(screen.getByText('default.num_repair_orders')).toBeInTheDocument();
+    });
+    fireEvent.click(screen.getByText('default.num_repair_orders'));
+
+    // Close menu to trigger onMenuClose
+    fireEvent.keyDown(selectMetrics.firstChild, { key: 'Escape' });
+
+    // Timestamp dimensions should be processed
+    await waitFor(() => {
+      expect(mockDjClient.commonDimensions).toHaveBeenCalled();
+    });
+  });
+
+  it('clears dimensions list when selectedMetrics becomes empty', async () => {
+    render(
+      <DJClientContext.Provider value={{ DataJunctionAPI: mockDjClient }}>
+        <SQLBuilderPage />
+      </DJClientContext.Provider>,
+    );
+
+    await waitFor(() => {
+      expect(mockDjClient.metrics).toHaveBeenCalled();
+    });
+
+    // The dimensions section should show 0 when no metrics selected
+    expect(screen.getAllByText('0 Shared Dimensions')[0]).toBeInTheDocument();
+  });
+
+  it('updates displayedRows when showNumRows changes', async () => {
+    const mockDataResponse = {
+      id: 'query-123',
+      results: [
+        {
+          columns: [{ name: 'dateint' }, { name: 'total' }],
+          rows: Array.from({ length: 150 }, (_, i) => [`date_${i}`, i * 10]),
+        },
+      ],
+    };
+
+    mockDjClient.data.mockResolvedValue(mockDataResponse);
+
+    render(
+      <DJClientContext.Provider value={{ DataJunctionAPI: mockDjClient }}>
+        <SQLBuilderPage />
+      </DJClientContext.Provider>,
+    );
+
+    await waitFor(() => {
+      expect(mockDjClient.metrics).toHaveBeenCalled();
+    });
+
+    // The data display and row selection functionality is triggered after query runs
+    // Since the test environment doesn't fully support the Select component interactions,
+    // we verify that the component renders without errors
+    expect(screen.getByText('Using the SQL Builder')).toBeInTheDocument();
+  });
+
+  it('shows instruction card initially and hides when query is present', async () => {
+    render(
+      <DJClientContext.Provider value={{ DataJunctionAPI: mockDjClient }}>
+        <SQLBuilderPage />
+      </DJClientContext.Provider>,
+    );
+
+    await waitFor(() => {
+      expect(mockDjClient.metrics).toHaveBeenCalled();
+    });
+
+    // Initially shows instruction card
+    expect(screen.getByText('Using the SQL Builder')).toBeInTheDocument();
+    expect(
+      screen.getByText(/Start by selecting one or more/),
+    ).toBeInTheDocument();
+  });
+});
+
+describe('SQLBuilderPage - Query generation', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockDjClient.metrics.mockResolvedValue(mockMetrics);
+    mockDjClient.commonDimensions.mockResolvedValue(mockCommonDimensions);
+    mockDjClient.sqls.mockResolvedValue({
+      sql: 'SELECT dateint, SUM(metric) FROM table GROUP BY 1',
+    });
+    mockDjClient.data.mockResolvedValue({});
+  });
+
+  it('resets view when metrics selection changes', async () => {
+    render(
+      <DJClientContext.Provider value={{ DataJunctionAPI: mockDjClient }}>
+        <SQLBuilderPage />
+      </DJClientContext.Provider>,
+    );
+
+    await waitFor(() => {
+      expect(mockDjClient.metrics).toHaveBeenCalled();
+    });
+
+    // Select first metric
+    const selectMetrics = screen.getAllByTestId('select-metrics')[0];
+    fireEvent.keyDown(selectMetrics.firstChild, { key: 'ArrowDown' });
+    await waitFor(() => {
+      expect(screen.getByText('default.num_repair_orders')).toBeInTheDocument();
+    });
+    fireEvent.click(screen.getByText('default.num_repair_orders'));
+
+    // Select another metric
+    fireEvent.keyDown(selectMetrics.firstChild, { key: 'ArrowDown' });
+    await waitFor(() => {
+      expect(screen.getByText('default.avg_repair_price')).toBeInTheDocument();
+    });
+    fireEvent.click(screen.getByText('default.avg_repair_price'));
+
+    fireEvent.keyDown(selectMetrics.firstChild, { key: 'Escape' });
+
+    await waitFor(() => {
+      expect(mockDjClient.commonDimensions).toHaveBeenCalled();
+    });
+  });
+});

package/src/app/pages/SettingsPage/__tests__/CreateServiceAccountModal.test.jsx

@@ -352,4 +352,54 @@ describe('CreateServiceAccountModal', () => {
 
     expect(navigator.clipboard.writeText).toHaveBeenCalledWith('secret-xyz');
   });
+
+  it('does not call onCreate when form is submitted with only whitespace', async () => {
+    render(
+      <CreateServiceAccountModal
+        isOpen={true}
+        onClose={mockOnClose}
+        onCreate={mockOnCreate}
+      />,
+    );
+
+    const input = screen.getByLabelText('Name');
+    // Enter only whitespace
+    fireEvent.change(input, { target: { value: '   ' } });
+
+    // Get the form and submit it directly
+    const form = document.querySelector('form');
+    fireEvent.submit(form);
+
+    // onCreate should not be called for whitespace-only names
+    expect(mockOnCreate).not.toHaveBeenCalled();
+  });
+
+  it('clears name input after successful creation', async () => {
+    const credentials = {
+      name: 'my-account',
+      client_id: 'abc-123',
+      client_secret: 'secret-xyz',
+    };
+    mockOnCreate.mockResolvedValue(credentials);
+
+    render(
+      <CreateServiceAccountModal
+        isOpen={true}
+        onClose={mockOnClose}
+        onCreate={mockOnCreate}
+      />,
+    );
+
+    const input = screen.getByLabelText('Name');
+    fireEvent.change(input, { target: { value: 'my-account' } });
+    fireEvent.click(screen.getByText('Create'));
+
+    await waitFor(() => {
+      expect(screen.getByText('Service Account Created!')).toBeInTheDocument();
+    });
+
+    // After showing credentials view, the name input is no longer visible
+    // The name was cleared after successful creation (line 21)
+    expect(mockOnCreate).toHaveBeenCalledWith('my-account');
+  });
 });

package/src/app/pages/SettingsPage/__tests__/NotificationSubscriptionsSection.test.jsx

@@ -230,4 +230,99 @@ describe('NotificationSubscriptionsSection', () => {
 
     expect(screen.getByText('namespace')).toBeInTheDocument();
   });
+
+  it('handles onUpdate error gracefully', async () => {
+    const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+    window.alert = jest.fn();
+    mockOnUpdate.mockRejectedValue(new Error('Update failed'));
+
+    render(
+      <NotificationSubscriptionsSection
+        subscriptions={mockSubscriptions}
+        onUpdate={mockOnUpdate}
+        onUnsubscribe={mockOnUnsubscribe}
+      />,
+    );
+
+    const editButtons = screen.getAllByTitle('Edit subscription');
+    fireEvent.click(editButtons[0]);
+
+    fireEvent.click(screen.getByText('Save'));
+
+    await waitFor(() => {
+      expect(consoleSpy).toHaveBeenCalled();
+      expect(window.alert).toHaveBeenCalledWith(
+        'Failed to update subscription',
+      );
+    });
+
+    consoleSpy.mockRestore();
+  });
+
+  it('handles onUnsubscribe error gracefully', async () => {
+    const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+    window.confirm = jest.fn().mockReturnValue(true);
+    mockOnUnsubscribe.mockRejectedValue(new Error('Unsubscribe failed'));
+
+    render(
+      <NotificationSubscriptionsSection
+        subscriptions={mockSubscriptions}
+        onUpdate={mockOnUpdate}
+        onUnsubscribe={mockOnUnsubscribe}
+      />,
+    );
+
+    const unsubscribeButtons = screen.getAllByTitle('Unsubscribe');
+    fireEvent.click(unsubscribeButtons[0]);
+
+    await waitFor(() => {
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+
+    consoleSpy.mockRestore();
+  });
+
+  it('shows "All" when subscription has no activity_types', () => {
+    const subscriptionsWithoutActivityTypes = [
+      {
+        entity_name: 'default.some_node',
+        entity_type: 'node',
+        node_type: 'metric',
+        activity_types: null,
+        status: 'valid',
+      },
+    ];
+
+    render(
+      <NotificationSubscriptionsSection
+        subscriptions={subscriptionsWithoutActivityTypes}
+        onUpdate={mockOnUpdate}
+        onUnsubscribe={mockOnUnsubscribe}
+      />,
+    );
+
+    expect(screen.getByText('All')).toBeInTheDocument();
+  });
+
+  it('shows "All" when subscription has undefined activity_types', () => {
+    const subscriptionsWithUndefinedActivityTypes = [
+      {
+        entity_name: 'default.other_node',
+        entity_type: 'node',
+        node_type: 'dimension',
+        status: 'valid',
+        // activity_types not defined
+      },
+    ];
+
+    render(
+      <NotificationSubscriptionsSection
+        subscriptions={subscriptionsWithUndefinedActivityTypes}
+        onUpdate={mockOnUpdate}
+        onUnsubscribe={mockOnUnsubscribe}
+      />,
+    );
+
+    expect(screen.getByText('All')).toBeInTheDocument();
+  });
 });