@availity/hooks 6.0.0 → 7.0.0

package/tests/useOrganizations.test.tsx

@@ -0,0 +1,49 @@
+import React from 'react';
+import { waitFor, cleanup } from '@testing-library/react';
+import { QueryClient } from '@tanstack/react-query';
+import { http, HttpResponse } from 'msw';
+import { server } from '@availity/mock/src/server';
+import { USER_A2 } from '@availity/mock/src/routes';
+import renderWithClient from './util';
+import { useOrganizations } from '../src/index';
+
+const queryClient = new QueryClient();
+
+afterEach(() => {
+  cleanup();
+  queryClient.clear();
+});
+
+const Component = () => {
+  const { data, error, status } = useOrganizations({}, { gcTime: 0, retry: false });
+
+  return (
+    <div>
+      <h1>Status: {status}</h1>
+      <h1>Data: {JSON.stringify(data?.data)}</h1>
+      <h1>Error: {error?.message}</h1>
+    </div>
+  );
+};
+
+describe('useOrganizations', () => {
+  test('should return an error', async () => {
+    server.use(http.get(USER_A2, () => HttpResponse.error()));
+
+    const { getByText } = renderWithClient(queryClient, <Component />);
+
+    getByText('Status: pending');
+    await waitFor(() => {
+      expect(getByText('Status: error')).toBeDefined();
+    });
+  });
+
+  test('should return organizations', async () => {
+    const { getByText } = renderWithClient(queryClient, <Component />);
+
+    getByText('Status: pending');
+    await waitFor(() => {
+      expect(getByText(/Techmania/)).toBeDefined();
+    });
+  });
+});

package/tests/usePermissions.test.tsx

@@ -0,0 +1,52 @@
+import React from 'react';
+import { waitFor, cleanup } from '@testing-library/react';
+import { QueryClient } from '@tanstack/react-query';
+import { http, HttpResponse } from 'msw';
+import { server } from '@availity/mock/src/server';
+import { PERMISSIONS } from '@availity/mock/src/routes';
+import renderWithClient from './util';
+import { usePermissions } from '../src/index';
+
+const queryClient = new QueryClient();
+
+afterEach(() => {
+  cleanup();
+  queryClient.clear();
+});
+
+const Component = () => {
+  const { data, error, status } = usePermissions({}, { gcTime: 0, retry: false });
+
+  return (
+    <div>
+      <h1>Status: {status}</h1>
+      <h1>Data: {JSON.stringify(data?.data)}</h1>
+      <h1>Error: {error?.message}</h1>
+    </div>
+  );
+};
+
+describe('usePermissions', () => {
+  test('should return an error', async () => {
+    server.use(http.get(PERMISSIONS, () => HttpResponse.error()));
+
+    const { getByText } = renderWithClient(queryClient, <Component />);
+
+    getByText('Status: pending');
+    await waitFor(() => {
+      expect(getByText('Status: error')).toBeDefined();
+    });
+  });
+
+  test('should return permissions', async () => {
+    const { getByText } = renderWithClient(queryClient, <Component />);
+
+    getByText('Status: pending');
+    await waitFor(() => {
+      expect(getByText(/"id":"123"/)).toBeDefined();
+    });
+    await waitFor(() => {
+      expect(getByText(/Do the thing/)).toBeDefined();
+    });
+  });
+});

package/tests/useProviders.test.tsx

