@cccsaurora/howler-ui 3.1.0-dev.1385 → 3.1.0-dev.1394

package/components/routes/ErrorBoundary.js

@@ -16,7 +16,6 @@ class ErrorBoundaryComponent extends React.Component {
         this.setState({ hasError: true, error: error });
     }
     componentDidUpdate(previousProps) {
-        console.log(previousProps, this.props);
         if (this.props.locationKey !== previousProps.locationKey && this.state.hasError) {
             this.setState({ hasError: false, error: null });
         }

package/components/routes/home/ViewCard.js

@@ -84,7 +84,7 @@ const ViewCard = ({ viewId, limit, refreshTick, onRefreshComplete }) => {
         }
         isRefreshing.current = true;
         try {
-            const res = await dispatchApi(api.v2.search.post(view.indexes, {
+            const res = await dispatchApi(api.v2.search.post((view.indexes ?? ['hit']), {
                 query: view.query,
                 rows: limit,
                 metadata: ['analytic']

package/components/routes/home/ViewCard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/routes/home/ViewCard.test.js

@@ -0,0 +1,147 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { render, screen, waitFor } from '@testing-library/react';
+import i18n from '@cccsaurora/howler-ui/i18n';
+import React, { useCallback, useState } from 'react';
+import { I18nextProvider } from 'react-i18next';
+import { setupContextSelectorMock } from '@cccsaurora/howler-ui/tests/mocks';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import ViewCard from './ViewCard';
+setupContextSelectorMock();
+const mockDispatchApi = vi.hoisted(() => vi.fn());
+const mockNavigate = vi.hoisted(() => vi.fn());
+const mockFetchViews = vi.hoisted(() => vi.fn().mockResolvedValue([]));
+const mockBuildViewUrl = vi.hoisted(() => vi.fn(() => '/views/view-1'));
+vi.mock('api', () => ({
+    default: {
+        v2: {
+            search: {
+                post: (...args) => mockSearchPost(...args)
+            }
+        }
+    }
+}));
+const mockSearchPost = vi.hoisted(() => vi.fn());
+vi.mock('components/hooks/useMyApi', () => ({
+    default: () => ({ dispatchApi: mockDispatchApi })
+}));
+vi.mock('react-router-dom', async () => {
+    // oxlint-disable-next-line consistent-type-imports
+    const actual = await vi.importActual('react-router-dom');
+    return {
+        ...actual,
+        Link: ({ children, to, ...props }) => (_jsx("a", { href: to, ...props, children: children })),
+        useNavigate: () => mockNavigate
+    };
+});
+vi.mock('utils/viewUtils', () => ({
+    buildViewUrl: mockBuildViewUrl
+}));
+const mockView = {
+    view_id: 'view-1',
+    title: 'My View',
+    query: 'howler.status:open',
+    indexes: ['hit'],
+    sort: 'event.created desc',
+    span: 'date.range.1.month',
+    type: 'personal',
+    owner: 'test-user',
+    settings: { advance_on_triage: false }
+};
+vi.mock('components/app/providers/ViewProvider', () => ({
+    ViewContext: React.createContext(null)
+}));
+vi.mock('components/app/providers/RecordProvider', () => {
+    const recordContext = React.createContext(null);
+    return {
+        RecordContext: recordContext,
+        useRecordContextSelector: (selector) => selector(React.useContext(recordContext))
+    };
+});
+vi.mock('components/elements/hit/HitBanner', () => ({
+    default: ({ hit }) => _jsxs("div", { children: ["Hit: ", hit.howler.id] })
+}));
+vi.mock('components/elements/event/EventCard', () => ({
+    default: ({ event }) => _jsxs("div", { children: ["Event: ", event.howler.id] })
+}));
+vi.mock('components/elements/record/RecordContextMenu', () => ({
+    default: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('commons/components/display/AppListEmpty', () => ({
+    default: () => _jsx("div", { children: "No records" })
+}));
+import { RecordContext } from '@cccsaurora/howler-ui/components/app/providers/RecordProvider';
+import { ViewContext } from '@cccsaurora/howler-ui/components/app/providers/ViewProvider';
+const hit = {
+    __index: 'hit',
+    howler: {
+        id: 'hit-1',
+        status: 'open',
+        assignment: null,
+        assessment: null
+    }
+};
+const event = {
+    __index: 'event',
+    howler: { id: 'event-1' }
+};
+const Wrapper = ({ children }) => {
+    const [records, setRecords] = useState({});
+    const loadRecords = useCallback((newRecords) => {
+        setRecords(current => ({
+            ...current,
+            ...Object.fromEntries(newRecords.map(record => [record.howler.id, record]))
+        }));
+    }, []);
+    const recordContext = {
+        records,
+        loadRecords
+    };
+    return (_jsx(I18nextProvider, { i18n: i18n, children: _jsx(ViewContext.Provider, { value: { views: { 'view-1': mockView }, fetchViews: mockFetchViews }, children: _jsx(RecordContext.Provider, { value: recordContext, children: children }) }) }));
+};
+describe('ViewCard', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockSearchPost.mockResolvedValue({ items: [] });
+        mockDispatchApi.mockImplementation((request) => request);
+    });
+    it('fetches the view and searches with its query and limit', async () => {
+        mockSearchPost.mockReturnValue('search-request');
+        mockDispatchApi.mockResolvedValue({ items: [] });
+        render(_jsx(ViewCard, { viewId: "view-1", limit: 3 }), { wrapper: Wrapper });
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalled());
+        expect(mockFetchViews).toHaveBeenCalledWith(['view-1']);
+        expect(mockSearchPost).toHaveBeenCalledWith(['hit'], {
+            query: mockView.query,
+            rows: 3,
+            metadata: ['analytic']
+        });
+    });
+    it('renders the empty state when the search has no records', async () => {
+        mockDispatchApi.mockResolvedValue({ items: [] });
+        render(_jsx(ViewCard, { viewId: "view-1", limit: 3 }), { wrapper: Wrapper });
+        expect(await screen.findByText('No records')).toBeInTheDocument();
+    });
+    it('renders hits and events returned by the search', async () => {
+        mockDispatchApi.mockResolvedValue({ items: [hit, event] });
+        render(_jsx(ViewCard, { viewId: "view-1", limit: 3 }), { wrapper: Wrapper });
+        expect(await screen.findByText('Hit: hit-1')).toBeInTheDocument();
+        expect(screen.getByText('Event: event-1')).toBeInTheDocument();
+    });
+    it('renders a link to the view query', async () => {
+        mockDispatchApi.mockResolvedValue({ items: [hit] });
+        render(_jsx(ViewCard, { viewId: "view-1", limit: 3 }), { wrapper: Wrapper });
+        await screen.findByText('Hit: hit-1');
+        expect(screen.getByRole('link')).toHaveAttribute('href', '/views/view-1');
+        expect(mockNavigate).not.toHaveBeenCalled();
+    });
+    it('refreshes when refreshTick changes and reports completion', async () => {
+        const onRefreshComplete = vi.fn();
+        mockDispatchApi.mockResolvedValue({ items: [] });
+        const { rerender } = render(_jsx(ViewCard, { viewId: "view-1", limit: 3, refreshTick: Symbol('first'), onRefreshComplete: onRefreshComplete }), { wrapper: Wrapper });
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalledTimes(1));
+        expect(onRefreshComplete).toHaveBeenCalledTimes(2);
+        rerender(_jsx(ViewCard, { viewId: "view-1", limit: 3, refreshTick: Symbol('second'), onRefreshComplete: onRefreshComplete }));
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalledTimes(2));
+        expect(onRefreshComplete).toHaveBeenCalledTimes(3);
+    });
+});

package/package.json

@@ -93,7 +93,7 @@
     "url": "https://github.com/CybercentreCanada/howler"
   },
   "type": "module",
-  "version": "3.1.0-dev.1385",
+  "version": "3.1.0-dev.1394",
   "exports": {
     "./i18n": "./i18n.js",
     "./index.css": "./index.css",