@object-ui/react 3.1.5 → 3.3.1

package/src/__tests__/SchemaRenderer.errorBoundary.test.tsx

@@ -1,114 +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, beforeEach, afterEach, vi } from 'vitest';
-import { render, screen, fireEvent } from '@testing-library/react';
-import React from 'react';
-import { ComponentRegistry } from '@object-ui/core';
-import { SchemaRenderer, SchemaErrorBoundary } from '../SchemaRenderer';
-
-// Suppress console.error from React error boundary during tests
-const originalConsoleError = console.error;
-beforeEach(() => {
-  console.error = vi.fn();
-});
-afterEach(() => {
-  console.error = originalConsoleError;
-});
-
-const CrashingWidget: React.FC = () => {
-  throw new Error('Widget exploded!');
-};
-
-const StableWidget: React.FC<any> = (props) => (
-  <div data-testid="stable-widget">{props.content || 'Stable'}</div>
-);
-
-describe('SchemaErrorBoundary', () => {
-  it('should render children normally when no error', () => {
-    render(
-      <SchemaErrorBoundary>
-        <div data-testid="child">OK</div>
-      </SchemaErrorBoundary>
-    );
-    expect(screen.getByTestId('child')).toBeInTheDocument();
-  });
-
-  it('should catch render errors and display fallback', () => {
-    render(
-      <SchemaErrorBoundary componentType="crashing-widget">
-        <CrashingWidget />
-      </SchemaErrorBoundary>
-    );
-    expect(screen.getByRole('alert')).toBeInTheDocument();
-    expect(screen.getByText(/failed to render/i)).toBeInTheDocument();
-    expect(screen.getByText(/"crashing-widget"/)).toBeInTheDocument();
-    expect(screen.getByText('Widget exploded!')).toBeInTheDocument();
-  });
-
-  it('should display retry button that resets the error', () => {
-    render(
-      <SchemaErrorBoundary>
-        <CrashingWidget />
-      </SchemaErrorBoundary>
-    );
-    expect(screen.getByRole('alert')).toBeInTheDocument();
-    const retryButton = screen.getByText('Retry');
-    expect(retryButton).toBeInTheDocument();
-  });
-
-  it('should work without componentType prop', () => {
-    render(
-      <SchemaErrorBoundary>
-        <CrashingWidget />
-      </SchemaErrorBoundary>
-    );
-    expect(screen.getByText(/failed to render/i)).toBeInTheDocument();
-  });
-});
-
-describe('SchemaRenderer error boundary integration', () => {
-  beforeEach(() => {
-    ComponentRegistry.register('crashing-widget', CrashingWidget);
-    ComponentRegistry.register('stable-widget', StableWidget);
-  });
-
-  afterEach(() => {
-    ComponentRegistry.unregister?.('crashing-widget');
-    ComponentRegistry.unregister?.('stable-widget');
-  });
-
-  it('should catch errors from a crashing component', () => {
-    render(
-      <SchemaRenderer schema={{ type: 'crashing-widget' }} />
-    );
-    expect(screen.getByRole('alert')).toBeInTheDocument();
-    expect(screen.getByText('Widget exploded!')).toBeInTheDocument();
-  });
-
-  it('should not affect stable components', () => {
-    render(
-      <SchemaRenderer schema={{ type: 'stable-widget', content: 'Hello' }} />
-    );
-    expect(screen.getByTestId('stable-widget')).toBeInTheDocument();
-    expect(screen.getByText('Hello')).toBeInTheDocument();
-  });
-
-  it('should isolate crashes between multiple renderers', () => {
-    render(
-      <div>
-        <SchemaRenderer schema={{ type: 'crashing-widget' }} />
-        <SchemaRenderer schema={{ type: 'stable-widget', content: 'Still works' }} />
-      </div>
-    );
-    // Crashing one should not affect the other
-    expect(screen.getByRole('alert')).toBeInTheDocument();
-    expect(screen.getByTestId('stable-widget')).toBeInTheDocument();
-    expect(screen.getByText('Still works')).toBeInTheDocument();
-  });
-});

package/src/__tests__/SchemaRenderer.expressions.test.tsx

