@object-ui/react 3.3.0 → 3.3.2

package/src/__tests__/useViewData.test.tsx

@@ -1,422 +0,0 @@
-/**
- * ObjectUI — useViewData Tests
- * 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 } from 'vitest';
-import { renderHook, act, waitFor } from '@testing-library/react';
-import React from 'react';
-import { useViewData } from '../hooks/useViewData';
-import { SchemaRendererContext } from '../context/SchemaRendererContext';
-import type { DataSource, ViewData, QueryResult } from '@object-ui/types';
-
-// ---------------------------------------------------------------------------
-// Mock DataSource
-// ---------------------------------------------------------------------------
-
-function createMockDataSource(
-  findResult: QueryResult<any> = { data: [], total: 0 },
-): DataSource<any> {
-  return {
-    find: vi.fn().mockResolvedValue(findResult),
-    findOne: vi.fn().mockResolvedValue(null),
-    create: vi.fn().mockResolvedValue({}),
-    update: vi.fn().mockResolvedValue({}),
-    delete: vi.fn().mockResolvedValue(true),
-    getObjectSchema: vi.fn().mockResolvedValue({ name: 'test', fields: {} }),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function createContextWrapper(dataSource?: any) {
-  return ({ children }: { children: React.ReactNode }) =>
-    React.createElement(
-      SchemaRendererContext.Provider,
-      { value: { dataSource: dataSource ?? null } },
-      children,
-    );
-}
-
-// ---------------------------------------------------------------------------
-// provider: 'value' (in-memory)
-// ---------------------------------------------------------------------------
-
-describe('useViewData — provider: value', () => {
-  it('should load value data synchronously', async () => {
-    const viewData: ViewData = {
-      provider: 'value',
-      items: [
-        { id: '1', name: 'Alice' },
-        { id: '2', name: 'Bob' },
-      ],
-    };
-
-    const { result } = renderHook(() =>
-      useViewData({ viewData, resource: 'users' }),
-    );
-
-    // Value provider resolves through the normal async path (Promise.resolve)
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    expect(result.current.data).toHaveLength(2);
-    expect(result.current.totalCount).toBe(2);
-    expect(result.current.error).toBeNull();
-    expect(result.current.dataSource).not.toBeNull();
-  });
-
-  it('should handle empty items', async () => {
-    const viewData: ViewData = { provider: 'value', items: [] };
-
-    const { result } = renderHook(() =>
-      useViewData({ viewData, resource: 'users' }),
-    );
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    expect(result.current.data).toHaveLength(0);
-    expect(result.current.totalCount).toBe(0);
-  });
-
-  it('should support filtering on value data', async () => {
-    const viewData: ViewData = {
-      provider: 'value',
-      items: [
-        { id: '1', name: 'Alice', role: 'admin' },
-        { id: '2', name: 'Bob', role: 'user' },
-        { id: '3', name: 'Charlie', role: 'admin' },
-      ],
-    };
-
-    const { result } = renderHook(() =>
-      useViewData({
-        viewData,
-        resource: 'users',
-        params: { $filter: { role: 'admin' } },
-      }),
-    );
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    expect(result.current.data).toHaveLength(2);
-    expect(result.current.totalCount).toBe(2);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// provider: 'object' (context fallback)
-// ---------------------------------------------------------------------------
-
-describe('useViewData — provider: object', () => {
-  it('should use context DataSource for object provider', async () => {
-    const mockDS = createMockDataSource({
-      data: [{ id: '1', name: 'Contact' }],
-      total: 1,
-    });
-
-    const viewData: ViewData = { provider: 'object', object: 'contacts' };
-
-    const { result } = renderHook(
-      () => useViewData({ viewData, resource: 'contacts' }),
-      { wrapper: createContextWrapper(mockDS) },
-    );
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    expect(mockDS.find).toHaveBeenCalledWith('contacts', undefined);
-    expect(result.current.data).toHaveLength(1);
-    expect(result.current.data[0].name).toBe('Contact');
-  });
-
-  it('should not fetch when no context DataSource available', async () => {
-    const viewData: ViewData = { provider: 'object', object: 'contacts' };
-
-    const { result } = renderHook(() =>
-      useViewData({ viewData, resource: 'contacts' }),
-    );
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    expect(result.current.data).toEqual([]);
-    expect(result.current.dataSource).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Explicit DataSource override
-// ---------------------------------------------------------------------------
-
-describe('useViewData — explicit dataSource', () => {
-  it('should use explicit dataSource over context', async () => {
-    const contextDS = createMockDataSource();
-    const explicitDS = createMockDataSource({
-      data: [{ id: 'x' }],
-      total: 1,
-    });
-
-    const { result } = renderHook(
-      () =>
-        useViewData({
-          dataSource: explicitDS,
-          resource: 'items',
-        }),
-      { wrapper: createContextWrapper(contextDS) },
-    );
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    expect(explicitDS.find).toHaveBeenCalled();
-    expect(contextDS.find).not.toHaveBeenCalled();
-    expect(result.current.data).toHaveLength(1);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// skip
-// ---------------------------------------------------------------------------
-
-describe('useViewData — skip', () => {
-  it('should not fetch when skip is true', async () => {
-    const mockDS = createMockDataSource();
-    const viewData: ViewData = { provider: 'object', object: 'contacts' };
-
-    const { result } = renderHook(
-      () => useViewData({ viewData, resource: 'contacts', skip: true }),
-      { wrapper: createContextWrapper(mockDS) },
-    );
-
-    // Should immediately be not-loading
-    expect(result.current.loading).toBe(false);
-    expect(mockDS.find).not.toHaveBeenCalled();
-    expect(result.current.data).toEqual([]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// refresh
-// ---------------------------------------------------------------------------
-
-describe('useViewData — refresh', () => {
-  it('should re-fetch data on refresh', async () => {
-    let callCount = 0;
-    const mockDS: DataSource<any> = {
-      ...createMockDataSource(),
-      find: vi.fn().mockImplementation(async () => {
-        callCount++;
-        return {
-          data: [{ id: String(callCount) }],
-          total: 1,
-        };
-      }),
-    };
-
-    const viewData: ViewData = { provider: 'object', object: 'items' };
-
-    const { result } = renderHook(
-      () => useViewData({ viewData, resource: 'items' }),
-      { wrapper: createContextWrapper(mockDS) },
-    );
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-    expect(result.current.data[0].id).toBe('1');
-
-    // Trigger refresh
-    await act(async () => {
-      await result.current.refresh();
-    });
-
-    expect(result.current.data[0].id).toBe('2');
-    expect(mockDS.find).toHaveBeenCalledTimes(2);
-  });
-
-  it('should accept new params on refresh', async () => {
-    const mockDS = createMockDataSource({ data: [], total: 0 });
-    const viewData: ViewData = { provider: 'object', object: 'items' };
-
-    const { result } = renderHook(
-      () => useViewData({ viewData, resource: 'items' }),
-      { wrapper: createContextWrapper(mockDS) },
-    );
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    await act(async () => {
-      await result.current.refresh({ $top: 5, $filter: { status: 'active' } });
-    });
-
-    expect(mockDS.find).toHaveBeenLastCalledWith('items', {
-      $top: 5,
-      $filter: { status: 'active' },
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// fetchOne
-// ---------------------------------------------------------------------------
-
-describe('useViewData — fetchOne', () => {
-  it('should fetch a single record', async () => {
-    const mockDS: DataSource<any> = {
-      ...createMockDataSource(),
-      findOne: vi.fn().mockResolvedValue({ id: '42', name: 'Found' }),
-    };
-
-    const viewData: ViewData = { provider: 'object', object: 'items' };
-
-    const { result } = renderHook(
-      () => useViewData({ viewData, resource: 'items' }),
-      { wrapper: createContextWrapper(mockDS) },
-    );
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    let record: any;
-    await act(async () => {
-      record = await result.current.fetchOne('42');
-    });
-
-    expect(record).toEqual({ id: '42', name: 'Found' });
-    expect(mockDS.findOne).toHaveBeenCalledWith('items', '42');
-  });
-
-  it('should return null when dataSource is not available', async () => {
-    const { result } = renderHook(() =>
-      useViewData({ resource: 'items' }),
-    );
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    let record: any;
-    await act(async () => {
-      record = await result.current.fetchOne('42');
-    });
-
-    expect(record).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Error handling
-// ---------------------------------------------------------------------------
-
-describe('useViewData — errors', () => {
-  it('should capture fetch errors', async () => {
-    const mockDS: DataSource<any> = {
-      ...createMockDataSource(),
-      find: vi.fn().mockRejectedValue(new Error('Network failure')),
-    };
-
-    const viewData: ViewData = { provider: 'object', object: 'items' };
-
-    const { result } = renderHook(
-      () => useViewData({ viewData, resource: 'items' }),
-      { wrapper: createContextWrapper(mockDS) },
-    );
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    expect(result.current.error).toBeInstanceOf(Error);
-    expect(result.current.error?.message).toBe('Network failure');
-    expect(result.current.data).toEqual([]);
-    expect(result.current.totalCount).toBe(0);
-  });
-
-  it('should wrap non-Error throws as Error', async () => {
-    const mockDS: DataSource<any> = {
-      ...createMockDataSource(),
-      find: vi.fn().mockRejectedValue('string error'),
-    };
-
-    const viewData: ViewData = { provider: 'object', object: 'items' };
-
-    const { result } = renderHook(
-      () => useViewData({ viewData, resource: 'items' }),
-      { wrapper: createContextWrapper(mockDS) },
-    );
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    expect(result.current.error).toBeInstanceOf(Error);
-    expect(result.current.error?.message).toBe('string error');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// hasMore
-// ---------------------------------------------------------------------------
-
-describe('useViewData — hasMore', () => {
-  it('should reflect hasMore from QueryResult', async () => {
-    const mockDS = createMockDataSource({
-      data: [{ id: '1' }],
-      total: 100,
-      hasMore: true,
-    });
-
-    const viewData: ViewData = { provider: 'object', object: 'items' };
-
-    const { result } = renderHook(
-      () => useViewData({ viewData, resource: 'items', params: { $top: 1 } }),
-      { wrapper: createContextWrapper(mockDS) },
-    );
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    expect(result.current.hasMore).toBe(true);
-    expect(result.current.totalCount).toBe(100);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// No resource
-// ---------------------------------------------------------------------------
-
-describe('useViewData — edge cases', () => {
-  it('should not fetch when resource is empty', async () => {
-    const mockDS = createMockDataSource();
-    const viewData: ViewData = { provider: 'object', object: 'items' };
-
-    const { result } = renderHook(
-      () => useViewData({ viewData, resource: '' }),
-      { wrapper: createContextWrapper(mockDS) },
-    );
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    expect(mockDS.find).not.toHaveBeenCalled();
-  });
-});