@bathiran212/esm-patient-notes-app 2.0.0

package/src/sticky-notes/sticky-note-header-button.test.tsx

@@ -0,0 +1,182 @@
+import React from 'react';
+import { vi, describe, it, expect, test, beforeEach, type Mock } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { showModal, useConfig, useOnClickOutside } from '@openmrs/esm-framework';
+import { mockStickyNote } from '__mocks__';
+import { mockPatient } from 'tools';
+import { type ConfigObject } from '../config-schema';
+import { useStickyNote } from './sticky-note.resource';
+import StickyNoteHeaderButton from './sticky-note-header-button.component';
+
+vi.mock('./sticky-note.resource', () => ({
+  useStickyNote: vi.fn(),
+}));
+
+vi.mock('./sticky-note-panel.component', () => ({ default: () => <div data-testid="sticky-note-panel" /> }));
+
+const mockUseStickyNote = useStickyNote as Mock;
+const mockShowModal = showModal as Mock;
+const mockUseOnClickOutside = useOnClickOutside as Mock;
+const mockUseConfig = vi.mocked(useConfig<ConfigObject>);
+
+// The framework's jest mock of useOnClickOutside is a no-op. Swap in a minimal real
+// implementation so the "closes on outside click" test can exercise the wiring.
+const useRealOnClickOutside = <T extends HTMLElement>(handler: (e: MouseEvent) => void, active: boolean) => {
+  const ref = React.useRef<T>(null);
+  React.useEffect(() => {
+    if (!active) return;
+    const listener = (e: MouseEvent) => {
+      if (ref.current && e.target instanceof Node && ref.current.contains(e.target)) return;
+      handler(e);
+    };
+    window.addEventListener('mousedown', listener);
+    return () => window.removeEventListener('mousedown', listener);
+  }, [handler, active]);
+  return ref;
+};
+
+describe('StickyNoteHeaderButton', () => {
+  const patientUuid = mockPatient.id;
+
+  beforeEach(() => {
+    mockUseConfig.mockReturnValue({ stickyNoteConceptUuid: 'concept-uuid' } as ConfigObject);
+  });
+
+  it('does not render when stickyNoteConceptUuid is disabled via empty string', () => {
+    mockUseConfig.mockReturnValue({ stickyNoteConceptUuid: '' } as ConfigObject);
+    mockUseStickyNote.mockReturnValue({ note: mockStickyNote, isLoading: false, error: undefined, mutate: vi.fn() });
+
+    const { container } = render(<StickyNoteHeaderButton patientUuid={patientUuid} />);
+
+    expect(container).toBeEmptyDOMElement();
+    expect(screen.queryByRole('button', { name: /sticky note/i })).not.toBeInTheDocument();
+  });
+
+  it('renders a button labelled "Sticky note"', () => {
+    mockUseStickyNote.mockReturnValue({ note: mockStickyNote, isLoading: false, error: undefined, mutate: vi.fn() });
+
+    render(<StickyNoteHeaderButton patientUuid={patientUuid} />);
+
+    expect(screen.getByRole('button', { name: /sticky note/i })).toBeInTheDocument();
+  });
+
+  it('shows a "1" badge when a note exists', () => {
+    mockUseStickyNote.mockReturnValue({ note: mockStickyNote, isLoading: false, error: undefined, mutate: vi.fn() });
+
+    render(<StickyNoteHeaderButton patientUuid={patientUuid} />);
+
+    expect(screen.getByText('1')).toBeInTheDocument();
+  });
+
+  it('does not show a badge when no note exists', () => {
+    mockUseStickyNote.mockReturnValue({ note: undefined, isLoading: false, error: undefined, mutate: vi.fn() });
+
+    render(<StickyNoteHeaderButton patientUuid={patientUuid} />);
+
+    expect(screen.queryByText('1')).not.toBeInTheDocument();
+  });
+
+  it('toggles the panel on click when a note exists', async () => {
+    const user = userEvent.setup();
+    mockUseStickyNote.mockReturnValue({ note: mockStickyNote, isLoading: false, error: undefined, mutate: vi.fn() });
+
+    render(<StickyNoteHeaderButton patientUuid={patientUuid} />);
+    const button = screen.getByRole('button', { name: /sticky note/i });
+
+    expect(screen.queryByTestId('sticky-note-panel')).not.toBeInTheDocument();
+    await user.click(button);
+    expect(screen.getByTestId('sticky-note-panel')).toBeInTheDocument();
+    await user.click(button);
+    expect(screen.queryByTestId('sticky-note-panel')).not.toBeInTheDocument();
+  });
+
+  it('opens the create modal on click when no note exists', async () => {
+    const user = userEvent.setup();
+    const mutate = vi.fn();
+    mockUseStickyNote.mockReturnValue({ note: undefined, isLoading: false, error: undefined, mutate });
+
+    render(<StickyNoteHeaderButton patientUuid={patientUuid} />);
+    await user.click(screen.getByRole('button', { name: /sticky note/i }));
+
+    expect(mockShowModal).toHaveBeenCalledWith('sticky-note-modal', expect.objectContaining({ patientUuid, mutate }));
+    expect(screen.queryByTestId('sticky-note-panel')).not.toBeInTheDocument();
+  });
+
+  it('opens the panel (not the create modal) while loading', async () => {
+    const user = userEvent.setup();
+    mockUseStickyNote.mockReturnValue({ note: undefined, isLoading: true, error: undefined, mutate: vi.fn() });
+
+    render(<StickyNoteHeaderButton patientUuid={patientUuid} />);
+    await user.click(screen.getByRole('button', { name: /sticky note/i }));
+
+    expect(mockShowModal).not.toHaveBeenCalled();
+    expect(screen.getByTestId('sticky-note-panel')).toBeInTheDocument();
+  });
+
+  it('opens the panel (not the create modal) when the fetch failed', async () => {
+    const user = userEvent.setup();
+    mockUseStickyNote.mockReturnValue({
+      note: undefined,
+      isLoading: false,
+      error: new Error('Failed'),
+      mutate: vi.fn(),
+    });
+
+    render(<StickyNoteHeaderButton patientUuid={patientUuid} />);
+    await user.click(screen.getByRole('button', { name: /sticky note/i }));
+
+    expect(mockShowModal).not.toHaveBeenCalled();
+    expect(screen.getByTestId('sticky-note-panel')).toBeInTheDocument();
+  });
+
+  it('closes the panel on Escape', async () => {
+    const user = userEvent.setup();
+    mockUseStickyNote.mockReturnValue({ note: mockStickyNote, isLoading: false, error: undefined, mutate: vi.fn() });
+
+    render(<StickyNoteHeaderButton patientUuid={patientUuid} />);
+    await user.click(screen.getByRole('button', { name: /sticky note/i }));
+    expect(screen.getByTestId('sticky-note-panel')).toBeInTheDocument();
+
+    await user.keyboard('{Escape}');
+    expect(screen.queryByTestId('sticky-note-panel')).not.toBeInTheDocument();
+  });
+
+  it('closes the panel on outside click', async () => {
+    const user = userEvent.setup();
+    mockUseStickyNote.mockReturnValue({ note: mockStickyNote, isLoading: false, error: undefined, mutate: vi.fn() });
+    mockUseOnClickOutside.mockImplementation(useRealOnClickOutside);
+
+    render(
+      <div>
+        <StickyNoteHeaderButton patientUuid={patientUuid} />
+        <button type="button">Outside</button>
+      </div>,
+    );
+    await user.click(screen.getByRole('button', { name: /sticky note/i }));
+    expect(screen.getByTestId('sticky-note-panel')).toBeInTheDocument();
+
+    await user.click(screen.getByRole('button', { name: /outside/i }));
+    expect(screen.queryByTestId('sticky-note-panel')).not.toBeInTheDocument();
+  });
+
+  it('ignores outside clicks that land inside an open modal', async () => {
+    const user = userEvent.setup();
+    mockUseStickyNote.mockReturnValue({ note: mockStickyNote, isLoading: false, error: undefined, mutate: vi.fn() });
+    mockUseOnClickOutside.mockImplementation(useRealOnClickOutside);
+
+    render(
+      <div>
+        <StickyNoteHeaderButton patientUuid={patientUuid} />
+        <div role="dialog">
+          <button type="button">In modal</button>
+        </div>
+      </div>,
+    );
+    await user.click(screen.getByRole('button', { name: /sticky note/i }));
+    expect(screen.getByTestId('sticky-note-panel')).toBeInTheDocument();
+
+    await user.click(screen.getByRole('button', { name: /in modal/i }));
+    expect(screen.getByTestId('sticky-note-panel')).toBeInTheDocument();
+  });
+});