@@ -0,0 +1,49 @@
+import React from 'react';
+import { waitFor, cleanup } from '@testing-library/react';
+import { QueryClient } from '@tanstack/react-query';
+import { http, HttpResponse } from 'msw';
+import { server } from '@availity/mock/src/server';
+import { PROVIDERS } from '@availity/mock/src/routes';
+import renderWithClient from './util';
+import { useProviders } from '../src/index';
+
+const queryClient = new QueryClient();
+
+afterEach(() => {
+  cleanup();
+  queryClient.clear();
+});
+
+const Component = () => {
+  const { data, error, status } = useProviders({}, { gcTime: 0, retry: false });
+
+  return (
+    <div>
+      <h1>Status: {status}</h1>
+      <h1>Data: {JSON.stringify(data?.data)}</h1>
+      <h1>Error: {error?.message}</h1>
+    </div>
+  );
+};
+
+describe('useProviders', () => {
+  test('should return an error', async () => {
+    server.use(http.get(PROVIDERS, () => HttpResponse.error()));
+
+    const { getByText } = renderWithClient(queryClient, <Component />);
+
+    getByText('Status: pending');
+    await waitFor(() => {
+      expect(getByText('Status: error')).toBeDefined();
+    });
+  });
+
+  test('should return providers', async () => {
+    const { getByText } = renderWithClient(queryClient, <Component />);
+
+    getByText('Status: pending');
+    await waitFor(() => {
+      expect(getByText(/BITREX/)).toBeDefined();
+    });
+  });
+});

package/tests/useStash.test.tsx

@@ -0,0 +1,58 @@
+import React from 'react';
+import { waitFor, cleanup } from '@testing-library/react';
+import { QueryClient } from '@tanstack/react-query';
+import { http, HttpResponse } from 'msw';
+import { server } from '@availity/mock/src/server';
+import { STASH } from '@availity/mock/src/routes';
+import { useStash } from '../src';
+import renderWithClient from './util';
+
+const queryClient = new QueryClient();
+
+afterEach(() => {
+  cleanup();
+  queryClient.clear();
+});
+
+const Component = ({ sessionId }: { sessionId: string }) => {
+  const { data, error, status } = useStash(sessionId, { gcTime: 0, retry: false });
+
+  return (
+    <div>
+      <h1>Status: {status}</h1>
+      <h1>Data: {JSON.stringify(data)}</h1>
+      <h1>Error: {error?.message}</h1>
+    </div>
+  );
+};
+
+describe('useStash', () => {
+  test('should return an error', async () => {
+    server.use(http.get(STASH, () => HttpResponse.error()));
+
+    const { getByText } = renderWithClient(queryClient, <Component sessionId="test-session-id" />);
+
+    getByText('Status: pending');
+    await waitFor(() => {
+      expect(getByText('Status: error')).toBeDefined();
+    });
+  });
+
+  test('should return stash data', async () => {
+    const { getByText } = renderWithClient(queryClient, <Component sessionId="test-session-id" />);
+
+    getByText('Status: pending');
+    await waitFor(() => {
+      expect(getByText(/"key":"value"/)).toBeDefined();
+    });
+    await waitFor(() => {
+      expect(getByText(/"nested":\{"foo":"bar"\}/)).toBeDefined();
+    });
+  });
+
+  test('should not fetch when sessionId is empty', () => {
+    const { getByText } = renderWithClient(queryClient, <Component sessionId="" />);
+
+    expect(getByText('Status: pending')).toBeDefined();
+  });
+});

package/tests/{useToggle.test.jsx → useToggle.test.tsx}

@@ -4,8 +4,7 @@ import { useToggle } from '../src/index';
 
 afterEach(cleanup);
 
