datajunction-ui 0.0.74 → 0.0.76

package/src/app/pages/MyWorkspacePage/__tests__/MyWorkspacePage.test.jsx

@@ -0,0 +1,347 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
+import { MyWorkspacePage } from '../index';
+import * as useWorkspaceData from '../../../hooks/useWorkspaceData';
+
+// Mock CSS imports
+jest.mock('../MyWorkspacePage.css', () => ({}));
+jest.mock('../../../../styles/settings.css', () => ({}));
+
+// Mock child components to test integration
+jest.mock('../NotificationsSection', () => ({
+  NotificationsSection: ({ notifications, loading }) => (
+    <div data-testid="notifications-section">
+      {loading ? 'Loading...' : `${notifications.length} notifications`}
+    </div>
+  ),
+}));
+
+jest.mock('../NeedsAttentionSection', () => ({
+  NeedsAttentionSection: ({ loading }) => (
+    <div data-testid="needs-attention-section">
+      {loading ? 'Loading...' : 'Needs Attention'}
+    </div>
+  ),
+}));
+
+jest.mock('../MyNodesSection', () => ({
+  MyNodesSection: ({ ownedNodes, loading }) => (
+    <div data-testid="my-nodes-section">
+      {loading ? 'Loading...' : `${ownedNodes.length} owned nodes`}
+    </div>
+  ),
+}));
+
+jest.mock('../CollectionsSection', () => ({
+  CollectionsSection: ({ collections, loading }) => (
+    <div data-testid="collections-section">
+      {loading ? 'Loading...' : `${collections.length} collections`}
+    </div>
+  ),
+}));
+
+jest.mock('../MaterializationsSection', () => ({
+  MaterializationsSection: ({ nodes, loading }) => (
+    <div data-testid="materializations-section">
+      {loading ? 'Loading...' : `${nodes.length} materializations`}
+    </div>
+  ),
+}));
+
+jest.mock('../ActiveBranchesSection', () => ({
+  ActiveBranchesSection: ({ loading }) => (
+    <div data-testid="active-branches-section">
+      {loading ? 'Loading...' : 'Active Branches'}
+    </div>
+  ),
+}));
+
+describe('<MyWorkspacePage />', () => {
+  const mockCurrentUser = {
+    username: 'test.user@example.com',
+    email: 'test.user@example.com',
+  };
+
+  const mockOwnedNodes = [
+    {
+      name: 'default.test_metric',
+      type: 'METRIC',
+      current: { displayName: 'Test Metric', updatedAt: '2024-01-01' },
+    },
+    {
+      name: 'default.test_dimension',
+      type: 'DIMENSION',
+      current: { displayName: 'Test Dimension', updatedAt: '2024-01-02' },
+    },
+  ];
+
+  const mockCollections = [
+    {
+      name: 'test_collection',
+      description: 'Test Collection',
+      nodeCount: 5,
+      createdBy: 'test.user@example.com',
+    },
+  ];
+
+  const mockNotifications = [
+    {
+      entity_name: 'default.test_metric',
+      entity_type: 'node',
+      activity_type: 'update',
+      created_at: '2024-01-01T00:00:00Z',
+      user: 'test.user@example.com',
+      node_type: 'metric',
+      display_name: 'Test Metric',
+    },
+  ];
+
+  const mockMaterializations = [
+    {
+      name: 'default.test_cube',
+      type: 'CUBE',
+      current: {
+        displayName: 'Test Cube',
+        availability: {
+          validThroughTs: Date.now() - 1000 * 60 * 60, // 1 hour ago
+        },
+        materializations: [{ name: 'mat1', schedule: '@daily' }],
+      },
+    },
+  ];
+
+  const mockNeedsAttention = {
+    nodesMissingDescription: [],
+    invalidNodes: [],
+    staleDrafts: [],
+    orphanedDimensions: [],
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should render loading state', () => {
+    jest.spyOn(useWorkspaceData, 'useCurrentUser').mockReturnValue({
+      data: null,
+      loading: true,
+      error: null,
+    });
+
+    render(
+      <MemoryRouter>
+        <MyWorkspacePage />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByText('Dashboard')).toBeInTheDocument();
+    // Should show loading icon when user is loading
+    expect(screen.queryByTestId('collections-section')).not.toBeInTheDocument();
+  });
+
+  it('should render all sections when data is loaded', () => {
+    // Mock all hooks with data
+    jest.spyOn(useWorkspaceData, 'useCurrentUser').mockReturnValue({
+      data: mockCurrentUser,
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceOwnedNodes').mockReturnValue({
+      data: mockOwnedNodes,
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceRecentlyEdited').mockReturnValue({
+      data: [],
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceWatchedNodes').mockReturnValue({
+      data: [],
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceCollections').mockReturnValue({
+      data: mockCollections,
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceNotifications').mockReturnValue({
+      data: mockNotifications,
+      loading: false,
+      error: null,
+    });
+    jest
+      .spyOn(useWorkspaceData, 'useWorkspaceMaterializations')
+      .mockReturnValue({
+        data: mockMaterializations,
+        loading: false,
+        error: null,
+      });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceNeedsAttention').mockReturnValue({
+      data: mockNeedsAttention,
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'usePersonalNamespace').mockReturnValue({
+      exists: true,
+      loading: false,
+      error: null,
+    });
+
+    render(
+      <MemoryRouter>
+        <MyWorkspacePage />
+      </MemoryRouter>,
+    );
+
+    // Check all sections are rendered
+    expect(screen.getByTestId('collections-section')).toHaveTextContent(
+      '1 collections',
+    );
+    expect(screen.getByTestId('my-nodes-section')).toHaveTextContent(
+      '2 owned nodes',
+    );
+    expect(screen.getByTestId('notifications-section')).toHaveTextContent(
+      '1 notifications',
+    );
+    expect(screen.getByTestId('materializations-section')).toHaveTextContent(
+      '1 materializations',
+    );
+    expect(screen.getByTestId('needs-attention-section')).toBeInTheDocument();
+    expect(screen.getByTestId('active-branches-section')).toBeInTheDocument();
+  });
+
+  it('should pass correct props to sections', () => {
+    jest.spyOn(useWorkspaceData, 'useCurrentUser').mockReturnValue({
+      data: mockCurrentUser,
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceOwnedNodes').mockReturnValue({
+      data: mockOwnedNodes,
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceRecentlyEdited').mockReturnValue({
+      data: [],
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceWatchedNodes').mockReturnValue({
+      data: [],
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceCollections').mockReturnValue({
+      data: mockCollections,
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceNotifications').mockReturnValue({
+      data: mockNotifications,
+      loading: false,
+      error: null,
+    });
+    jest
+      .spyOn(useWorkspaceData, 'useWorkspaceMaterializations')
+      .mockReturnValue({
+        data: mockMaterializations,
+        loading: false,
+        error: null,
+      });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceNeedsAttention').mockReturnValue({
+      data: mockNeedsAttention,
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'usePersonalNamespace').mockReturnValue({
+      exists: true,
+      loading: false,
+      error: null,
+    });
+
+    render(
+      <MemoryRouter>
+        <MyWorkspacePage />
+      </MemoryRouter>,
+    );
+
+    // Verify sections receive correct data
+    expect(screen.getByTestId('collections-section')).toBeInTheDocument();
+    expect(screen.getByTestId('my-nodes-section')).toBeInTheDocument();
+    expect(screen.getByTestId('notifications-section')).toBeInTheDocument();
+  });
+
+  it('should calculate stale materializations correctly', () => {
+    const now = Date.now();
+    const staleNode = {
+      name: 'default.stale_cube',
+      type: 'CUBE',
+      current: {
+        displayName: 'Stale Cube',
+        availability: {
+          validThroughTs: now - 1000 * 60 * 60 * 80, // 80 hours ago (> 72 hours)
+        },
+      },
+    };
+
+    jest.spyOn(useWorkspaceData, 'useCurrentUser').mockReturnValue({
+      data: mockCurrentUser,
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceOwnedNodes').mockReturnValue({
+      data: [],
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceRecentlyEdited').mockReturnValue({
+      data: [],
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceWatchedNodes').mockReturnValue({
+      data: [],
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceCollections').mockReturnValue({
+      data: [],
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceNotifications').mockReturnValue({
+      data: [],
+      loading: false,
+      error: null,
+    });
+    jest
+      .spyOn(useWorkspaceData, 'useWorkspaceMaterializations')
+      .mockReturnValue({
+        data: [staleNode],
+        loading: false,
+        error: null,
+      });
+    jest.spyOn(useWorkspaceData, 'useWorkspaceNeedsAttention').mockReturnValue({
+      data: mockNeedsAttention,
+      loading: false,
+      error: null,
+    });
+    jest.spyOn(useWorkspaceData, 'usePersonalNamespace').mockReturnValue({
+      exists: true,
+      loading: false,
+      error: null,
+    });
+
+    render(
+      <MemoryRouter>
+        <MyWorkspacePage />
+      </MemoryRouter>,
+    );
+
+    // The stale materialization should be passed to NeedsAttentionSection
+    expect(screen.getByTestId('needs-attention-section')).toBeInTheDocument();
+  });
+});

