Merge branch 'master' into IncidentsCSV

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()
+    }
+  })
+})