-// eslint-disable-next-line react/prop-types
-const Component = ({ initialToggle = false }) => {
+const Component = ({ initialToggle = false }: { initialToggle?: boolean }) => {
   const [isToggled, toggle] = useToggle(initialToggle);
 
   return (

package/tests/{useUpdateNav.test.jsx → useUpdateNav.test.tsx}

@@ -1,5 +1,6 @@
+import React from 'react';
 import { render, screen, fireEvent } from '@testing-library/react';
-import { MemoryRouter, useNavigate, Routes, Route } from 'react-router-dom';
+import { MemoryRouter, useNavigate, Routes, Route } from 'react-router';
 import avMessageMock from '@availity/message-core';
 
 import useUpdateNav from '../src/useUpdateNav';

package/tests/{useWindowDimensions.test.jsx → useWindowDimensions.test.tsx}

@@ -6,7 +6,6 @@ const Component = () => {
   const { height, width } = useWindowDimensions();
   return (
     <div data-testid="window_dimensions">
-      {' '}
       <span data-testid="window_height">{height}</span>
       <span data-testid="window_width">{width}</span>
     </div>

package/tests/util.tsx

@@ -0,0 +1,7 @@
+import React from 'react';
+import { render } from '@testing-library/react';
+import { QueryClientProvider, QueryClient } from '@tanstack/react-query';
+
+export default function renderWithClient(client: QueryClient, ui: React.ReactElement) {
+  return render(<QueryClientProvider client={client}>{ui}</QueryClientProvider>);
+}

package/tests/useCurrentRegion.test.jsx

@@ -1,96 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import { waitFor, cleanup } from '@testing-library/react';
-import { avRegionsApi } from '@availity/api-axios';
-import { QueryClient } from '@tanstack/react-query';
-import { useCurrentRegion } from '../src/index';
-import renderWithClient from './util';
-
-vi.mock('@availity/api-axios');
-
-let queryStates = [];
-beforeEach(() => {
-  queryStates = [];
-});
-
-const queryClient = new QueryClient();
-
-afterEach(() => {
-  vi.clearAllMocks();
-  cleanup();
-  queryClient.clear();
-  queryStates = [];
-});
-
-const pushState = (state) => {
-  queryStates.push(state);
-};
-
-const Component = ({ log }) => {
-  // Mirror testing methods from react-query instead of relying on timing or booleans
-  // https://github.com/tannerlinsley/react-query/blob/master/src/react/tests/useQuery.test.tsx
-  const state = useCurrentRegion({ gcTime: 0, retry: false });
-
-  // not directly used in assertions here, but useful for debugging purposes
-  if (log) log(state);
-
-  const { data, error, status } = state;
-
-  return (
-    <div>
-      <h1>Status: {status}</h1>
-      <h1>Data: {JSON.stringify(data)}</h1>
-      <h1>Error: {error}</h1>
-    </div>
-  );
-};
-
-Component.propTypes = {
-  log: PropTypes.func,
-};
-
-describe('useCurrentRegion', () => {
-  test('handle error', async () => {
-    avRegionsApi.getCurrentRegion.mockRejectedValueOnce('An error occurred');
-    const { getByText } = renderWithClient(queryClient, <Component log={pushState} />);
-
-    getByText('Status: pending');
-    await waitFor(() => {
-      const el = getByText('Status: error');
-      expect(el).toBeDefined();
-    });
-    await waitFor(() => {
-      const el = getByText('Error: An error occurred');
-      expect(el).toBeDefined();
-    });
-  });
-
-  test('handle success', async () => {
-    avRegionsApi.getCurrentRegion.mockResolvedValueOnce({
-      config: { polling: false },
-      data: {
-        regions: [
-          {
-            id: 'FL',
-            value: 'Florida',
-          },
-        ],
-      },
-      status: 200,
-      statusText: 'Ok',
-    });
-
-    const { getByText } = renderWithClient(queryClient, <Component log={pushState} />);
-
-    getByText('Status: pending');
-    await waitFor(() => {
-      const el = getByText(
-        `Data: ${JSON.stringify({
-          code: 'FL',
-          value: 'Florida',
-        })}`
-      );
-      expect(el).toBeDefined();
-    });
-  });
-});

package/tests/useCurrentUser.test.jsx

@@ -1,94 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import { waitFor, cleanup } from '@testing-library/react';
-import { avUserApi } from '@availity/api-axios';
-import { QueryClient } from '@tanstack/react-query';
-import { useCurrentUser } from '../src/index';
-import renderWithClient from './util';
-
-vi.mock('@availity/api-axios');
-
-let queryStates = [];
-beforeEach(() => {
-  queryStates = [];
-});
-
-const queryClient = new QueryClient();
-
-afterEach(() => {
-  vi.clearAllMocks();
-  cleanup();
-  queryClient.clear();
-  queryStates = [];
-});
-
-const pushState = (state) => {
-  queryStates.push(state);
-};
-
-const Component = ({ log }) => {
-  // Mirror testing methods from react-query instead of relying on timing or booleans
-  // https://github.com/tannerlinsley/react-query/blob/master/src/react/tests/useQuery.test.tsx
-  const state = useCurrentUser({ gcTime: 0, retry: false });
-
-  // not directly used in assertions here, but useful for debugging purposes
-  if (log) log(state);
-
-  const { data, error, status } = state;
-
-  return (
-    <div>
-      <h1>Status: {status}</h1>
-      <h1>Data: {JSON.stringify(data)}</h1>
-      <h1>Error: {error}</h1>
-    </div>
-  );
-};
-
-Component.propTypes = {
-  log: PropTypes.func,
-};
-
-describe('useCurrentUser', () => {
-  test('should set error on rejected promise', async () => {
-    avUserApi.me.mockRejectedValueOnce('An error occurred');
-
-    const { getByText } = renderWithClient(queryClient, <Component log={pushState} />);
-
-    getByText('Status: pending');
-    await waitFor(() => {
-      const el = getByText('Status: error');
-      expect(el).toBeDefined();
-    });
-    await waitFor(() => {
-      const el = getByText('Error: An error occurred');
-      expect(el).toBeDefined();
-    });
-  });
-
-  test('should return user', async () => {
-    avUserApi.me.mockResolvedValueOnce({
-      id: 'aka12345',
-      userId: 'testExample',
-      akaname: 'aka12345',
-      lastName: 'Last',
-      firstName: 'First',
-    });
-
-    const { getByText } = renderWithClient(queryClient, <Component log={pushState} />);
-
-    getByText('Status: pending');
-    await waitFor(() => {
-      const el = getByText(
-        `Data: ${JSON.stringify({
-          id: 'aka12345',
-          userId: 'testExample',
-          akaname: 'aka12345',
-          lastName: 'Last',
-          firstName: 'First',
-        })}`
-      );
-      expect(el).toBeDefined();
-    });
-  });
-});

package/tests/useOrganizations.test.jsx

@@ -1,112 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import { waitFor, cleanup } from '@testing-library/react';
-import { avOrganizationsApi } from '@availity/api-axios';
-import { QueryClient } from '@tanstack/react-query';
-import renderWithClient from './util';
-import { useOrganizations } from '../src/index';
-
-vi.mock('@availity/api-axios');
-
-let queryStates = [];
-beforeEach(() => {
-  queryStates = [];
-});
-
-const queryClient = new QueryClient();
-
-afterEach(() => {
-  vi.clearAllMocks();
-  cleanup();
-  queryClient.clear();
-  queryStates = [];
-});
-
-const pushState = (state) => {
-  queryStates.push(state);
-};
-
-const Component = ({ log }) => {
-  // Mirror testing methods from react-query instead of relying on timing or booleans
-  // https://github.com/tannerlinsley/react-query/blob/master/src/react/tests/useQuery.test.tsx
-  const state = useOrganizations({}, { gcTime: 0, retry: false });
-
-  // not directly used in assertions here, but useful for debugging purposes
-  if (log) log(state);
-
-  const { data, error, status } = state;
-
-  return (
-    <div>
-      <h1>Status: {status}</h1>
-      <h1>Data: {JSON.stringify(data)}</h1>
-      <h1>Error: {error}</h1>
-    </div>
-  );
-};
-
-Component.propTypes = {
-  log: PropTypes.func,
-};
-
-describe('useOrganizations', () => {
-  test('should return an error', async () => {
-    avOrganizationsApi.getOrganizations.mockRejectedValueOnce('An error occurred');
-
-    const { getByText } = renderWithClient(queryClient, <Component log={pushState} />);
-
-    getByText('Status: pending');
-    await waitFor(() => {
-      const el = getByText('Status: error');
-      expect(el).toBeDefined();
-    });
-    await waitFor(() => {
-      const el = getByText('Error: An error occurred');
-      expect(el).toBeDefined();
-    });
-  });
-
-  test('should return organizations', async () => {
-    avOrganizationsApi.getOrganizations.mockResolvedValueOnce({
-      data: {
-        organizations: [
-          {
-            links: {
-              permissions: { href: 'test' },
-              patients: { href: 'test' },
-              self: { href: 'test' },
-              admin: { href: 'test' },
-              businessArrangements: { href: 'test' },
-              users: { href: 'test' },
-            },
-          },
-        ],
-      },
-    });
-
-    const { getByText } = renderWithClient(queryClient, <Component log={pushState} />);
-
-    getByText('Status: pending');
-    await waitFor(() => {
-      const el = getByText(
-        `Data: ${JSON.stringify({
-          data: {
-            organizations: [
-              {
-                links: {
-                  permissions: { href: 'test' },
-                  patients: { href: 'test' },
-                  self: { href: 'test' },
-                  admin: { href: 'test' },
-                  businessArrangements: { href: 'test' },
-                  users: { href: 'test' },
-                },
-              },
-            ],
-          },
-        })}`
-      );
-      expect(el).toBeDefined();
-    });
-  });
-});

package/tests/usePermissions.test.jsx

@@ -1,90 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import { waitFor, cleanup } from '@testing-library/react';
-import { avPermissionsApi } from '@availity/api-axios';
-import { QueryClient } from '@tanstack/react-query';
-import renderWithClient from './util';
-import { usePermissions } from '../src/index';
-
-vi.mock('@availity/api-axios');
-
-let queryStates = [];
-beforeEach(() => {
-  queryStates = [];
-});
-
-const queryClient = new QueryClient();
-
-afterEach(() => {
-  vi.clearAllMocks();
-  cleanup();
-  queryClient.clear();
-  queryStates = [];
-});
-
-const pushState = (state) => {
-  queryStates.push(state);
-};
-
-const Component = ({ log }) => {
-  // Mirror testing methods from react-query instead of relying on timing or booleans
-  // https://github.com/tannerlinsley/react-query/blob/master/src/react/tests/useQuery.test.tsx
-  const state = usePermissions({}, { gcTime: 0, retry: false });
-
-  // not directly used in assertions here, but useful for debugging purposes
-  if (log) log(state);
-
-  const { data, error, status } = state;
-
-  return (
-    <div>
-      <h1>Status: {status}</h1>
-      <h1>Data: {JSON.stringify(data)}</h1>
-      <h1>Error: {error}</h1>
-    </div>
-  );
-};
-
-Component.propTypes = {
-  log: PropTypes.func,
-};
-
-describe('usePermissions', () => {
-  test('should return an error', async () => {
-    avPermissionsApi.getPermissions.mockRejectedValueOnce('An error occurred');
-
-    const { getByText } = renderWithClient(queryClient, <Component log={pushState} />);
-
-    getByText('Status: pending');
-    await waitFor(() => {
-      const el = getByText('Status: error');
-      expect(el).toBeDefined();
-    });
-    await waitFor(() => {
-      const el = getByText('Error: An error occurred');
-      expect(el).toBeDefined();
-    });
-  });
-
-  test('should return permissions', async () => {
-    avPermissionsApi.getPermissions.mockResolvedValueOnce({
-      id: '44',
-      description: 'test',
-      links: { self: { href: 'test.com' } },
-    });
-
-    const { getByText } = renderWithClient(queryClient, <Component log={pushState} />);
-
-    getByText('Status: pending');
-    await waitFor(() => {
-      const el = getByText(
-        `Data: ${JSON.stringify({
-          id: '44',
-          description: 'test',
-          links: { self: { href: 'test.com' } },
-        })}`
-      );
-      expect(el).toBeDefined();
-    });
-  });
-});