@@ -1,131 +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, beforeEach, afterEach } from 'vitest';
-import { render, screen } from '@testing-library/react';
-import React from 'react';
-import { ComponentRegistry } from '@object-ui/core';
-import { SchemaRenderer } from '../SchemaRenderer';
-import { SchemaRendererContext } from '../context/SchemaRendererContext';
-
-// Simple test component
-const TestComponent = (props: any) => (
-  <div data-testid="test-component" data-disabled={props.disabled || undefined}>
-    {props.content || props.label || 'Test'}
-  </div>
-);
-
-describe('SchemaRenderer Expression Integration', () => {
-  beforeEach(() => {
-    ComponentRegistry.register('test-component', TestComponent);
-  });
-
-  afterEach(() => {
-    ComponentRegistry.unregister?.('test-component');
-  });
-
-  describe('visible / hidden expressions', () => {
-    it('renders when visible is true', () => {
-      render(<SchemaRenderer schema={{ type: 'test-component', visible: true }} />);
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-
-    it('does not render when visible is false', () => {
-      const { container } = render(<SchemaRenderer schema={{ type: 'test-component', visible: false }} />);
-      expect(container.innerHTML).toBe('');
-    });
-
-    it('evaluates visible expression string', () => {
-      render(
-        <SchemaRendererContext.Provider value={{ dataSource: { role: 'admin' } }}>
-          <SchemaRenderer schema={{ type: 'test-component', visible: '${data.role === "admin"}' }} />
-        </SchemaRendererContext.Provider>
-      );
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-
-    it('hides when visible expression evaluates to false', () => {
-      const { container } = render(
-        <SchemaRendererContext.Provider value={{ dataSource: { role: 'viewer' } }}>
-          <SchemaRenderer schema={{ type: 'test-component', visible: '${data.role === "admin"}' }} />
-        </SchemaRendererContext.Provider>
-      );
-      expect(container.innerHTML).toBe('');
-    });
-
-    it('hides when hidden is true', () => {
-      const { container } = render(<SchemaRenderer schema={{ type: 'test-component', hidden: true }} />);
-      expect(container.innerHTML).toBe('');
-    });
-
-    it('shows when hidden is false', () => {
-      render(<SchemaRenderer schema={{ type: 'test-component', hidden: false }} />);
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-
-    it('hides with hiddenOn expression', () => {
-      const { container } = render(
-        <SchemaRendererContext.Provider value={{ dataSource: { status: 'draft' } }}>
-          <SchemaRenderer schema={{ type: 'test-component', hiddenOn: '${data.status === "draft"}' }} />
-        </SchemaRendererContext.Provider>
-      );
-      expect(container.innerHTML).toBe('');
-    });
-
-    it('visible takes precedence over hidden', () => {
-      render(<SchemaRenderer schema={{ type: 'test-component', visible: true, hidden: true }} />);
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-  });
-
-  describe('disabled expressions', () => {
-    it('passes disabled=true when disabled expression is true', () => {
-      render(<SchemaRenderer schema={{ type: 'test-component', disabled: true }} />);
-      expect(screen.getByTestId('test-component')).toHaveAttribute('data-disabled', 'true');
-    });
-
-    it('evaluates disabled expression string', () => {
-      render(
-        <SchemaRendererContext.Provider value={{ dataSource: { status: 'locked' } }}>
-          <SchemaRenderer schema={{ type: 'test-component', disabled: '${data.status === "locked"}' }} />
-        </SchemaRendererContext.Provider>
-      );
-      expect(screen.getByTestId('test-component')).toHaveAttribute('data-disabled', 'true');
-    });
-
-    it('does not set disabled when expression is false', () => {
-      render(
-        <SchemaRendererContext.Provider value={{ dataSource: { status: 'active' } }}>
-          <SchemaRenderer schema={{ type: 'test-component', disabled: '${data.status === "locked"}' }} />
-        </SchemaRendererContext.Provider>
-      );
-      expect(screen.getByTestId('test-component')).not.toHaveAttribute('data-disabled');
-    });
-
-    it('evaluates disabledOn expression', () => {
-      render(
-        <SchemaRendererContext.Provider value={{ dataSource: { readOnly: true } }}>
-          <SchemaRenderer schema={{ type: 'test-component', disabledOn: '${data.readOnly}' }} />
-        </SchemaRendererContext.Provider>
-      );
-      expect(screen.getByTestId('test-component')).toHaveAttribute('data-disabled', 'true');
-    });
-  });
-
-  describe('defaults', () => {
-    it('renders by default when no visibility props are set', () => {
-      render(<SchemaRenderer schema={{ type: 'test-component' }} />);
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-
-    it('is not disabled by default', () => {
-      render(<SchemaRenderer schema={{ type: 'test-component' }} />);
-      expect(screen.getByTestId('test-component')).not.toHaveAttribute('data-disabled');
-    });
-  });
-});

package/src/__tests__/SchemaRendererProvider.smoke.test.tsx

@@ -1,132 +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.
- */
-
-/**
- * Smoke tests for SchemaRendererProvider.
- *
- * These tests ensure that every registered plugin component that calls
- * useSchemaContext() can render without throwing when wrapped in a
- * SchemaRendererProvider. This catches the class of errors reported in
- * Storybook ("useSchemaContext must be used within a SchemaRendererProvider").
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { render, screen } from '@testing-library/react';
-import React from 'react';
-import { ComponentRegistry } from '@object-ui/core';
-import { SchemaRenderer } from '../SchemaRenderer';
-import { SchemaRendererProvider, useSchemaContext } from '../context/SchemaRendererContext';
-
-// Suppress console.error from React error boundary during tests
-const originalConsoleError = console.error;
-beforeEach(() => {
-  console.error = vi.fn();
-});
-afterEach(() => {
-  console.error = originalConsoleError;
-});
-
-// Helper: a component that calls useSchemaContext (mimics plugin pattern)
-const ContextConsumer: React.FC<any> = ({ schema }) => {
-  const { dataSource } = useSchemaContext();
-  return <div data-testid="ctx-consumer">dataSource: {JSON.stringify(dataSource)}</div>;
-};
-
-describe('useSchemaContext provider requirement', () => {
-  it('should throw when used outside SchemaRendererProvider', () => {
-    expect(() => render(<ContextConsumer schema={{}} />)).toThrow(
-      'useSchemaContext must be used within a SchemaRendererProvider'
-    );
-  });
-
-  it('should not throw when used inside SchemaRendererProvider', () => {
-    render(
-      <SchemaRendererProvider dataSource={{ test: true }}>
-        <ContextConsumer schema={{}} />
-      </SchemaRendererProvider>
-    );
-    expect(screen.getByTestId('ctx-consumer')).toHaveTextContent('dataSource: {"test":true}');
-  });
-
-  it('should fall back to empty dataSource when provider has empty object', () => {
-    render(
-      <SchemaRendererProvider dataSource={{}}>
-        <ContextConsumer schema={{}} />
-      </SchemaRendererProvider>
-    );
-    expect(screen.getByTestId('ctx-consumer')).toHaveTextContent('dataSource: {}');
-  });
-});
-
-describe('SchemaRenderer + SchemaRendererProvider integration', () => {
-  beforeEach(() => {
-    ComponentRegistry.register('test-ctx-consumer', ContextConsumer);
-  });
-
-  afterEach(() => {
-    ComponentRegistry.unregister?.('test-ctx-consumer');
-  });
-
-  it('should render a component that calls useSchemaContext without error when provider wraps the tree', () => {
-    render(
-      <SchemaRendererProvider dataSource={{ foo: 'bar' }}>
-        <SchemaRenderer schema={{ type: 'test-ctx-consumer' }} />
-      </SchemaRendererProvider>
-    );
-    expect(screen.getByTestId('ctx-consumer')).toHaveTextContent('dataSource: {"foo":"bar"}');
-  });
-
-  it('should show error boundary fallback (not crash) when provider is missing', () => {
-    // Without a provider, the SchemaErrorBoundary catches the throw
-    render(
-      <SchemaRenderer schema={{ type: 'test-ctx-consumer' }} />
-    );
-    expect(screen.getByRole('alert')).toBeInTheDocument();
-    expect(screen.getByText(/failed to render/i)).toBeInTheDocument();
-  });
-});
-
-describe('Plugin component types render inside provider', () => {
-  // This test ensures all registered plugin types that use useSchemaContext
-  // can at least mount without throwing inside a SchemaRendererProvider.
-  const pluginTypes = [
-    'kanban',
-    'object-kanban',
-    'timeline',
-    'object-timeline',
-    'object-grid',
-    'object-calendar',
-    'object-map',
-    'chart',
-    'object-gantt',
-  ];
-
-  for (const type of pluginTypes) {
-    it(`type="${type}" should not throw inside SchemaRendererProvider`, () => {
-      const component = ComponentRegistry.get(type);
-      if (!component) {
-        // Component not registered in test environment — skip
-        return;
-      }
-
-      // Render via SchemaRenderer inside provider
-      const { container } = render(
-        <SchemaRendererProvider dataSource={{}}>
-          <SchemaRenderer schema={{ type }} />
-        </SchemaRendererProvider>
-      );
-
-      // Should NOT show the error boundary alert
-      const alerts = container.querySelectorAll('[role="alert"]');
-      const providerErrors = Array.from(alerts).filter((el) =>
-        el.textContent?.includes('useSchemaContext must be used within')
-      );
-      expect(providerErrors).toHaveLength(0);
-    });
-  }
-});