@cccsaurora/howler-ui 2.14.0-dev.264 → 2.14.0-dev.266

package/plugins/HowlerPlugin.ts

@@ -1,17 +1,17 @@
-import type { HowlerHelper } from 'components/elements/display/handlebars/helpers';
-import type { ActionButton } from 'components/elements/hit/actions/SharedComponents';
-import type { StatusProps } from 'components/elements/hit/HitBanner';
-import type { PivotLinkProps } from 'components/elements/hit/related/PivotLink';
-import type { PluginChipProps } from 'components/elements/PluginChip';
-import type { PluginTypographyProps } from 'components/elements/PluginTypography';
-import type { CustomActionProps } from 'components/routes/action/edit/ActionEditor';
-import type { LeadFormProps } from 'components/routes/dossiers/LeadEditor';
-import type { PivotFormProps } from 'components/routes/dossiers/PivotForm';
-import type { PluginDocumentation } from 'components/routes/help/ActionDocumentation';
-import i18nInstance from 'i18n';
+import type { HowlerHelper } from '@cccsaurora/howler-ui/components/elements/display/handlebars/helpers';
+import type { ActionButton } from '@cccsaurora/howler-ui/components/elements/hit/actions/SharedComponents';
+import type { StatusProps } from '@cccsaurora/howler-ui/components/elements/hit/HitBanner';
+import type { PivotLinkProps } from '@cccsaurora/howler-ui/components/elements/hit/related/PivotLink';
+import type { PluginChipProps } from '@cccsaurora/howler-ui/components/elements/PluginChip';
+import type { PluginTypographyProps } from '@cccsaurora/howler-ui/components/elements/PluginTypography';
+import type { CustomActionProps } from '@cccsaurora/howler-ui/components/routes/action/edit/ActionEditor';
+import type { LeadFormProps } from '@cccsaurora/howler-ui/components/routes/dossiers/LeadEditor';
+import type { PivotFormProps } from '@cccsaurora/howler-ui/components/routes/dossiers/PivotForm';
+import type { PluginDocumentation } from '@cccsaurora/howler-ui/components/routes/help/ActionDocumentation';
+import i18nInstance from '@cccsaurora/howler-ui/i18n';
 import type { i18n as I18N } from 'i18next';
 import { difference } from 'lodash-es';
-import type { Hit } from 'models/entities/generated/Hit';
+import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
 import type React from 'react';
 import type { PropsWithChildren } from 'react';
 import type { IPlugin, PluginStore } from 'react-pluggable';

package/plugins/store.ts

@@ -1,5 +1,5 @@
 /* eslint-disable no-console */
-import type { Hit } from 'models/entities/generated/Hit';
+import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
 import { createPluginStore, Event } from 'react-pluggable';
 import type HowlerPlugin from './HowlerPlugin';
 import type { AppLeftNavElement } from '../commons/components/app/AppConfigs';

package/rest/AxiosClient.ts

@@ -1,9 +1,9 @@
-import type { HowlerResponse } from 'api';
+import type { HowlerResponse } from '@cccsaurora/howler-ui/api';
 import type { AxiosInstance, AxiosRequestConfig, AxiosRequestHeaders } from 'axios';
 import axios, { AxiosError } from 'axios';
 import axiosRetry, { exponentialDelay, isNetworkError } from 'axios-retry';
