feat(incident): add the ability to document notes on a reported incident

.github/workflows/auto-merge.yml

@@ -0,0 +1,14 @@
+name: Dependabot PR merge
+
+on:
+  pull_request:
+
+jobs:
+  auto-merge:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ahmadnassri/action-dependabot-auto-merge@v2
+        with:
+          target: minor
+          github-token: ${{ secrets.BOT_PAT }}

src/__tests__/incidents/hooks/useAddIncidentNote.test.tsx

@@ -0,0 +1,83 @@
+import useAddIncidentNote from '../../../incidents/hooks/useAddIncidentNote'
+import IncidentRepository from '../../../shared/db/IncidentRepository'
+import Incident from '../../../shared/model/Incident'
+import Note from '../../../shared/model/Note'
+import executeMutation from '../../test-utils/use-mutation.util'
+
+describe('use add incident note', () => {
+  beforeEach(() => {
+    jest.resetAllMocks()
+  })
+
+  it('should add a new note', async () => {
+    const expectedNote = {
+      id: '5678',
+      text: 'some text',
+    } as Note
+
+    const givenIncident = {
+      id: '1234',
+      date: new Date().toISOString(),
+      notes: [] as Note[],
+    } as Incident
+
+    const expectedIncident = { ...givenIncident, notes: [expectedNote] } as Incident
+    jest.spyOn(IncidentRepository, 'find').mockResolvedValue(givenIncident)
+    jest.spyOn(IncidentRepository, 'saveOrUpdate').mockResolvedValue(expectedIncident)
+
+    const result = await executeMutation(() => useAddIncidentNote(), {
+      incidentId: givenIncident.id,
+      note: expectedNote,
+    })
+
+    expect(IncidentRepository.find).toHaveBeenCalledTimes(1)
+    expect(IncidentRepository.saveOrUpdate).toHaveBeenCalledTimes(1)
+    expect(IncidentRepository.saveOrUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        notes: [expect.objectContaining({ text: expectedNote.text })],
+      }),
+    )
+    expect(result).toEqual([expectedNote])
+  })
+
+  it('should edit an existing note', async () => {
+    const givenNote = {
+      id: '5678',
+      text: 'some new text',
+    } as Note
+
+    const expectedNote = {
+      id: '5678',
+      text: 'some edited text',
+    } as Note
+
+    const givenIncident = {
+      id: '1234',
+      date: new Date().toISOString(),
+      notes: [givenNote] as Note[],
+    } as Incident
+
+    const expectedIncident = { ...givenIncident, notes: [expectedNote] } as Incident
+    jest.spyOn(IncidentRepository, 'find').mockResolvedValue(givenIncident)
+    jest.spyOn(IncidentRepository, 'saveOrUpdate').mockResolvedValue(expectedIncident)
+
+    const result = await executeMutation(() => useAddIncidentNote(), {
+      incidentId: givenIncident.id,
+      note: expectedNote,
+    })
+
+    expect(IncidentRepository.find).toHaveBeenCalledTimes(1)
+    expect(IncidentRepository.saveOrUpdate).toHaveBeenCalledTimes(1)
+    expect(IncidentRepository.saveOrUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        notes: [expect.objectContaining({ text: expectedNote.text })],
+      }),
+    )
+    expect(IncidentRepository.saveOrUpdate).not.toHaveBeenCalledWith(
+      expect.objectContaining({
+        notes: [expect.objectContaining({ text: givenNote.text })],
+      }),
+    )
+    expect(result).toEqual([expectedNote])
+  })
+})

src/__tests__/incidents/hooks/useDeleteIncidentNote.test.tsx

