@object-ui/plugin-dashboard 3.3.0 → 3.3.1

package/src/__tests__/ObjectMetricWidget.test.tsx

@@ -1,196 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { render, screen, waitFor } from '@testing-library/react';
-import React from 'react';
-import '@testing-library/jest-dom';
-import { ObjectMetricWidget } from '../ObjectMetricWidget';
-import { SchemaRendererProvider } from '@object-ui/react';
-
-// Suppress console.error from expected fetch errors
-const originalConsoleError = console.error;
-beforeEach(() => {
-  console.error = vi.fn();
-});
-afterEach(() => {
-  console.error = originalConsoleError;
-});
-
-describe('ObjectMetricWidget', () => {
-  const baseProps = {
-    objectName: 'opportunity',
-    label: 'Total Revenue',
-    fallbackValue: '$652,000',
-    icon: 'DollarSign',
-  };
-
-  it('should show fallback value when no dataSource is available', () => {
-    render(<ObjectMetricWidget {...baseProps} />);
-
-    expect(screen.getByText('Total Revenue')).toBeInTheDocument();
-    expect(screen.getByText('$652,000')).toBeInTheDocument();
-  });
-
-  it('should show loading state while fetching', async () => {
-    const dataSource = {
-      find: vi.fn(() => new Promise(() => {})), // Never resolves
-    };
-
-    const { container } = render(
-      <SchemaRendererProvider dataSource={dataSource}>
-        <ObjectMetricWidget {...baseProps} />
-      </SchemaRendererProvider>,
-    );
-
-    await waitFor(() => {
-      const loadingEl = container.querySelector('[data-testid="metric-loading"]');
-      expect(loadingEl).toBeTruthy();
-    });
-  });
-
-  it('should show error state when data fetch fails', async () => {
-    const dataSource = {
-      find: vi.fn().mockRejectedValue(new Error('Cube name is required')),
-    };
-
-    const { container } = render(
-      <SchemaRendererProvider dataSource={dataSource}>
-        <ObjectMetricWidget {...baseProps} />
-      </SchemaRendererProvider>,
-    );
-
-    await waitFor(() => {
-      const errorEl = container.querySelector('[data-testid="metric-error"]');
-      expect(errorEl).toBeTruthy();
-    });
-
-    expect(screen.getByText('Cube name is required')).toBeInTheDocument();
-  });
-
-  it('should show error state when aggregate fails', async () => {
-    const dataSource = {
-      aggregate: vi.fn().mockRejectedValue(new Error('Connection refused')),
-      find: vi.fn(),
-    };
-
-    const propsWithAggregate = {
-      ...baseProps,
-      aggregate: { field: 'amount', function: 'sum', groupBy: 'stage' },
-    };
-
-    const { container } = render(
-      <SchemaRendererProvider dataSource={dataSource}>
-        <ObjectMetricWidget {...propsWithAggregate} />
-      </SchemaRendererProvider>,
-    );
-
-    await waitFor(() => {
-      const errorEl = container.querySelector('[data-testid="metric-error"]');
-      expect(errorEl).toBeTruthy();
-    });
-
-    expect(screen.getByText('Connection refused')).toBeInTheDocument();
-  });
-
-  it('should display fetched value from find()', async () => {
-    const dataSource = {
-      find: vi.fn().mockResolvedValue({
-        data: [
-          { name: 'A', amount: 100 },
-          { name: 'B', amount: 200 },
-          { name: 'C', amount: 300 },
-        ],
-      }),
-    };
-
-    render(
-      <SchemaRendererProvider dataSource={dataSource}>
-        <ObjectMetricWidget {...baseProps} />
-      </SchemaRendererProvider>,
-    );
-
-    // When no aggregate config, it falls back to counting records
-    await waitFor(() => {
-      expect(screen.getByText('3')).toBeInTheDocument();
-    });
-  });
-
-  it('should display aggregated value from aggregate()', async () => {
-    const dataSource = {
-      aggregate: vi.fn().mockResolvedValue([
-        { stage: 'All', amount: 652000 },
-      ]),
-      find: vi.fn(),
-    };
-
-    const propsWithAggregate = {
-      ...baseProps,
-      aggregate: { field: 'amount', function: 'sum', groupBy: '_all' },
-    };
-
-    render(
-      <SchemaRendererProvider dataSource={dataSource}>
-        <ObjectMetricWidget {...propsWithAggregate} />
-      </SchemaRendererProvider>,
-    );
-
-    await waitFor(() => {
-      expect(screen.getByText('652000')).toBeInTheDocument();
-    });
-
-    // Should have called aggregate, not find
-    expect(dataSource.aggregate).toHaveBeenCalledWith('opportunity', {
-      field: 'amount',
-      function: 'sum',
-      groupBy: '_all',
-      filter: undefined,
-    });
-  });
-
-  it('should render label even in error state', async () => {
-    const dataSource = {
-      find: vi.fn().mockRejectedValue(new Error('Server error')),
-    };
-
-    render(
-      <SchemaRendererProvider dataSource={dataSource}>
-        <ObjectMetricWidget {...baseProps} />
-      </SchemaRendererProvider>,
-    );
-
-    await waitFor(() => {
-      expect(screen.getByText('Server error')).toBeInTheDocument();
-    });
-
-    // Label should still be visible
-    expect(screen.getByText('Total Revenue')).toBeInTheDocument();
-  });
-
-  it('should use prop dataSource over context dataSource', async () => {
-    const contextDs = {
-      find: vi.fn().mockResolvedValue({ data: [{ a: 1 }] }),
-    };
-    const propDs = {
-      find: vi.fn().mockResolvedValue({ data: [{ a: 1 }, { a: 2 }] }),
-    };
-
-    render(
-      <SchemaRendererProvider dataSource={contextDs}>
-        <ObjectMetricWidget {...baseProps} dataSource={propDs} />
-      </SchemaRendererProvider>,
-    );
-
-    await waitFor(() => {
-      expect(screen.getByText('2')).toBeInTheDocument();
-    });
-
-    expect(propDs.find).toHaveBeenCalled();
-    expect(contextDs.find).not.toHaveBeenCalled();
-  });
-});