-import type RestClient from 'rest';
-import { getAxiosCache, setAxiosCache } from 'utils/sessionStorage';
+import type RestClient from '@cccsaurora/howler-ui/rest';
+import { getAxiosCache, setAxiosCache } from '@cccsaurora/howler-ui/utils/sessionStorage';
 
 class AxiosCache {
   constructor(_axios: AxiosInstance) {

package/rest/FetchClient.ts

@@ -1,5 +1,5 @@
-import type { HowlerResponse } from 'api';
-import type RestClient from 'rest';
+import type { HowlerResponse } from '@cccsaurora/howler-ui/api';
+import type RestClient from '@cccsaurora/howler-ui/rest';
 
 export default class FetchClient implements RestClient {
   public async fetch<R>(

package/rest/index.ts

@@ -1,4 +1,4 @@
-import type { HowlerResponse } from 'api';
+import type { HowlerResponse } from '@cccsaurora/howler-ui/api';
 
 export default interface RestClient {
   fetch<R>(

package/utils/actionUtils.ts

@@ -1,5 +1,5 @@
-import type { ActionOperation, ActionOperationStep } from 'models/ActionTypes';
-import type { Operation } from 'models/entities/generated/Operation';
+import type { ActionOperation, ActionOperationStep } from '@cccsaurora/howler-ui/models/ActionTypes';
+import type { Operation } from '@cccsaurora/howler-ui/models/entities/generated/Operation';
 
 /**
  * A simple validation function to ensure we have all the necessary arguments filled out.

package/utils/hitFunctions.ts

@@ -1,4 +1,4 @@
-import type { Hit } from 'models/entities/generated/Hit';
+import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
 
 export const getUserList = (hit: Hit): Set<string> => {
   const ids = new Set<string>();

package/utils/localStorage.ts

@@ -1,4 +1,4 @@
-import type { LoginResponse } from 'api/auth/login';
+import type { LoginResponse } from '@cccsaurora/howler-ui/api/auth/login';
 import { MY_LOCAL_STORAGE_PREFIX, StorageKey } from './constants';
 
 const buildName = (name: string) => `${MY_LOCAL_STORAGE_PREFIX}.${name}`;

package/utils/sessionStorage.ts

@@ -1,4 +1,4 @@
-import Throttler from 'utils/Throttler';
+import Throttler from '@cccsaurora/howler-ui/utils/Throttler';
 import { MY_SESSION_STORAGE_PREFIX, StorageKey } from './constants';
 
 const buildName = (name: string) => `${MY_SESSION_STORAGE_PREFIX}.${name}`;

package/utils/socketUtils.ts

@@ -1,5 +1,5 @@
-import type { RecievedDataType } from 'components/app/providers/SocketProvider';
-import type { HitUpdate } from 'models/socket/HitUpdate';
+import type { RecievedDataType } from '@cccsaurora/howler-ui/components/app/providers/SocketProvider';
+import type { HitUpdate } from '@cccsaurora/howler-ui/models/socket/HitUpdate';
 
 /**
  * Checks to see if the data recieved from the socket is a hit update

package/components/app/hooks/useMatchers.test.ts

@@ -1,328 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import type { Dossier } from 'models/entities/generated/Dossier';
-import type { Hit } from 'models/entities/generated/Hit';
-import type { Overview } from 'models/entities/generated/Overview';
-import type { Template } from 'models/entities/generated/Template';
-import type { WithMetadata } from 'models/WithMetadata';
-import { useContextSelector } from 'use-context-selector';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { HitContext } from '../providers/HitProvider';
-import useMatchers from './useMatchers';
-
-// Mock the useContextSelector hook
-vi.mock('use-context-selector', () => ({
-  useContextSelector: vi.fn(),
-  createContext: vi.fn()
-}));
-
-// Mock lodash-es has function
-vi.mock('lodash-es', () => ({
-  has: vi.fn()
-}));
-
-// Create mock data
-const mockTemplate: Template = {
-  name: 'test-template',
-  template: 'Test template content'
-} as Template;
-
-const mockOverview: Overview = {
-  name: 'test-overview',
-  overview: 'Test overview content'
-} as Overview;
-
-const mockDossiers: Dossier[] = [
-  {
-    name: 'test-dossier',
-    description: 'Test dossier content'
-  } as Dossier
-];
-
-const mockHit: Hit = {
-  howler: {
-    id: 'test-hit-id',
-    analytic: 'test-analytic',
-    data: {}
-  }
-} as Hit;
-
-const mockHitWithMetadata: WithMetadata<Hit> = {
-  ...mockHit,
-  __template: mockTemplate,
-  __overview: mockOverview,
-  __dossiers: mockDossiers
-};
-
-const mockGetHit = vi.fn();
-
-describe('useMatchers', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    // Mock useContextSelector to return our mock getHit function
-    (useContextSelector as any).mockImplementation((context: any, selector: any) => {
-      if (context === HitContext) {
-        return selector({ getHit: mockGetHit });
-      }
-      return null;
-    });
-  });
-
-  describe('getMatchingTemplate', () => {
-    it('should return null when hit is null', async () => {
-      const { result } = renderHook(() => useMatchers());
-
-      const template = await result.current.getMatchingTemplate(null);
-
-      expect(template).toBeNull();
-    });
-
-    it('should return null when hit is undefined', async () => {
-      const { result } = renderHook(() => useMatchers());
-
-      const template = await result.current.getMatchingTemplate(undefined);
-
-      expect(template).toBeNull();
-    });
-
-    it('should return template from metadata when it exists', async () => {
-      const { has } = await import('lodash-es');
-      (has as any).mockReturnValue(true);
-
-      const { result } = renderHook(() => useMatchers());
-
-      const template = await result.current.getMatchingTemplate(mockHitWithMetadata);
-
-      expect(template).toBe(mockTemplate);
-      expect(mockGetHit).not.toHaveBeenCalled();
-    });
-
-    it('should fetch hit with metadata when template is not present', async () => {
-      const { has } = await import('lodash-es');
-      (has as any).mockReturnValue(false);
-
-      const hitWithFetchedMetadata = { ...mockHit, __template: mockTemplate };
-      mockGetHit.mockResolvedValue(hitWithFetchedMetadata);
-
-      const { result } = renderHook(() => useMatchers());
-
-      const template = await result.current.getMatchingTemplate(mockHit);
-
-      expect(template).toBe(mockTemplate);
-      expect(mockGetHit).toHaveBeenCalledWith('test-hit-id', true);
-    });
-
-    it('should handle getHit rejection gracefully', async () => {
-      const { has } = await import('lodash-es');
-      (has as any).mockReturnValue(false);
-
-      mockGetHit.mockRejectedValue(new Error('Failed to fetch hit'));
-
-      const { result } = renderHook(() => useMatchers());
-
-      await expect(result.current.getMatchingTemplate(mockHit)).resolves.toBeNull();
-      expect(mockGetHit).toHaveBeenCalledWith('test-hit-id', true);
-    });
-  });
-
-  describe('getMatchingOverview', () => {
-    it('should return null when hit is null', async () => {
-      const { result } = renderHook(() => useMatchers());
-
-      const overview = await result.current.getMatchingOverview(null);
-
-      expect(overview).toBeNull();
-    });
-
-    it('should return null when hit is undefined', async () => {
-      const { result } = renderHook(() => useMatchers());
-
-      const overview = await result.current.getMatchingOverview(undefined);
-
-      expect(overview).toBeNull();
-    });
-
-    it('should return overview from metadata when it exists', async () => {
-      const { has } = await import('lodash-es');
-      (has as any).mockReturnValue(true);
-
-      const { result } = renderHook(() => useMatchers());
-
-      const overview = await result.current.getMatchingOverview(mockHitWithMetadata);
-
-      expect(overview).toBe(mockOverview);
-      expect(mockGetHit).not.toHaveBeenCalled();
-    });
-
-    it('should fetch hit with metadata when overview is not present', async () => {
-      const { has } = await import('lodash-es');
-      (has as any).mockReturnValue(false);
-
-      const hitWithFetchedMetadata = { ...mockHit, __overview: mockOverview };
-      mockGetHit.mockResolvedValue(hitWithFetchedMetadata);
-
-      const { result } = renderHook(() => useMatchers());
-
-      const overview = await result.current.getMatchingOverview(mockHit);
-
-      expect(overview).toBe(mockOverview);
-      expect(mockGetHit).toHaveBeenCalledWith('test-hit-id', true);
-    });
-
-    it('should handle getHit rejection gracefully', async () => {
-      const { has } = await import('lodash-es');
-      (has as any).mockReturnValue(false);
-
-      mockGetHit.mockRejectedValue(new Error('Failed to fetch hit'));
-
-      const { result } = renderHook(() => useMatchers());
-
-      await expect(result.current.getMatchingOverview(mockHit)).resolves.toBeNull();
-      expect(mockGetHit).toHaveBeenCalledWith('test-hit-id', true);
-    });
-  });
-
-  describe('getMatchingDossiers', () => {
-    it('should return null when hit is null', async () => {
-      const { result } = renderHook(() => useMatchers());
-
-      const dossiers = await result.current.getMatchingDossiers(null);
-
-      expect(dossiers).toBeNull();
-    });
-
-    it('should return null when hit is undefined', async () => {
-      const { result } = renderHook(() => useMatchers());
-
-      const dossiers = await result.current.getMatchingDossiers(undefined);
-
-      expect(dossiers).toBeNull();
-    });
-
-    it('should return dossiers from metadata when they exist', async () => {
-      const { has } = await import('lodash-es');
-      (has as any).mockReturnValue(true);
-
-      const { result } = renderHook(() => useMatchers());
-
-      const dossiers = await result.current.getMatchingDossiers(mockHitWithMetadata);
-
-      expect(dossiers).toBe(mockDossiers);
-      expect(mockGetHit).not.toHaveBeenCalled();
-    });
-
-    it('should fetch hit with metadata when dossiers are not present', async () => {
-      const { has } = await import('lodash-es');
-      (has as any).mockReturnValue(false);
-
-      const hitWithFetchedMetadata = { ...mockHit, __dossiers: mockDossiers };
-      mockGetHit.mockResolvedValue(hitWithFetchedMetadata);
-
-      const { result } = renderHook(() => useMatchers());
-
-      const dossiers = await result.current.getMatchingDossiers(mockHit);
-
-      expect(dossiers).toBe(mockDossiers);
-      expect(mockGetHit).toHaveBeenCalledWith('test-hit-id', true);
-    });
-
-    it('should handle getHit rejection gracefully', async () => {
-      const { has } = await import('lodash-es');
-      (has as any).mockReturnValue(false);
-
-      mockGetHit.mockRejectedValue(new Error('Failed to fetch hit'));
-
-      const { result } = renderHook(() => useMatchers());
-
-      await expect(result.current.getMatchingDossiers(mockHit)).resolves.toEqual([]);
-      expect(mockGetHit).toHaveBeenCalledWith('test-hit-id', true);
-    });
-  });
-
-  describe('integration tests', () => {
-    it('should correctly handle has function calls for different metadata properties', async () => {
-      const { has } = await import('lodash-es');
-
-      // Mock has to return true for __template, false for others
-      (has as any).mockImplementation((_obj: any, prop: string) => {
-        return prop === '__template';
-      });
-
-      const hitWithPartialMetadata = {
-        ...mockHit,
-        __template: mockTemplate
-      };
-
-      mockGetHit.mockResolvedValue({
-        ...mockHit,
-        __overview: mockOverview,
-        __dossiers: mockDossiers
-      });
-
-      const { result } = renderHook(() => useMatchers());
-
-      // Should return template from metadata
-      const template = await result.current.getMatchingTemplate(hitWithPartialMetadata);
-      expect(template).toBe(mockTemplate);
-
-      // Should fetch overview
-      const overview = await result.current.getMatchingOverview(hitWithPartialMetadata);
-      expect(overview).toBe(mockOverview);
-
-      // Should fetch dossiers
-      const dossiers = await result.current.getMatchingDossiers(hitWithPartialMetadata);
-      expect(dossiers).toBe(mockDossiers);
-
-      // Verify has was called with correct parameters
-      expect(has).toHaveBeenCalledWith(hitWithPartialMetadata, '__template');
-      expect(has).toHaveBeenCalledWith(hitWithPartialMetadata, '__overview');
-      expect(has).toHaveBeenCalledWith(hitWithPartialMetadata, '__dossiers');
-    });
-
-    it('should handle empty or undefined metadata gracefully', async () => {
-      const { has } = await import('lodash-es');
-      (has as any).mockReturnValue(false);
-
-      mockGetHit.mockResolvedValue({
-        ...mockHit,
-        __template: undefined,
-        __overview: null,
-        __dossiers: []
-      });
-
-      const { result } = renderHook(() => useMatchers());
-
-      const template = await result.current.getMatchingTemplate(mockHit);
-      const overview = await result.current.getMatchingOverview(mockHit);
-      const dossiers = await result.current.getMatchingDossiers(mockHit);
-
-      expect(template).toBeUndefined();
-      expect(overview).toBeNull();
-      expect(dossiers).toEqual([]);
-      expect(mockGetHit).toHaveBeenCalledTimes(3);
-    });
-
-    it('should maintain referential equality of returned functions', () => {
-      const { result, rerender } = renderHook(() => useMatchers());
-
-      const firstRender = {
-        getMatchingTemplate: result.current.getMatchingTemplate,
-        getMatchingOverview: result.current.getMatchingOverview,
-        getMatchingDossiers: result.current.getMatchingDossiers
-      };
-
-      rerender();
-
-      const secondRender = {
-        getMatchingTemplate: result.current.getMatchingTemplate,
-        getMatchingOverview: result.current.getMatchingOverview,
-        getMatchingDossiers: result.current.getMatchingDossiers
-      };
-
-      // Functions should be the same reference due to useCallback
-      expect(firstRender.getMatchingTemplate).toBe(secondRender.getMatchingTemplate);
-      expect(firstRender.getMatchingOverview).toBe(secondRender.getMatchingOverview);
-      expect(firstRender.getMatchingDossiers).toBe(secondRender.getMatchingDossiers);
-    });
-  });
-});

package/components/app/providers/ViewProvider.test.tsx

@@ -1,244 +0,0 @@
-import type { RenderHookResult } from '@testing-library/react';
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { hget, hpost, hput } from 'api';
-import MockLocalStorage from 'tests/MockLocalStorage';
-import { MOCK_RESPONSES } from 'tests/server-handlers';
-import { useContextSelector } from 'use-context-selector';
-import { MY_LOCAL_STORAGE_PREFIX, StorageKey } from 'utils/constants';
-import ViewProvider, { ViewContext, type ViewContextType } from './ViewProvider';
-
-let mockUser = {
-  favourite_views: ['favourited_view_id']
-};
-
-vi.mock('api', { spy: true });
-vi.mock('react-router-dom', () => ({
-  useLocation: vi.fn(() => ({ pathname: '/views/searched_view_id' })),
-  useParams: vi.fn(() => ({ id: 'searched_view_id' }))
-}));
-vi.mock('commons/components/app/hooks', () => ({
-  useAppUser: () => ({
-    user: mockUser,
-    setUser: _user => (mockUser = _user)
-  })
-}));
-
-const mockLocalStorage: Storage = new MockLocalStorage() as any;
-
-// Replace localStorage in global scope
-Object.defineProperty(window, 'localStorage', {
-  value: mockLocalStorage,
-  writable: true
-});
-
-const Wrapper = ({ children }) => {
-  return <ViewProvider>{children}</ViewProvider>;
-};
-
-beforeEach(() => {
-  mockLocalStorage.clear();
-});
-
-describe('ViewContext', () => {
-  it('should fetch the defaultView on initialization', async () => {
-    mockLocalStorage.setItem(
-      `${MY_LOCAL_STORAGE_PREFIX}.${StorageKey.DEFAULT_VIEW}`,
-      JSON.stringify('searched_view_id')
-    );
-
-    let hook = await act(async () =>
-      renderHook(() => useContextSelector(ViewContext, ctx => ctx.views), { wrapper: Wrapper })
-    );
-
-    await waitFor(() => expect(hook.result.current.searched_view_id).not.toBeFalsy());
-
-    expect(hook.result.current.searched_view_id).toEqual(MOCK_RESPONSES['/api/v1/search/view'].items[0]);
-  });
-
-  it('should allow the user to add and remove a favourite view', async () => {
-    interface HookResult {
-      addFavourite: ViewContextType['addFavourite'];
-      removeFavourite: ViewContextType['removeFavourite'];
-    }
-
-    const hook: RenderHookResult<HookResult, any> = await act(async () => {
-      return renderHook(
-        () =>
-          useContextSelector(ViewContext, ctx => ({
-            addFavourite: ctx.addFavourite,
-            removeFavourite: ctx.removeFavourite
-          })),
-        { wrapper: Wrapper }
-      );
-    });
-
-    await hook.result.current.addFavourite('example_view_id');
-
-    expect(mockUser.favourite_views).toEqual(['favourited_view_id', 'example_view_id']);
-
-    await hook.result.current.removeFavourite('example_view_id');
-
-    expect(mockUser.favourite_views).toEqual(['favourited_view_id']);
-  });
-
-  it('should allow the user to add and remove views', async () => {
-    interface HookResult {
-      addView: ViewContextType['addView'];
-      removeView: ViewContextType['removeView'];
-      views: ViewContextType['views'];
-    }
-
-    const hook: RenderHookResult<HookResult, any> = await act(async () => {
-      return renderHook(
-        () =>
-          useContextSelector(ViewContext, ctx => ({
-            addView: ctx.addView,
-            removeView: ctx.removeView,
-            views: ctx.views
-          })),
-        { wrapper: Wrapper }
-      );
-    });
-
-    const result = await act(async () =>
-      hook.result.current.addView({
-        owner: 'user',
-        settings: {
-          advance_on_triage: false
-        },
-        view_id: 'example_created_view',
-        query: 'howler.id:*',
-        sort: 'event.created desc',
-        title: 'Example View',
-        type: 'personal',
-        span: 'date.range.1.month'
-      })
-    );
-
-    hook.rerender();
-
-    expect(hook.result.current.views[result.view_id]).toEqual(result);
-
-    await act(async () => hook.result.current.removeView(result.view_id));
-
-    hook.rerender();
-
-    expect(hook.result.current.views[result.view_id]).toBeFalsy();
-  });
-
-  describe('fetchViews', () => {
-    let hook: RenderHookResult<ViewContextType['fetchViews'], any>;
-    beforeEach(async () => {
-      hook = await act(async () => {
-        return renderHook(() => useContextSelector(ViewContext, ctx => ctx.fetchViews), { wrapper: Wrapper });
-      });
-
-      vi.mocked(hpost).mockClear();
-      vi.mocked(hget).mockClear();
-    });
-
-    it('Should fetch all views when no ids are provided', async () => {
-      const result = await act(async () => hook.result.current());
-
-      expect(result.length).toBe(2);
-      expect(result[0].view_id).toBe('example_view_id');
-      expect(result[1].view_id).toBe('another_view_id');
-    });
-
-    it('Should search for specified views when ids are provided', async () => {
-      const result = await act(async () => hook.result.current(['searched_view_id']));
-
-      expect(hpost).toHaveBeenCalledOnce();
-      expect(hpost).toBeCalledWith('/api/v1/search/view', {
-        query: 'view_id:(searched_view_id)',
-        rows: 1,
-        sort: 'title asc'
-      });
-
-      expect(result).toEqual(MOCK_RESPONSES['/api/v1/search/view'].items);
-    });
-
-    it('Should search only for new views when ids are provided', async () => {
-      await act(async () => hook.result.current(['searched_view_id']));
-
-      expect(hpost).toHaveBeenCalledOnce();
-      expect(hpost).toBeCalledWith('/api/v1/search/view', {
-        query: 'view_id:(searched_view_id)',
-        rows: 1,
-        sort: 'title asc'
-      });
-
-      vi.mocked(hpost).mockClear();
-      await act(async () => hook.result.current(['searched_view_id', 'searched_view_id_2']));
-
-      expect(hpost).toHaveBeenCalledOnce();
-      expect(hpost).toBeCalledWith('/api/v1/search/view', {
-        query: 'view_id:(searched_view_id_2)',
-        rows: 1,
-        sort: 'title asc'
-      });
-    });
-
-    it('Should provide cached instances as a response when the same views are requested', async () => {
-      let result = await act(async () => hook.result.current(['searched_view_id']));
-
-      expect(result).toEqual(MOCK_RESPONSES['/api/v1/search/view'].items);
-
-      result = await act(async () => hook.result.current(['searched_view_id']));
-
-      expect(result).toEqual(MOCK_RESPONSES['/api/v1/search/view'].items);
-
-      expect(hpost).toHaveBeenCalledOnce();
-    });
-  });
-
-  describe('getCurrentView', () => {
-    let hook: RenderHookResult<ViewContextType['getCurrentView'], any>;
-    beforeEach(async () => {
-      hook = await act(async () => {
-        return renderHook(() => useContextSelector(ViewContext, ctx => ctx.getCurrentView), { wrapper: Wrapper });
-      });
-    });
-
-    it('should allow the user to fetch their current view based on the location', async () => {
-      // lazy load should return nothing
-      await expect(hook.result.current({ lazy: true })).resolves.toBeFalsy();
-
-      const result = await act(async () => hook.result.current());
-
-      expect(result).toEqual(MOCK_RESPONSES['/api/v1/search/view'].items[0]);
-    });
-
-    it('should allow the user to fetch their current view based on the view ID', async () => {
-      // lazy load should return nothing
-      await expect(hook.result.current({ lazy: true })).resolves.toBeFalsy();
-
-      const result = await act(async () => hook.result.current({ viewId: 'searched_view_id' }));
-
-      expect(result).toEqual(MOCK_RESPONSES['/api/v1/search/view'].items[0]);
-    });
-  });
-
-  describe('editView', () => {
-    let hook: RenderHookResult<ViewContextType['editView'], any>;
-    beforeAll(async () => {
-      hook = await act(async () => {
-        return renderHook(() => useContextSelector(ViewContext, ctx => ctx.editView), { wrapper: Wrapper });
-      });
-    });
-
-    beforeEach(() => {
-      vi.mocked(hput).mockClear();
-      vi.mocked(hpost).mockClear();
-    });
-
-    it('should allow users to edit views', async () => {
-      const result = await act(async () => hook.result.current('example_view_id', { query: 'howler.id:*' }));
-
-      expect(hput).toHaveBeenCalledOnce();
-      expect(hput).toBeCalledWith('/api/v1/view/example_view_id', { query: 'howler.id:*' });
-
-      expect(result).toEqual(MOCK_RESPONSES['/api/v1/view/example_view_id']);
-    });
-  });
-});