@@ -0,0 +1,62 @@
+import useDeleteIncidentNote from '../../../incidents/hooks/useDeleteIncidentNote'
+import * as validateNote from '../../../patients/util/validate-note'
+import IncidentRepository from '../../../shared/db/IncidentRepository'
+import Incident from '../../../shared/model/Incident'
+import Note from '../../../shared/model/Note'
+import { expectOneConsoleError } from '../../test-utils/console.utils'
+import executeMutation from '../../test-utils/use-mutation.util'
+
+describe('use delete incident note', () => {
+  beforeEach(() => {
+    jest.resetAllMocks()
+  })
+
+  it('should delete an existing note', async () => {
+    const givenNote = {
+      id: '5678',
+      text: 'some text',
+    } as Note
+
+    const givenIncident = {
+      id: '1234',
+      date: new Date().toISOString(),
+      notes: [givenNote] as Note[],
+    } as Incident
+
+    const expectedIncident = { ...givenIncident, notes: [] } as Incident
+    jest.spyOn(IncidentRepository, 'find').mockResolvedValue(givenIncident)
+    jest.spyOn(IncidentRepository, 'saveOrUpdate').mockResolvedValue(expectedIncident)
+
+    const result = await executeMutation(() => useDeleteIncidentNote(), {
+      incidentId: givenIncident.id,
+      note: givenNote,
+    })
+
+    expect(IncidentRepository.find).toHaveBeenCalledTimes(1)
+    expect(IncidentRepository.saveOrUpdate).toHaveBeenCalledTimes(1)
+    expect(IncidentRepository.saveOrUpdate).not.toHaveBeenCalledWith(
+      expect.objectContaining({
+        notes: [expect.objectContaining({ text: givenNote.text })],
+      }),
+    )
+    expect(result).toEqual([])
+  })
+
+  it('should throw an error if note validation fails', async () => {
+    const expectedError = { nameError: 'some error' }
+    expectOneConsoleError(expectedError)
+    jest.spyOn(validateNote, 'default').mockReturnValue(expectedError)
+    jest.spyOn(IncidentRepository, 'saveOrUpdate')
+
+    try {
+      await executeMutation(() => useDeleteIncidentNote(), {
+        incidentId: '1234',
+        note: {} as Note,
+      })
+    } catch (e) {
+      expect(e).toEqual(expectedError)
+    }
+
+    expect(IncidentRepository.saveOrUpdate).not.toHaveBeenCalled()
+  })
+})

src/__tests__/incidents/view/NotesTable.test.tsx

@@ -0,0 +1,52 @@
+import { fireEvent, render, screen } from '@testing-library/react'
+import React from 'react'
+
+import NotesTable from '../../../incidents/view/NotesTable'
+import Note from '../../../shared/model/Note'
+
+const mockNote = {
+  id: '1234',
+  date: new Date().toISOString(),
+  text: 'some text',
+  givenBy: 'some user',
+} as Note
+
+const setup = (notes: Note[] = [mockNote]) => {
+  const onEditSpy = jest.fn()
+  const onDeleteSpy = jest.fn()
+
+  render(<NotesTable onEditNote={onEditSpy} onDeleteNote={onDeleteSpy} notes={notes} />)
+
+  return { onEditSpy, onDeleteSpy }
+}
+
+describe('Notes Table', () => {
+  it('should render a notes table if at least one note is in the list.', async () => {
+    setup()
+
+    expect(screen.getByRole('table')).toBeInTheDocument()
+  })
+  it('should display edit and delete buttons if notes exist', async () => {
+    setup()
+    expect(screen.getByRole('button', { name: 'actions.edit' })).toBeInTheDocument()
+    expect(screen.getByRole('button', { name: 'actions.delete' })).toBeInTheDocument()
+  })
+
+  it('should display no notes message if no notes exist', async () => {
+    setup([])
+    expect(screen.getByRole('alert')).toBeInTheDocument()
+    expect(screen.getByText('patient.notes.warning.noNotes')).toBeInTheDocument()
+  })
+
+  it('calls on edit note when edit note button clicked', async () => {
+    const { onEditSpy } = setup()
+    fireEvent.click(screen.getByRole('button', { name: 'actions.edit' }))
+    expect(onEditSpy).toHaveBeenCalled()
+  })
+
+  it('calls on delete note when delete note button clicked', async () => {
+    const { onDeleteSpy } = setup()
+    fireEvent.click(screen.getByRole('button', { name: 'actions.delete' }))
+    expect(onDeleteSpy).toHaveBeenCalled()
+  })
+})

src/__tests__/incidents/view/ViewIncident.test.tsx

@@ -1,4 +1,4 @@
-import { render, screen } from '@testing-library/react'
+import { fireEvent, render, screen } from '@testing-library/react'
 import { createMemoryHistory } from 'history'
 import React from 'react'
 import { Provider } from 'react-redux'
@@ -12,20 +12,36 @@ import { ButtonBarProvider } from '../../../page-header/button-toolbar/ButtonBar
 import { TitleProvider } from '../../../page-header/title/TitleContext'
 import IncidentRepository from '../../../shared/db/IncidentRepository'
 import Incident from '../../../shared/model/Incident'
+import Note from '../../../shared/model/Note'
 import Permissions from '../../../shared/model/Permissions'
 import { RootState } from '../../../shared/store'
 
 const mockStore = createMockStore<RootState, any>([thunk])
 
