datajunction-ui 0.0.44 → 0.0.45

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

@@ -324,37 +324,6 @@ describe('QueryPlannerPage', () => {
         expect(screen.getByText('num_repair_orders')).toBeInTheDocument();
       });
     });
-
-    it('shows clear button when search has value', async () => {
-      renderPage();
-
-      await waitFor(() => {
-        expect(mockDjClient.metrics).toHaveBeenCalled();
-      });
-
-      const searchInput = screen.getByPlaceholderText('Search metrics...');
-      fireEvent.change(searchInput, { target: { value: 'test' } });
-
-      // Clear button should appear
-      const clearButton = screen.getAllByText('×')[0];
-      expect(clearButton).toBeInTheDocument();
-    });
-
-    it('clears search when clear button is clicked', async () => {
-      renderPage();
-
-      await waitFor(() => {
-        expect(mockDjClient.metrics).toHaveBeenCalled();
-      });
-
-      const searchInput = screen.getByPlaceholderText('Search metrics...');
-      fireEvent.change(searchInput, { target: { value: 'test' } });
-
-      const clearButton = screen.getAllByText('×')[0];
-      fireEvent.click(clearButton);
-
-      expect(searchInput.value).toBe('');
-    });
   });
 
   describe('Cube Preset Loading', () => {
@@ -678,7 +647,7 @@ describe('QueryPlannerPage', () => {
   });
 
   describe('Clear Selection', () => {
-    it('clears all selections when Clear all is clicked', async () => {
+    it('clears all selections when Clear is clicked', async () => {
       mockDjClient.cubeForPlanner.mockResolvedValue(mockCubeData);
 
       renderPage();
@@ -700,8 +669,8 @@ describe('QueryPlannerPage', () => {
         expect(mockDjClient.commonDimensions).toHaveBeenCalled();
       });
 
-      // Click Clear all
-      const clearButton = screen.getByText('Clear all');
+      // Click the global Clear button (clear-all-btn class)
+      const clearButton = document.querySelector('.clear-all-btn');
       fireEvent.click(clearButton);
 
       // Should show "Load from Cube" again (cube unloaded)
@@ -739,4 +708,721 @@ describe('QueryPlannerPage', () => {
       });
     });
   });
+
+  describe('Filter Handling', () => {
+    it('adds a filter when add filter button is clicked', async () => {
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+
+      // Find filter input and add a filter
+      const filterInput = screen.getByPlaceholderText(
+        /e\.g\. v3\.date\.date_id/i,
+      );
+      fireEvent.change(filterInput, {
+        target: { value: "date_id >= '2024-01-01'" },
+      });
+
+      const addButton = screen.getByText('Add');
+      fireEvent.click(addButton);
+
+      // Filter should be added (check for chip)
+      await waitFor(() => {
+        expect(screen.getByText("date_id >= '2024-01-01'")).toBeInTheDocument();
+      });
+    });
+
+    it('removes a filter when remove button is clicked', async () => {
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+
+      // Add a filter first
+      const filterInput = screen.getByPlaceholderText(
+        /e\.g\. v3\.date\.date_id/i,
+      );
+      fireEvent.change(filterInput, {
+        target: { value: "status = 'active'" },
+      });
+      fireEvent.click(screen.getByText('Add'));
+
+      await waitFor(() => {
+        expect(screen.getByText("status = 'active'")).toBeInTheDocument();
+      });
+
+      // Remove the filter (button has generic title "Remove filter")
+      const removeButton = screen.getByTitle('Remove filter');
+      fireEvent.click(removeButton);
+
+      await waitFor(() => {
+        expect(screen.queryByText("status = 'active'")).not.toBeInTheDocument();
+      });
+    });
+
+    it('disables add button when filter input is empty', async () => {
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+
+      const addButton = screen.getByText('Add');
+      expect(addButton).toBeDisabled();
+    });
+  });
+
+  describe('Run Query', () => {
+    beforeEach(() => {
+      mockDjClient.metricsV3.mockResolvedValue({
+        sql: 'SELECT * FROM metrics',
+        dialect: 'SPARK',
+        cube_name: null,
+      });
+    });
+
+    it('shows Run Query button when metrics and dimensions selected', async () => {
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+
+      // Select metric
+      fireEvent.click(screen.getByText('default'));
+      await waitFor(() => {
+        fireEvent.click(
+          screen.getByRole('checkbox', { name: /num_repair_orders/i }),
+        );
+      });
+
+      await waitFor(() => {
+        expect(mockDjClient.commonDimensions).toHaveBeenCalled();
+      });
+
+      // Select dimension
+      fireEvent.click(screen.getByRole('checkbox', { name: /dateint/i }));
+
+      // Run Query button should exist
+      await waitFor(() => {
+        expect(screen.getByText('Run Query')).toBeInTheDocument();
+      });
+    });
+
+    it('disables Run Query button when no metrics selected', async () => {
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+
+      const runButton = screen.getByText('Run Query');
+      expect(runButton).toBeDisabled();
+    });
+  });
+
+  describe('Materialization Handlers', () => {
+    const mockMeasuresResult = {
+      grainGroups: [
+        {
+          node: 'default.repair_orders',
+          grain_columns: ['default.date_dim.dateint'],
+          measures: [
+            { name: 'sum_revenue', expression: 'SUM(revenue)' },
+            { name: 'count_orders', expression: 'COUNT(*)' },
+          ],
+        },
+      ],
+      metricFormulas: [
+        {
+          metric: 'default.num_repair_orders',
+          formula: 'default.repair_orders.count_orders',
+        },
+      ],
+    };
+
+    beforeEach(() => {
+      mockDjClient.measuresV3.mockResolvedValue(mockMeasuresResult);
+      mockDjClient.metricsV3.mockResolvedValue({
+        sql: 'SELECT * FROM metrics',
+        dialect: 'SPARK',
+        cube_name: null,
+      });
+      mockDjClient.listPreaggs.mockResolvedValue({ items: [] });
+      mockDjClient.getNodeColumnsWithPartitions.mockResolvedValue({
+        columns: [],
+        temporalPartitions: [],
+      });
+    });
+
+    it('calls planPreaggs when materialization is planned', async () => {
+      mockDjClient.planPreaggs.mockResolvedValue({
+        preaggs: [
+          {
+            id: 1,
+            node_name: 'default.repair_orders',
+            grain_columns: ['default.date_dim.dateint'],
+          },
+        ],
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+
+      // Select metric and dimension
+      fireEvent.click(screen.getByText('default'));
+      await waitFor(() => {
+        fireEvent.click(
+          screen.getByRole('checkbox', { name: /num_repair_orders/i }),
+        );
+      });
+
+      await waitFor(() => {
+        expect(mockDjClient.commonDimensions).toHaveBeenCalled();
+      });
+
+      fireEvent.click(screen.getByRole('checkbox', { name: /dateint/i }));
+
+      await waitFor(() => {
+        expect(mockDjClient.measuresV3).toHaveBeenCalled();
+      });
+    });
+
+    it('handles planPreaggs error gracefully', async () => {
+      mockDjClient.planPreaggs.mockResolvedValue({
+        _error: true,
+        message: 'Failed to plan',
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+    });
+
+    it('calls materializePreagg when workflow is created', async () => {
+      mockDjClient.planPreaggs.mockResolvedValue({
+        preaggs: [
+          {
+            id: 123,
+            node_name: 'default.repair_orders',
+            grain_columns: ['default.date_dim.dateint'],
+          },
+        ],
+      });
+      mockDjClient.materializePreagg.mockResolvedValue({
+        workflow_urls: ['http://workflow.example.com'],
+        workflow_status: 'active',
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+    });
+
+    it('handles materializePreagg error', async () => {
+      mockDjClient.materializePreagg.mockResolvedValue({
+        _error: true,
+        message: 'Failed to create workflow',
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+    });
+
+    it('calls runPreaggBackfill when backfill is triggered', async () => {
+      mockDjClient.runPreaggBackfill.mockResolvedValue({
+        job_url: 'http://job.example.com',
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+    });
+
+    it('handles runPreaggBackfill error', async () => {
+      mockDjClient.runPreaggBackfill.mockResolvedValue({
+        _error: true,
+        message: 'Backfill failed',
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+    });
+
+    it('calls updatePreaggConfig for config updates', async () => {
+      mockDjClient.updatePreaggConfig.mockResolvedValue({
+        id: 123,
+        strategy: 'incremental_time',
+        schedule: '0 6 * * *',
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+    });
+
+    it('handles updatePreaggConfig error', async () => {
+      mockDjClient.updatePreaggConfig.mockResolvedValue({
+        _error: true,
+        message: 'Config update failed',
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+    });
+
+    it('calls deactivatePreaggWorkflow when workflow is deactivated', async () => {
+      mockDjClient.deactivatePreaggWorkflow.mockResolvedValue({
+        success: true,
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+    });
+
+    it('handles deactivatePreaggWorkflow error', async () => {
+      mockDjClient.deactivatePreaggWorkflow.mockResolvedValue({
+        _error: true,
+        message: 'Failed to deactivate',
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('Cube Materialization Flow', () => {
+    beforeEach(() => {
+      mockDjClient.listCubesForPreset.mockResolvedValue([
+        { name: 'default.test_cube', display_name: 'Test Cube' },
+      ]);
+      mockDjClient.cubeForPlanner.mockResolvedValue({
+        name: 'default.test_cube',
+        display_name: 'Test Cube',
+        cube_node_metrics: ['default.num_repair_orders'],
+        cube_node_dimensions: ['default.date_dim.dateint'],
+        cubeMaterialization: {
+          strategy: 'full',
+          schedule: '0 6 * * *',
+          lookbackWindow: null,
+          druidDatasource: 'test_ds',
+          preaggTables: [],
+          workflowUrls: ['http://workflow.url'],
+        },
+        availability: null,
+      });
+    });
+
+    it('calls createCube when new cube is created', async () => {
+      mockDjClient.createCube.mockResolvedValue({
+        status: 200,
+        json: { name: 'new.cube' },
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.listCubesForPreset).toHaveBeenCalled();
+      });
+    });
+
+    it('handles createCube error - cube already exists', async () => {
+      mockDjClient.createCube.mockResolvedValue({
+        status: 400,
+        json: { message: 'Cube already exists' },
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.listCubesForPreset).toHaveBeenCalled();
+      });
+    });
+
+    it('handles createCube error - other error', async () => {
+      mockDjClient.createCube.mockResolvedValue({
+        status: 500,
+        json: { message: 'Server error' },
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.listCubesForPreset).toHaveBeenCalled();
+      });
+    });
+
+    it('calls materializeCubeV2 for cube materialization', async () => {
+      mockDjClient.materializeCubeV2.mockResolvedValue({
+        status: 200,
+        json: {
+          workflow_urls: ['http://cube-workflow.example.com'],
+        },
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.listCubesForPreset).toHaveBeenCalled();
+      });
+    });
+
+    it('handles materializeCubeV2 error', async () => {
+      mockDjClient.materializeCubeV2.mockResolvedValue({
+        status: 500,
+        json: { message: 'Cube materialization failed' },
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.listCubesForPreset).toHaveBeenCalled();
+      });
+    });
+
+    it('calls refreshCubeWorkflow for config updates', async () => {
+      mockDjClient.refreshCubeWorkflow.mockResolvedValue({
+        status: 200,
+        json: { workflow_urls: ['http://updated-workflow.url'] },
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.listCubesForPreset).toHaveBeenCalled();
+      });
+    });
+
+    it('handles refreshCubeWorkflow error', async () => {
+      mockDjClient.refreshCubeWorkflow.mockResolvedValue({
+        status: 500,
+        json: { message: 'Refresh failed' },
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.listCubesForPreset).toHaveBeenCalled();
+      });
+    });
+
+    it('calls deactivateCubeWorkflow when deactivating', async () => {
+      mockDjClient.deactivateCubeWorkflow.mockResolvedValue({
+        status: 200,
+        json: { success: true },
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.listCubesForPreset).toHaveBeenCalled();
+      });
+
+      // Load cube first
+      fireEvent.click(screen.getByText('Load from Cube'));
+      fireEvent.click(screen.getByText('Test Cube'));
+
+      await waitFor(() => {
+        expect(mockDjClient.cubeForPlanner).toHaveBeenCalled();
+      });
+    });
+
+    it('handles deactivateCubeWorkflow error', async () => {
+      mockDjClient.deactivateCubeWorkflow.mockResolvedValue({
+        status: 500,
+        json: { message: 'Deactivation failed' },
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.listCubesForPreset).toHaveBeenCalled();
+      });
+    });
+
+    it('calls runCubeBackfill for backfill', async () => {
+      mockDjClient.runCubeBackfill.mockResolvedValue({
+        job_url: 'http://backfill-job.example.com',
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.listCubesForPreset).toHaveBeenCalled();
+      });
+
+      // Load cube
+      fireEvent.click(screen.getByText('Load from Cube'));
+      fireEvent.click(screen.getByText('Test Cube'));
+
+      await waitFor(() => {
+        expect(mockDjClient.cubeForPlanner).toHaveBeenCalled();
+      });
+    });
+
+    it('handles runCubeBackfill error', async () => {
+      mockDjClient.runCubeBackfill.mockResolvedValue({
+        _error: true,
+        message: 'Backfill failed',
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.listCubesForPreset).toHaveBeenCalled();
+      });
+    });
+
+    it('handles runCubeBackfill with missing cube name', async () => {
+      // Don't load any cube - loadedCubeName will be null
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+
+      // No cube loaded, so runCubeBackfill shouldn't be callable
+    });
+  });
+
+  describe('Workflow Status Updates', () => {
+    const mockMeasuresWithPreagg = {
+      grainGroups: [
+        {
+          node: 'default.repair_orders',
+          grain_columns: ['default.date_dim.dateint'],
+          measures: [{ name: 'count_orders', expression: 'COUNT(*)' }],
+        },
+      ],
+      metricFormulas: [
+        {
+          metric: 'default.num_repair_orders',
+          formula: 'count_orders',
+        },
+      ],
+    };
+
+    beforeEach(() => {
+      mockDjClient.measuresV3.mockResolvedValue(mockMeasuresWithPreagg);
+      mockDjClient.metricsV3.mockResolvedValue({
+        sql: 'SELECT * FROM metrics',
+        dialect: 'SPARK',
+        cube_name: null,
+      });
+      mockDjClient.listPreaggs.mockResolvedValue({ items: [] });
+    });
+
+    it('updates state when workflow is created successfully', async () => {
+      mockDjClient.materializePreagg.mockResolvedValue({
+        workflow_urls: ['http://new-workflow.example.com'],
+        workflow_status: 'active',
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+    });
+
+    it('updates state when workflow is deactivated', async () => {
+      mockDjClient.deactivatePreaggWorkflow.mockResolvedValue({
+        success: true,
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+    });
+
+    it('handles network errors in workflow operations', async () => {
+      mockDjClient.materializePreagg.mockRejectedValue(
+        new Error('Network error'),
+      );
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('Raw SQL Fetching', () => {
+    it('fetches raw SQL when needed', async () => {
+      mockDjClient.metricsV3.mockResolvedValue({
+        sql: 'SELECT * FROM raw_tables',
+        dialect: 'SPARK',
+        cube_name: null,
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+
+      // Select metric and dimension to trigger SQL fetch
+      fireEvent.click(screen.getByText('default'));
+      await waitFor(() => {
+        fireEvent.click(
+          screen.getByRole('checkbox', { name: /num_repair_orders/i }),
+        );
+      });
+
+      await waitFor(() => {
+        expect(mockDjClient.commonDimensions).toHaveBeenCalled();
+      });
+
+      fireEvent.click(screen.getByRole('checkbox', { name: /dateint/i }));
+
+      await waitFor(() => {
+        expect(mockDjClient.metricsV3).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('Cube Workflow Handlers', () => {
+    beforeEach(() => {
+      mockDjClient.listCubesForPreset.mockResolvedValue([
+        { name: 'default.test_cube', display_name: 'Test Cube' },
+      ]);
+    });
+
+    it('handles cube deactivation', async () => {
+      mockDjClient.cubeForPlanner.mockResolvedValue({
+        name: 'default.test_cube',
+        display_name: 'Test Cube',
+        cube_node_metrics: ['default.num_repair_orders'],
+        cube_node_dimensions: ['default.date_dim.dateint'],
+        cubeMaterialization: {
+          strategy: 'full',
+          schedule: '0 6 * * *',
+          lookbackWindow: null,
+          druidDatasource: 'test_ds',
+          preaggTables: [],
+          workflowUrls: ['http://workflow.url'],
+        },
+        availability: null,
+      });
+      mockDjClient.deactivateCubeWorkflow.mockResolvedValue({ success: true });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.listCubesForPreset).toHaveBeenCalled();
+      });
+
+      // Load cube
+      fireEvent.click(screen.getByText('Load from Cube'));
+      fireEvent.click(screen.getByText('Test Cube'));
+
+      await waitFor(() => {
+        expect(mockDjClient.cubeForPlanner).toHaveBeenCalled();
+      });
+    });
+
+    it('handles cube backfill', async () => {
+      mockDjClient.cubeForPlanner.mockResolvedValue({
+        name: 'default.test_cube',
+        display_name: 'Test Cube',
+        cube_node_metrics: ['default.num_repair_orders'],
+        cube_node_dimensions: ['default.date_dim.dateint'],
+        cubeMaterialization: {
+          strategy: 'full',
+          schedule: '0 6 * * *',
+          lookbackWindow: null,
+          druidDatasource: 'test_ds',
+          preaggTables: [],
+          workflowUrls: [],
+        },
+        availability: null,
+      });
+      mockDjClient.runCubeBackfill.mockResolvedValue({ job_url: 'http://job' });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.listCubesForPreset).toHaveBeenCalled();
+      });
+
+      // Load cube
+      fireEvent.click(screen.getByText('Load from Cube'));
+      fireEvent.click(screen.getByText('Test Cube'));
+
+      await waitFor(() => {
+        expect(mockDjClient.cubeForPlanner).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('Partition Handling', () => {
+    it('fetches node partitions when needed', async () => {
+      mockDjClient.getNodeColumnsWithPartitions.mockResolvedValue({
+        columns: [{ name: 'date_col', type: 'date' }],
+        temporalPartitions: [{ column: 'date_col' }],
+      });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+    });
+
+    it('handles setPartition call', async () => {
+      mockDjClient.setPartition.mockResolvedValue({ success: true });
+
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('Results View Navigation', () => {
+    it('shows results view hint when no selection', async () => {
+      renderPage();
+
+      await waitFor(() => {
+        expect(mockDjClient.metrics).toHaveBeenCalled();
+      });
+
+      expect(
+        screen.getByText('Select metrics and dimensions to run a query'),
+      ).toBeInTheDocument();
+    });
+  });
 });