package/src/app/pages/MyWorkspacePage/__tests__/NeedsAttentionSection.test.jsx

@@ -0,0 +1,272 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
+import { NeedsAttentionSection } from '../NeedsAttentionSection';
+
+jest.mock('../MyWorkspacePage.css', () => ({}));
+
+describe('<NeedsAttentionSection />', () => {
+  const defaultProps = {
+    nodesMissingDescription: [],
+    invalidNodes: [],
+    staleDrafts: [],
+    staleMaterializations: [],
+    orphanedDimensions: [],
+    username: 'test.user@example.com',
+    hasItems: false,
+    loading: false,
+    personalNamespace: 'users.test.user',
+    hasPersonalNamespace: true,
+    namespaceLoading: false,
+  };
+
+  it('should render loading state', () => {
+    render(
+      <MemoryRouter>
+        <NeedsAttentionSection {...defaultProps} loading={true} />
+      </MemoryRouter>,
+    );
+
+    expect(screen.queryByText('✓ All good!')).not.toBeInTheDocument();
+  });
+
+  it('should render all categories', () => {
+    render(
+      <MemoryRouter>
+        <NeedsAttentionSection {...defaultProps} />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByText(/Invalid/)).toBeInTheDocument();
+    expect(screen.getByText(/Stale Drafts/)).toBeInTheDocument();
+    expect(screen.getByText(/Stale Materializations/)).toBeInTheDocument();
+    expect(screen.getByText(/No Description/)).toBeInTheDocument();
+    expect(screen.getByText(/Orphaned Dimensions/)).toBeInTheDocument();
+  });
+
+  it('should show "All good!" when category has no items', () => {
+    render(
+      <MemoryRouter>
+        <NeedsAttentionSection {...defaultProps} />
+      </MemoryRouter>,
+    );
+
+    const allGood = screen.getAllByText('✓ All good!');
+    expect(allGood.length).toBe(5); // All 5 categories should show "All good!"
+  });
+
+  it('should display invalid nodes', () => {
+    const invalidNodes = [
+      {
+        name: 'default.invalid_metric',
+        type: 'METRIC',
+        current: { displayName: 'Invalid Metric' },
+      },
+    ];
+
+    render(
+      <MemoryRouter>
+        <NeedsAttentionSection
+          {...defaultProps}
+          invalidNodes={invalidNodes}
+          hasItems={true}
+        />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByText('❌ Invalid')).toBeInTheDocument();
+    expect(screen.getByText('(1)')).toBeInTheDocument();
+  });
+
+  it('should display stale drafts', () => {
+    const staleDrafts = [
+      {
+        name: 'default.stale_draft',
+        type: 'METRIC',
+        current: { displayName: 'Stale Draft' },
+      },
+    ];
+
+    render(
+      <MemoryRouter>
+        <NeedsAttentionSection
+          {...defaultProps}
+          staleDrafts={staleDrafts}
+          hasItems={true}
+        />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByText('⏰ Stale Drafts')).toBeInTheDocument();
+    expect(screen.getByText('(1)')).toBeInTheDocument();
+  });
+
+  it('should display nodes missing description', () => {
+    const nodesMissingDescription = [
+      {
+        name: 'default.no_desc_metric',
+        type: 'METRIC',
+        current: { displayName: 'No Description Metric' },
+      },
+    ];
+
+    render(
+      <MemoryRouter>
+        <NeedsAttentionSection
+          {...defaultProps}
+          nodesMissingDescription={nodesMissingDescription}
+          hasItems={true}
+        />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByText('📝 No Description')).toBeInTheDocument();
+    expect(screen.getByText('(1)')).toBeInTheDocument();
+  });
+
+  it('should show "View all" link for categories with items', () => {
+    const invalidNodes = [
+      {
+        name: 'default.invalid_metric',
+        type: 'METRIC',
+        current: { displayName: 'Invalid Metric' },
+      },
+    ];
+
+    render(
+      <MemoryRouter>
+        <NeedsAttentionSection
+          {...defaultProps}
+          invalidNodes={invalidNodes}
+          hasItems={true}
+        />
+      </MemoryRouter>,
+    );
+
+    const viewAllLinks = screen.getAllByText('View all →');
+    expect(viewAllLinks.length).toBeGreaterThan(0);
+  });
+
+  it('should not show "View all" link for empty categories', () => {
+    render(
+      <MemoryRouter>
+        <NeedsAttentionSection {...defaultProps} />
+      </MemoryRouter>,
+    );
+
+    expect(screen.queryByText('View all →')).not.toBeInTheDocument();
+  });
+
+  it('should limit nodes to 10 per category', () => {
+    const manyNodes = Array.from({ length: 15 }, (_, i) => ({
+      name: `default.node_${i}`,
+      type: 'METRIC',
+      current: { displayName: `Node ${i}` },
+    }));
+
+    render(
+      <MemoryRouter>
+        <NeedsAttentionSection
+          {...defaultProps}
+          invalidNodes={manyNodes}
+          hasItems={true}
+        />
+      </MemoryRouter>,
+    );
+
+    // Should only display 10 nodes (via NodeChip component)
+    // The 11th node should not be displayed
+    expect(screen.getByText('❌ Invalid')).toBeInTheDocument();
+    expect(screen.getByText('(15)')).toBeInTheDocument();
+  });
+
+  it('should show personal namespace prompt when namespace does not exist', () => {
+    render(
+      <MemoryRouter>
+        <NeedsAttentionSection {...defaultProps} hasPersonalNamespace={false} />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByText('Set up your namespace')).toBeInTheDocument();
+    expect(screen.getByText('users.test.user')).toBeInTheDocument();
+    expect(screen.getByText('Create →')).toBeInTheDocument();
+  });
+
+  it('should not show personal namespace prompt when namespace exists', () => {
+    render(
+      <MemoryRouter>
+        <NeedsAttentionSection {...defaultProps} hasPersonalNamespace={true} />
+      </MemoryRouter>,
+    );
+
+    expect(screen.queryByText('Set up your namespace')).not.toBeInTheDocument();
+  });
+
+  it('should not show personal namespace prompt when loading', () => {
+    render(
+      <MemoryRouter>
+        <NeedsAttentionSection
+          {...defaultProps}
+          hasPersonalNamespace={false}
+          namespaceLoading={true}
+        />
+      </MemoryRouter>,
+    );
+
+    expect(screen.queryByText('Set up your namespace')).not.toBeInTheDocument();
+  });
+
+  it('should link to correct filter URLs', () => {
+    const invalidNodes = [
+      {
+        name: 'default.invalid_metric',
+        type: 'METRIC',
+        current: { displayName: 'Invalid Metric' },
+      },
+    ];
+
+    render(
+      <MemoryRouter>
+        <NeedsAttentionSection
+          {...defaultProps}
+          invalidNodes={invalidNodes}
+          hasItems={true}
+        />
+      </MemoryRouter>,
+    );
+
+    const viewAllLink = screen.getByText('View all →').closest('a');
+    expect(viewAllLink).toHaveAttribute(
+      'href',
+      '/?ownedBy=test.user@example.com&statuses=INVALID',
+    );
+  });
+
+  it('should display correct count for each category', () => {
+    render(
+      <MemoryRouter>
+        <NeedsAttentionSection
+          {...defaultProps}
+          invalidNodes={[{ name: 'node1', type: 'METRIC', current: {} }]}
+          staleDrafts={[
+            { name: 'node2', type: 'METRIC', current: {} },
+            { name: 'node3', type: 'METRIC', current: {} },
+          ]}
+          nodesMissingDescription={[
+            { name: 'node4', type: 'METRIC', current: {} },
+            { name: 'node5', type: 'METRIC', current: {} },
+            { name: 'node6', type: 'METRIC', current: {} },
+          ]}
+          hasItems={true}
+        />
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByText('❌ Invalid')).toBeInTheDocument();
+    expect(screen.getByText('(1)')).toBeInTheDocument();
+    expect(screen.getByText('⏰ Stale Drafts')).toBeInTheDocument();
+    expect(screen.getByText('(2)')).toBeInTheDocument();
+    expect(screen.getByText('📝 No Description')).toBeInTheDocument();
+    expect(screen.getByText('(3)')).toBeInTheDocument();
+  });
+});