refactor(imaging): use react query instead of redux to fetch imaging data

src/__tests__/HospitalRun.test.tsx

@@ -9,7 +9,7 @@ import thunk from 'redux-thunk'
 
 import Dashboard from '../dashboard/Dashboard'
 import HospitalRun from '../HospitalRun'
-import ViewImagings from '../imagings/ViewImagings'
+import ViewImagings from '../imagings/search/ViewImagings'
 import Incidents from '../incidents/Incidents'
 import ViewLabs from '../labs/ViewLabs'
 import ViewMedications from '../medications/ViewMedications'
@@ -224,11 +224,10 @@ describe('HospitalRun', () => {
 
  describe('/imaging', () => {
  it('should render the Imagings component when /imaging is accessed', async () => {
- jest.spyOn(ImagingRepository, 'findAll').mockResolvedValue([])
+ jest.spyOn(ImagingRepository, 'search').mockResolvedValue([])
  const store = mockStore({
  title: 'test',
  user: { user: { id: '123' }, permissions: [Permissions.ViewImagings] },
- imagings: { imagings: [] },
  breadcrumbs: { breadcrumbs: [] },
  components: { sidebarCollapsed: false },
  } as any)

src/__tests__/imagings/hooks/useImagingRequest.test.tsx

@@ -0,0 +1,32 @@
+import { renderHook, act } from '@testing-library/react-hooks'
+
+import useImagingRequest from '../../../imagings/hooks/useImagingRequest'
+import ImagingRepository from '../../../shared/db/ImagingRepository'
+import Imaging from '../../../shared/model/Imaging'
+import waitUntilQueryIsSuccessful from '../../test-utils/wait-for-query.util'
+
+describe('useImagingRequest', () => {
+ it('should get an imaging request by id', async () => {
+ const expectedImagingId = 'some id'
+ const expectedImagingRequest = {
+ id: expectedImagingId,
+ patient: 'some patient',
+ visitId: 'visit id',
+ status: 'requested',
+ type: 'some type',
+ } as Imaging
+ jest.spyOn(ImagingRepository, 'find').mockResolvedValue(expectedImagingRequest)
+
+ let actualData: any
+ await act(async () => {
+ const renderHookResult = renderHook(() => useImagingRequest(expectedImagingId))
+ const { result } = renderHookResult
+ await waitUntilQueryIsSuccessful(renderHookResult)
+ actualData = result.current.data
+ })
+
+ expect(ImagingRepository.find).toHaveBeenCalledTimes(1)
+ expect(ImagingRepository.find).toBeCalledWith(expectedImagingId)
+ expect(actualData).toEqual(expectedImagingRequest)
+ })
+})

src/__tests__/imagings/hooks/useImagingSearch.test.tsx

@@ -0,0 +1,43 @@
+import { act, renderHook } from '@testing-library/react-hooks'
+
+import useImagingSearch from '../../../imagings/hooks/useImagingSearch'
+import ImagingSearchRequest from '../../../imagings/model/ImagingSearchRequest'
+import ImagingRepository from '../../../shared/db/ImagingRepository'
+import SortRequest from '../../../shared/db/SortRequest'
+import Imaging from '../../../shared/model/Imaging'
+import waitUntilQueryIsSuccessful from '../../test-utils/wait-for-query.util'
+
+const defaultSortRequest: SortRequest = {
+ sorts: [
+ {
+ field: 'requestedOn',
+ direction: 'desc',
+ },
+ ],
+}
+
+describe('useImagingSearch', () => {
+ it('it should search imaging requests', async () => {
+ const expectedSearchRequest: ImagingSearchRequest = {
+ status: 'completed',
+ text: 'some search request',
+ }
+ const expectedImagingRequests = [{ id: 'some id' }] as Imaging[]
+ jest.spyOn(ImagingRepository, 'search').mockResolvedValue(expectedImagingRequests)
+
+ let actualData: any
+ await act(async () => {
+ const renderHookResult = renderHook(() => useImagingSearch(expectedSearchRequest))
+ const { result } = renderHookResult
+ await waitUntilQueryIsSuccessful(renderHookResult)
+ actualData = result.current.data
+ })
+
+ expect(ImagingRepository.search).toHaveBeenCalledTimes(1)
+ expect(ImagingRepository.search).toBeCalledWith({
+ ...expectedSearchRequest,
+ defaultSortRequest,
+ })
+ expect(actualData).toEqual(expectedImagingRequests)
+ })
+})

src/__tests__/imagings/hooks/useRequestImaging.test.tsx

@@ -0,0 +1,55 @@
+/* eslint-disable no-console */
+
+import useRequestImaging from '../../../imagings/hooks/useRequestImaging'
+import { ImagingRequestError } from '../../../imagings/util/validate-imaging-request'
+import * as imagingRequestValidator from '../../../imagings/util/validate-imaging-request'
+import ImagingRepository from '../../../shared/db/ImagingRepository'
+import Imaging from '../../../shared/model/Imaging'
+import executeMutation from '../../test-utils/use-mutation.util'
+
+describe('useReportIncident', () => {
+ beforeEach(() => {
+ jest.restoreAllMocks()
+ console.error = jest.fn()
+ })
+
+ it('should save the imaging request with correct data', async () => {
+ const expectedDate = new Date(Date.now())
+ Date.now = jest.fn().mockReturnValue(expectedDate)
+ const givenImagingRequest = {
+ patient: 'some patient',
+ fullName: 'some full name',
+ status: 'requested',
+ type: 'some type',
+ notes: 'some notes',
+ visitId: 'some visit id',
+ } as Imaging
+
+ const expectedImagingRequest = {
+ ...givenImagingRequest,
+ requestedOn: expectedDate.toISOString(),
+ requestedBy: 'test',
+ } as Imaging
+ jest.spyOn(ImagingRepository, 'save').mockResolvedValue(expectedImagingRequest)
+
+ await executeMutation(() => useRequestImaging(), givenImagingRequest)
+ expect(ImagingRepository.save).toHaveBeenCalledTimes(1)
+ expect(ImagingRepository.save).toBeCalledWith(expectedImagingRequest)
+ })
+
+ it('should throw an error if validation fails', async () => {
+ const expectedImagingRequestError = {
+ patient: 'some patient error',
+ } as ImagingRequestError
+
+ jest.spyOn(imagingRequestValidator, 'default').mockReturnValue(expectedImagingRequestError)
+ jest.spyOn(ImagingRepository, 'save').mockResolvedValue({} as Imaging)
+
+ try {
+ await executeMutation(() => useRequestImaging(), {})
+ } catch (e) {
+ expect(e).toEqual(expectedImagingRequestError)
+ expect(ImagingRepository.save).not.toHaveBeenCalled()
+ }
+ })
+})