package/src/__tests__/ObjectPivotTable.test.tsx

@@ -1,192 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { render, screen, waitFor } from '@testing-library/react';
-import React from 'react';
-import { ObjectPivotTable } from '../ObjectPivotTable';
-import { SchemaRendererProvider } from '@object-ui/react';
-
-describe('ObjectPivotTable', () => {
-  const baseSchema = {
-    type: 'pivot' as const,
-    rowField: 'region',
-    columnField: 'quarter',
-    valueField: 'revenue',
-    aggregation: 'sum' as const,
-  };
-
-  it('should render PivotTable with static data', () => {
-    const schema = {
-      ...baseSchema,
-      data: [
-        { region: 'North', quarter: 'Q1', revenue: 100 },
-        { region: 'South', quarter: 'Q1', revenue: 200 },
-      ],
-    };
-
-    render(<ObjectPivotTable schema={schema} />);
-    expect(screen.getByText('North')).toBeDefined();
-    expect(screen.getByText('South')).toBeDefined();
-  });
-
-  it('should show loading skeleton when fetching data', async () => {
-    // A dataSource that resolves slowly
-    const dataSource = {
-      find: vi.fn(() => new Promise(() => {})), // Never resolves
-    };
-
-    const schema = {
-      ...baseSchema,
-      objectName: 'sales',
-    };
-
-    const { container } = render(
-      <SchemaRendererProvider dataSource={dataSource}>
-        <ObjectPivotTable schema={schema} />
-      </SchemaRendererProvider>,
-    );
-
-    // Should show loading skeleton
-    await waitFor(() => {
-      const loadingEl = container.querySelector('[data-testid="pivot-loading"]');
-      expect(loadingEl).toBeDefined();
-    });
-  });
-
-  it('should show error state on fetch failure', async () => {
-    const dataSource = {
-      find: vi.fn().mockRejectedValue(new Error('Network error')),
-    };
-
-    const schema = {
-      ...baseSchema,
-      objectName: 'sales',
-    };
-
-    const { container } = render(
-      <SchemaRendererProvider dataSource={dataSource}>
-        <ObjectPivotTable schema={schema} />
-      </SchemaRendererProvider>,
-    );
-
-    await waitFor(() => {
-      const errorEl = container.querySelector('[data-testid="pivot-error"]');
-      expect(errorEl).not.toBeNull();
-    });
-
-    expect(screen.getByText('Network error')).toBeDefined();
-  });
-
-  it('should render fetched data in PivotTable', async () => {
-    const dataSource = {
-      find: vi.fn().mockResolvedValue({
-        records: [
-          { region: 'East', quarter: 'Q1', revenue: 500 },
-          { region: 'West', quarter: 'Q2', revenue: 300 },
-        ],
-      }),
-    };
-
-    const schema = {
-      ...baseSchema,
-      objectName: 'sales',
-    };
-
-    render(
-      <SchemaRendererProvider dataSource={dataSource}>
-        <ObjectPivotTable schema={schema} />
-      </SchemaRendererProvider>,
-    );
-
-    await waitFor(() => {
-      expect(screen.getByText('East')).toBeDefined();
-      expect(screen.getByText('West')).toBeDefined();
-    });
-
-    expect(dataSource.find).toHaveBeenCalledWith('sales', { $filter: undefined });
-  });
-
-  it('should show empty state when no data returned', async () => {
-    const dataSource = {
-      find: vi.fn().mockResolvedValue({ records: [] }),
-    };
-
-    const schema = {
-      ...baseSchema,
-      objectName: 'sales',
-    };
-
-    const { container } = render(
-      <SchemaRendererProvider dataSource={dataSource}>
-        <ObjectPivotTable schema={schema} />
-      </SchemaRendererProvider>,
-    );
-
-    await waitFor(() => {
-      const emptyState = container.querySelector('[data-testid="pivot-empty-state"]');
-      expect(emptyState).toBeDefined();
-    });
-  });
-
-  it('should prefer static data over fetched data', () => {
-    const dataSource = {
-      find: vi.fn(),
-    };
-
-    const schema = {
-      ...baseSchema,
-      objectName: 'sales',
-      data: [
-        { region: 'Static', quarter: 'Q1', revenue: 999 },
-      ],
-    };
-
-    render(
-      <SchemaRendererProvider dataSource={dataSource}>
-        <ObjectPivotTable schema={schema} />
-      </SchemaRendererProvider>,
-    );
-
-    expect(screen.getByText('Static')).toBeDefined();
-    expect(dataSource.find).not.toHaveBeenCalled();
-  });
-
-  it('should show no-data-source message when objectName is set but no dataSource available', () => {
-    const schema = {
-      ...baseSchema,
-      objectName: 'sales',
-    };
-
-    render(<ObjectPivotTable schema={schema} />);
-    expect(screen.getByText(/No data source available/)).toBeDefined();
-  });
-
-  it('should render title in all states', async () => {
-    const dataSource = {
-      find: vi.fn().mockRejectedValue(new Error('fail')),
-    };
-
-    const schema = {
-      ...baseSchema,
-      objectName: 'sales',
-      title: 'Revenue Pivot',
-    };
-
-    render(
-      <SchemaRendererProvider dataSource={dataSource}>
-        <ObjectPivotTable schema={schema} />
-      </SchemaRendererProvider>,
-    );
-
-    // Title shows even in error state
-    await waitFor(() => {
-      expect(screen.getByText('Revenue Pivot')).toBeDefined();
-    });
-  });
-});