package/src/sticky-notes/sticky-note-panel.component.tsx

@@ -0,0 +1,88 @@
+import React, { useCallback, useMemo } from 'react';
+import { Button, SkeletonText } from '@carbon/react';
+import { useTranslation } from 'react-i18next';
+import { formatDate, showModal } from '@openmrs/esm-framework';
+import { type StickyNoteObs } from './sticky-note.resource';
+import { decodeHtmlEntities } from './utils';
+import DeleteStickyNote from './delete-sticky-note-button.component';
+import EditStickyNote from './edit-sticky-note-button.component';
+import styles from './sticky-note-panel.scss';
+
+interface StickyNotePanelProps {
+  isLoading: boolean;
+  error: Error | undefined;
+  mutate: () => void;
+  note: StickyNoteObs | undefined;
+  onClose: () => void;
+  patientUuid: string;
+}
+
+const StickyNotePanel: React.FC<StickyNotePanelProps> = ({ error, isLoading, mutate, note, onClose, patientUuid }) => {
+  const { t } = useTranslation();
+  const decodedValue = useMemo(() => (note ? decodeHtmlEntities(note.value) : ''), [note]);
+
+  const handleEdit = useCallback(() => {
+    if (!note) {
+      return;
+    }
+
+    const dispose = showModal('sticky-note-modal', {
+      close: () => dispose(),
+      existingNote: note,
+      mutate,
+      patientUuid,
+    });
+  }, [mutate, note, patientUuid]);
+
+  if (isLoading) {
+    return (
+      <div className={styles.stickyNoteContainer}>
+        <div className={styles.noteContent}>
+          <SkeletonText paragraph lineCount={3} />
+        </div>
+        <div className={styles.noteFooter}>
+          <SkeletonText width="40%" />
+        </div>
+      </div>
+    );
+  }
+
+  if (error) {
+    return (
+      <div className={styles.stickyNoteContainer}>
+        <div className={styles.errorState}>
+          <p className={styles.errorTitle}>{t('errorLoadingStickyNote', "Couldn't load sticky note.")}</p>
+          <Button kind="ghost" size="sm" onClick={() => mutate()}>
+            {t('retry', 'Retry')}
+          </Button>
+        </div>
+      </div>
+    );
+  }
+
+  if (!note) {
+    return null;
+  }
+
+  const creatorDisplay = note.auditInfo?.creator?.display;
+
+  return (
+    <div className={styles.stickyNoteContainer}>
+      <div className={styles.noteContent}>
+        <p>{decodedValue}</p>
+      </div>
+      <div className={styles.noteFooter}>
+        <div className={styles.noteMetadata}>
+          {formatDate(new Date(note.obsDatetime), { mode: 'wide' })}
+          {creatorDisplay ? ` · ${creatorDisplay}` : ''}
+        </div>
+        <div className={styles.noteActions}>
+          <EditStickyNote onEdit={handleEdit} />
+          <DeleteStickyNote noteUuid={note.uuid} mutate={mutate} onClose={onClose} />
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default StickyNotePanel;

package/src/sticky-notes/sticky-note-panel.scss

@@ -0,0 +1,54 @@
+@use '@carbon/layout';
+@use '@carbon/type';
+@use '@openmrs/esm-styleguide/src/vars' as *;
+
+.stickyNoteContainer {
+  position: absolute;
+  top: 34px;
+  right: 0;
+  z-index: 99;
+  width: 24rem;
+  box-shadow:
+    0 2px 10px 1px rgba(0, 0, 0, 0.12),
+    0 2px 6px 1px rgba(171, 198, 213, 0.12);
+  background-color: $ui-background;
+}
+
+.noteContent {
+  padding: layout.$spacing-05;
+  min-height: 8rem;
+  @include type.type-style('body-long-01');
+  white-space: pre-wrap;
+}
+
+.noteFooter {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: layout.$spacing-03 layout.$spacing-05;
+  border-top: 1px solid rgba(0, 0, 0, 0.1);
+  background-color: rgba(255, 255, 255, 0.2);
+}
+
+.noteMetadata {
+  @include type.type-style('caption-01');
+  color: var(--cds-text-02);
+}
+
+.noteActions {
+  display: flex;
+  gap: layout.$spacing-02;
+}
+
+.errorState {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  text-align: center;
+  padding: layout.$spacing-06 layout.$spacing-05;
+  gap: layout.$spacing-03;
+}
+
+.errorTitle {
+  @include type.type-style('body-short-01');
+}

package/src/sticky-notes/sticky-note-panel.test.tsx

@@ -0,0 +1,66 @@
+import React from 'react';
+import { vi, describe, it, expect, type Mock } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { showModal } from '@openmrs/esm-framework';
+import { mockStickyNote } from '__mocks__';
+import { mockPatient } from 'tools';
+import StickyNotePanel from './sticky-note-panel.component';
+
+const mockShowModal = showModal as Mock;
+
+describe('StickyNotePanel', () => {
+  const patientUuid = mockPatient.id;
+  const onClose = vi.fn();
+  const mutate = vi.fn();
+
+  const defaultProps = {
+    error: undefined,
+    isLoading: false,
+    mutate,
+    onClose,
+    patientUuid,
+  };
+
+  it('shows a skeleton while loading', () => {
+    render(<StickyNotePanel {...defaultProps} isLoading={true} note={undefined} />);
+
+    expect(screen.queryByText(/simple notes/i)).not.toBeInTheDocument();
+  });
+
+  it('shows an inline error with a retry button when the fetch fails', async () => {
+    const user = userEvent.setup();
+    render(<StickyNotePanel {...defaultProps} error={new Error('Failed')} note={undefined} />);
+
+    expect(screen.getByText(/couldn't load sticky note/i)).toBeInTheDocument();
+    const retry = screen.getByRole('button', { name: /retry/i });
+    await user.click(retry);
+    expect(mutate).toHaveBeenCalledTimes(1);
+  });
+
+  it('renders nothing when no note exists and not loading', () => {
+    const { container } = render(<StickyNotePanel {...defaultProps} note={undefined} />);
+
+    expect(container).toBeEmptyDOMElement();
+  });
+
+  it('renders note text with creator and date metadata', () => {
+    render(<StickyNotePanel {...defaultProps} note={mockStickyNote} />);
+
+    expect(screen.getByText(/simple notes/i)).toBeInTheDocument();
+    expect(screen.getByText(/Dr\. Ray Romano/)).toBeInTheDocument();
+  });
+
+  it('opens the edit modal when the edit icon is clicked', async () => {
+    const user = userEvent.setup();
+
+    render(<StickyNotePanel {...defaultProps} note={mockStickyNote} />);
+
+    await user.click(screen.getByRole('button', { name: /edit sticky note/i }));
+
+    expect(mockShowModal).toHaveBeenCalledWith(
+      'sticky-note-modal',
+      expect.objectContaining({ existingNote: mockStickyNote, mutate, patientUuid }),
+    );
+  });
+});

package/src/sticky-notes/sticky-note.modal.scss

@@ -0,0 +1,3 @@
+.textArea {
+  width: 100%;
+}

package/src/sticky-notes/sticky-note.modal.test.tsx

@@ -0,0 +1,115 @@
+import React from 'react';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { showSnackbar, useConfig } from '@openmrs/esm-framework';
+import { mockStickyNote } from '__mocks__';
+import { mockPatient } from 'tools';
+import { type ConfigObject } from '../config-schema';
+import { createStickyNote, updateStickyNote } from './sticky-note.resource';
+import StickyNoteModal from './sticky-note.modal';
+
+vi.mock('./sticky-note.resource', () => ({
+  createStickyNote: vi.fn(),
+  updateStickyNote: vi.fn(),
+}));
+
+vi.mock('./utils', () => ({
+  decodeHtmlEntities: (text: string) => text,
+}));
+
+const mockUseConfig = vi.mocked(useConfig<ConfigObject>);
+const mockShowSnackbar = vi.mocked(showSnackbar);
+const mockCreateStickyNote = vi.mocked(createStickyNote);
+const mockUpdateStickyNote = vi.mocked(updateStickyNote);
+
+describe('StickyNoteModal', () => {
+  const patientUuid = mockPatient.id;
+  const defaultProps = {
+    close: vi.fn(),
+    mutate: vi.fn(),
+    patientUuid,
+  };
+
+  beforeEach(() => {
+    mockUseConfig.mockReturnValue({
+      stickyNoteConceptUuid: 'concept-uuid',
+    } as ConfigObject);
+  });
+
+  it('renders an empty create form by default', () => {
+    render(<StickyNoteModal {...defaultProps} />);
+
+    expect(screen.getByRole('textbox')).toHaveValue('');
+    expect(screen.getByRole('button', { name: /save/i })).toBeDisabled();
+  });
+
+  it('keeps Save disabled when the input is only whitespace', async () => {
+    const user = userEvent.setup();
+    render(<StickyNoteModal {...defaultProps} />);
+
+    await user.type(screen.getByRole('textbox'), '   ');
+
+    expect(screen.getByRole('button', { name: /save/i })).toBeDisabled();
+  });
+
+  it('keeps Save disabled in edit mode when the value is cleared to whitespace', async () => {
+    const user = userEvent.setup();
+    render(<StickyNoteModal {...defaultProps} existingNote={mockStickyNote} />);
+
+    const textarea = screen.getByRole('textbox');
+    await user.clear(textarea);
+    await user.type(textarea, '   ');
+
+    expect(screen.getByRole('button', { name: /save/i })).toBeDisabled();
+  });
+
+  it('creates a new sticky note and shows a success snackbar', async () => {
+    const user = userEvent.setup();
+    mockCreateStickyNote.mockResolvedValue({} as any);
+
+    render(<StickyNoteModal {...defaultProps} />);
+
+    await user.type(screen.getByRole('textbox'), 'New note');
+    await user.click(screen.getByRole('button', { name: /save/i }));
+
+    expect(mockCreateStickyNote).toHaveBeenCalledWith(patientUuid, 'New note', 'concept-uuid');
+    expect(mockShowSnackbar).toHaveBeenCalledWith(expect.objectContaining({ kind: 'success' }));
+    expect(defaultProps.close).toHaveBeenCalled();
+  });
+
+  it('prefills the textarea in edit mode and updates on save', async () => {
+    const user = userEvent.setup();
+    mockUpdateStickyNote.mockResolvedValue({} as any);
+
+    render(<StickyNoteModal {...defaultProps} existingNote={mockStickyNote} />);
+
+    const textarea = screen.getByRole('textbox');
+    expect(textarea).toHaveValue(mockStickyNote.value);
+
+    await user.clear(textarea);
+    await user.type(textarea, 'Updated note');
+    await user.click(screen.getByRole('button', { name: /save/i }));
+
+    expect(mockUpdateStickyNote).toHaveBeenCalledWith(mockStickyNote.uuid, 'Updated note');
+    expect(mockShowSnackbar).toHaveBeenCalledWith(expect.objectContaining({ kind: 'success' }));
+  });
+
+  it('disables Save when the edit leaves the value unchanged', () => {
+    render(<StickyNoteModal {...defaultProps} existingNote={mockStickyNote} />);
+
+    expect(screen.getByRole('button', { name: /save/i })).toBeDisabled();
+  });
+
+  it('shows an error snackbar when the save fails', async () => {
+    const user = userEvent.setup();
+    mockCreateStickyNote.mockRejectedValue(new Error('Server error'));
+
+    render(<StickyNoteModal {...defaultProps} />);
+
+    await user.type(screen.getByRole('textbox'), 'New note');
+    await user.click(screen.getByRole('button', { name: /save/i }));
+
+    expect(mockShowSnackbar).toHaveBeenCalledWith(expect.objectContaining({ kind: 'error' }));
+  });
+});

package/src/sticky-notes/sticky-note.modal.tsx

@@ -0,0 +1,93 @@
+import React, { useCallback, useMemo, useState } from 'react';
+import { Button, InlineLoading, ModalBody, ModalFooter, ModalHeader, TextArea } from '@carbon/react';
+import { useTranslation } from 'react-i18next';
+import { getCoreTranslation, showSnackbar, useConfig } from '@openmrs/esm-framework';
+import { type ConfigObject } from '../config-schema';
+import { createStickyNote, type StickyNoteObs, updateStickyNote } from './sticky-note.resource';
+import { decodeHtmlEntities } from './utils';
+import styles from './sticky-note.modal.scss';
+
+const MAX_NOTE_LENGTH = 300;
+
+interface StickyNoteModalProps {
+  close: () => void;
+  existingNote?: StickyNoteObs;
+  mutate: () => void;
+  patientUuid: string;
+}
+
+const StickyNoteModal: React.FC<StickyNoteModalProps> = ({ close, existingNote, mutate, patientUuid }) => {
+  const { t } = useTranslation();
+  const { stickyNoteConceptUuid } = useConfig<ConfigObject>();
+  const decodedExistingValue = useMemo(
+    () => (existingNote?.value ? decodeHtmlEntities(existingNote.value) : ''),
+    [existingNote],
+  );
+  const [value, setValue] = useState(decodedExistingValue);
+  const [isSaving, setIsSaving] = useState(false);
+
+  const isEditMode = Boolean(existingNote);
+  const trimmed = value.trim();
+  const isUnchanged = isEditMode && trimmed === decodedExistingValue.trim();
+
+  const handleSave = useCallback(async () => {
+    if (!trimmed || isUnchanged) {
+      return;
+    }
+    setIsSaving(true);
+    try {
+      if (isEditMode) {
+        await updateStickyNote(existingNote.uuid, trimmed);
+      } else {
+        await createStickyNote(patientUuid, trimmed, stickyNoteConceptUuid);
+      }
+      showSnackbar({
+        kind: 'success',
+        title: isEditMode
+          ? t('stickyNoteUpdated', 'Sticky note updated')
+          : t('stickyNoteCreated', 'Sticky note created'),
+      });
+      mutate();
+      close();
+    } catch (error) {
+      showSnackbar({
+        kind: 'error',
+        title: t('errorSavingStickyNote', 'Error saving sticky note'),
+        subtitle: error instanceof Error ? error.message : undefined,
+      });
+    } finally {
+      setIsSaving(false);
+    }
+  }, [close, existingNote, isEditMode, isUnchanged, mutate, patientUuid, stickyNoteConceptUuid, t, trimmed]);
+
+  return (
+    <>
+      <ModalHeader closeModal={close} title={t('stickyNote', 'Sticky note')} />
+      <ModalBody>
+        <TextArea
+          id="sticky-note-text"
+          labelText={t('stickyNote', 'Sticky note')}
+          hideLabel
+          value={value}
+          onChange={(e) => setValue(e.target.value)}
+          rows={4}
+          maxLength={MAX_NOTE_LENGTH}
+          enableCounter
+          counterMode="character"
+          className={styles.textArea}
+          placeholder={t('enterNotePlaceholder', 'Enter your sticky note here...')}
+        />
+      </ModalBody>
+      <ModalFooter>
+        <Button kind="secondary" onClick={close} disabled={isSaving}>
+          {getCoreTranslation('cancel')}
+        </Button>
+        <Button kind="primary" onClick={handleSave} disabled={!trimmed || isUnchanged || isSaving}>
+          {isSaving ? <InlineLoading description={t('saving', 'Saving') + '...'} /> : getCoreTranslation('save')}
+        </Button>
+      </ModalFooter>
+    </>
+  );
+};
+
+export default StickyNoteModal;

package/src/sticky-notes/sticky-note.resource.test.ts

@@ -0,0 +1,24 @@
+import { isStandaloneStickyNote, type StickyNoteObs } from './sticky-note.resource';
+import { describe, it, expect } from 'vitest';
+
+const baseObs: StickyNoteObs = {
+  uuid: 'uuid',
+  value: 'note text',
+  obsDatetime: '2026-01-20T11:38:02+00:00',
+  encounter: null,
+  formNamespaceAndPath: null,
+};
+
+describe('isStandaloneStickyNote', () => {
+  it('accepts an obs with no encounter and no form binding', () => {
+    expect(isStandaloneStickyNote(baseObs)).toBe(true);
+  });
+
+  it('rejects an obs attached to an encounter', () => {
+    expect(isStandaloneStickyNote({ ...baseObs, encounter: { uuid: 'encounter-uuid' } })).toBe(false);
+  });
+
+  it('rejects an obs created via a form engine', () => {
+    expect(isStandaloneStickyNote({ ...baseObs, formNamespaceAndPath: 'form-ns^form-path' })).toBe(false);
+  });
+});