-const setup = (permissions: Permissions[], id: string | undefined) => {
-  jest.resetAllMocks()
-  jest.spyOn(breadcrumbUtil, 'default')
-  jest.spyOn(IncidentRepository, 'find').mockResolvedValue({
+const expectedNote = {
+  id: '5678',
+  date: new Date().toISOString(),
+  text: 'some text',
+  givenBy: 'some user',
+  deleted: false,
+} as Note
+
+const setup = (
+  permissions: Permissions[] | undefined,
+  id: string | undefined,
+  notes: Note[] = [],
+) => {
+  const expectedIncident = {
     id,
     date: new Date().toISOString(),
     code: 'some code',
     reportedOn: new Date().toISOString(),
-  } as Incident)
+    notes,
+  } as Incident
+
+  jest.resetAllMocks()
+  jest.spyOn(breadcrumbUtil, 'default')
+  jest.spyOn(IncidentRepository, 'find').mockResolvedValue(expectedIncident)
 
   const history = createMemoryHistory({ initialEntries: [`/incidents/${id}`] })
   const store = mockStore({
@@ -52,22 +68,67 @@ const setup = (permissions: Permissions[], id: string | undefined) => {
   }
 }
 
-it('should not render ViewIncidentDetails if there are no Permissions', async () => {
-  setup(undefined, '1234')
+describe('View Incident', () => {
+  it('should not render ViewIncidentDetails if there are no Permissions', async () => {
+    const { container } = setup(undefined, '1234')
 
-  expect(
-    screen.queryByRole('heading', {
-      name: /incidents\.reports\.dateofincident/i,
-    }),
-  ).not.toBeInTheDocument()
-})
+    expect(container.querySelector(`[class^='css-']`)).not.toBeInTheDocument()
+    expect(
+      screen.queryByRole('heading', {
+        name: /incidents\.reports\.dateofincident/i,
+      }),
+    ).not.toBeInTheDocument()
+  })
+
+  it('should render tabs header', async () => {
+    setup([Permissions.ViewIncident], '1234')
+
+    expect(await screen.findByText('patient.notes.label')).toBeInTheDocument()
+  })
+
+  it('should render notes tab and add new note button when clicked', async () => {
+    setup([Permissions.ViewIncident, Permissions.ReportIncident], '1234')
+
+    fireEvent.click(await screen.findByText('patient.notes.label'))
+    expect(screen.getByRole('button', { name: 'patient.notes.new' })).toBeInTheDocument()
+  })
+
+  it('should not display add new note button without permission to report', async () => {
+    setup([Permissions.ViewIncident], '1234')
+
+    fireEvent.click(await screen.findByText('patient.notes.label'))
+    expect(screen.queryByRole('button', { name: 'patient.notes.new' })).not.toBeInTheDocument()
+  })
+
+  it('should not display modal before new note button clicked', async () => {
+    setup([Permissions.ViewIncident, Permissions.ReportIncident], '1234')
+
+    fireEvent.click(await screen.findByText('patient.notes.label'))
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
+  })
+
+  it('should display modal after new note button is clicked', async () => {
+    setup([Permissions.ViewIncident, Permissions.ReportIncident], '1234')
+
+    fireEvent.click(await screen.findByText('patient.notes.label'))
+    fireEvent.click(screen.getByRole('button', { name: 'patient.notes.new' }))
+    expect(screen.queryByRole('dialog')).toBeInTheDocument()
+  })
+
+  it('should display modal when edit note is clicked', async () => {
+    setup([Permissions.ViewIncident, Permissions.ReportIncident], '1234', [expectedNote])
+
+    fireEvent.click(await screen.findByRole('button', { name: 'actions.edit' }))
+    expect(await screen.findByRole('dialog')).toBeInTheDocument()
+  })
 
-it('should not  ViewIncidentDetails no there is no ID', async () => {
-  setup([Permissions.ReportIncident, Permissions.ResolveIncident], undefined)
+  it('should not render ViewIncidentDetails when there is no ID', async () => {
+    setup([Permissions.ReportIncident, Permissions.ResolveIncident], undefined)
 
-  expect(
-    screen.queryByRole('heading', {
-      name: /incidents\.reports\.dateofincident/i,
-    }),
-  ).not.toBeInTheDocument()
+    expect(
+      screen.queryByRole('heading', {
+        name: /incidents\.reports\.dateofincident/i,
+      }),
+    ).not.toBeInTheDocument()
+  })
 })