package/src/__tests__/PivotTable.test.tsx

@@ -1,162 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import { describe, it, expect } from 'vitest';
-import { render, screen } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import { PivotTable } from '../PivotTable';
-import type { PivotTableSchema } from '@object-ui/types';
-
-const SAMPLE_DATA = [
-  { owner: 'Alice', stage: 'Discovery', amount: 1000 },
-  { owner: 'Alice', stage: 'Proposal', amount: 2000 },
-  { owner: 'Alice', stage: 'Discovery', amount: 500 },
-  { owner: 'Bob', stage: 'Discovery', amount: 3000 },
-  { owner: 'Bob', stage: 'Closed', amount: 5000 },
-  { owner: 'Carol', stage: 'Proposal', amount: 4000 },
-];
-
-function makeSchema(overrides?: Partial<PivotTableSchema>): PivotTableSchema {
-  return {
-    type: 'pivot',
-    rowField: 'owner',
-    columnField: 'stage',
-    valueField: 'amount',
-    data: SAMPLE_DATA,
-    ...overrides,
-  };
-}
-
-describe('PivotTable', () => {
-  it('should render row and column headers', () => {
-    render(<PivotTable schema={makeSchema()} />);
-
-    // Row headers
-    expect(screen.getByText('Alice')).toBeInTheDocument();
-    expect(screen.getByText('Bob')).toBeInTheDocument();
-    expect(screen.getByText('Carol')).toBeInTheDocument();
-
-    // Column headers
-    expect(screen.getByText('Discovery')).toBeInTheDocument();
-    expect(screen.getByText('Proposal')).toBeInTheDocument();
-    expect(screen.getByText('Closed')).toBeInTheDocument();
-  });
-
-  it('should aggregate values with sum by default', () => {
-    render(<PivotTable schema={makeSchema()} />);
-
-    // Alice + Discovery = 1000 + 500 = 1500
-    expect(screen.getByText('1500')).toBeInTheDocument();
-    // Alice + Proposal = 2000
-    expect(screen.getByText('2000')).toBeInTheDocument();
-    // Bob + Discovery = 3000
-    expect(screen.getByText('3000')).toBeInTheDocument();
-    // Bob + Closed = 5000
-    expect(screen.getByText('5000')).toBeInTheDocument();
-    // Carol + Proposal = 4000
-    expect(screen.getByText('4000')).toBeInTheDocument();
-  });
-
-  it('should support count aggregation', () => {
-    render(<PivotTable schema={makeSchema({ aggregation: 'count' })} />);
-
-    // Alice + Discovery = 2 items
-    expect(screen.getByText('2')).toBeInTheDocument();
-  });
-
-  it('should support avg aggregation', () => {
-    render(<PivotTable schema={makeSchema({ aggregation: 'avg' })} />);
-
-    // Alice + Discovery = avg(1000, 500) = 750
-    expect(screen.getByText('750')).toBeInTheDocument();
-  });
-
-  it('should render title when provided', () => {
-    render(<PivotTable schema={makeSchema({ title: 'Revenue Pivot' })} />);
-
-    expect(screen.getByText('Revenue Pivot')).toBeInTheDocument();
-  });
-
-  it('should show row totals when showRowTotals is true', () => {
-    render(<PivotTable schema={makeSchema({ showRowTotals: true })} />);
-
-    // Header "Total" column
-    const totalHeaders = screen.getAllByText('Total');
-    expect(totalHeaders.length).toBeGreaterThanOrEqual(1);
-
-    // Alice total = 1000 + 2000 + 500 = 3500
-    expect(screen.getByText('3500')).toBeInTheDocument();
-    // Bob total = 3000 + 5000 = 8000
-    expect(screen.getByText('8000')).toBeInTheDocument();
-  });
-
-  it('should show column totals when showColumnTotals is true', () => {
-    render(<PivotTable schema={makeSchema({ showColumnTotals: true })} />);
-
-    // Footer row with "Total" label
-    const totalCells = screen.getAllByText('Total');
-    expect(totalCells.length).toBeGreaterThanOrEqual(1);
-
-    // Discovery total = 1000 + 500 + 3000 = 4500
-    expect(screen.getByText('4500')).toBeInTheDocument();
-    // Proposal total = 2000 + 4000 = 6000
-    expect(screen.getByText('6000')).toBeInTheDocument();
-  });
-
-  it('should show grand total when both row and column totals are enabled', () => {
-    render(<PivotTable schema={makeSchema({ showRowTotals: true, showColumnTotals: true })} />);
-
-    // Grand total = 1000 + 2000 + 500 + 3000 + 5000 + 4000 = 15500
-    expect(screen.getByText('15500')).toBeInTheDocument();
-  });
-
-  it('should apply format string', () => {
-    render(<PivotTable schema={makeSchema({ format: '$,.0f' })} />);
-
-    // Alice + Discovery = $1,500
-    expect(screen.getByText('$1,500')).toBeInTheDocument();
-    // Bob + Closed = $5,000
-    expect(screen.getByText('$5,000')).toBeInTheDocument();
-  });
-
-  it('should handle empty data gracefully', () => {
-    const { container } = render(<PivotTable schema={makeSchema({ data: [] })} />);
-
-    // Should render a friendly empty state instead of an empty table
-    const emptyState = container.querySelector('[data-testid="pivot-empty-state"]');
-    expect(emptyState).toBeInTheDocument();
-    expect(screen.getByText('No data available')).toBeInTheDocument();
-  });
-
-  it('should handle missing values in data as 0', () => {
-    const data = [
-      { owner: 'Alice', stage: 'A', amount: 10 },
-      { owner: 'Bob', stage: 'B', amount: 20 },
-    ];
-    render(<PivotTable schema={makeSchema({ data })} />);
-
-    // Alice × B = 0, Bob × A = 0 should appear
-    const zeroCells = screen.getAllByText('0');
-    expect(zeroCells.length).toBe(2);
-  });
-
-  it('should show title in empty state', () => {
-    render(<PivotTable schema={makeSchema({ data: [], title: 'Empty Pivot' })} />);
-
-    expect(screen.getByText('Empty Pivot')).toBeInTheDocument();
-    expect(screen.getByText('No data available')).toBeInTheDocument();
-  });
-
-  it('should treat non-array data (e.g. provider config) as empty', () => {
-    const schema = makeSchema({ data: { provider: 'object', object: 'sales' } as any });
-    const { container } = render(<PivotTable schema={schema} />);
-
-    const emptyState = container.querySelector('[data-testid="pivot-empty-state"]');
-    expect(emptyState).toBeInTheDocument();
-  });
-});