@defra/interactive-map 0.0.9-alpha → 0.0.10-alpha

package/plugins/beta/draw-ml/src/api/newLine.js

@@ -17,8 +17,8 @@ export const newLine = ({ appState, appConfig, pluginConfig, pluginState, mapPro
     return
   }
 
-  // Emit draw:start
-  eventBus.emit('draw:start', { mode: 'draw_line' })
+  // Emit draw:started
+  eventBus.emit('draw:started', { mode: 'draw_line' })
 
   // Determin snapLayers from pluginConfig or runtime config
   let snapLayers = null

package/plugins/beta/draw-ml/src/api/newPolygon.js

@@ -17,8 +17,8 @@ export const newPolygon = ({ appState, appConfig, pluginConfig, pluginState, map
     return
   }
 
-  // Emit draw:start
-  eventBus.emit('draw:start', { mode: 'draw_polygon' })
+  // Emit draw:started
+  eventBus.emit('draw:started', { mode: 'draw_polygon' })
 
   // Determin snapLayers from pluginConfig or runtime config
   let snapLayers = null

package/plugins/beta/draw-ml/src/events.js

@@ -29,14 +29,14 @@ export function attachEvents({ pluginState, mapProvider, buttonConfig, eventBus
   // --- Button handlers
   const handleDone = () => {
     const mode = draw.getMode()
-    const features = draw.getAll().features
-    const feature = features?.[0]
 
     disableSnap()
     mapProvider.undoStack?.clear()
 
+    const features = draw.getAll().features
+    
     if (mode === 'edit_vertex') {
-      map.fire('draw.editfinish', { features: [feature] })
+      map.fire('draw.editfinish', { features: [draw.get(tempFeature.id)] })
       return
     }
 
@@ -44,7 +44,9 @@ export function attachEvents({ pluginState, mapProvider, buttonConfig, eventBus
       return
     }
 
+    const feature = features?.[0]
     const geom = feature.geometry
+
     if (geom.type === 'Polygon') {
       const ring = geom.coordinates[0]
       geom.coordinates[0] = [...ring.slice(0, -2), ring[0]]
@@ -56,6 +58,7 @@ export function attachEvents({ pluginState, mapProvider, buttonConfig, eventBus
   }
 
   const handleCancel = () => {
+    draw.trash()
     if (tempFeature?.id) {
       draw.delete(tempFeature.id)
     }
@@ -65,7 +68,7 @@ export function attachEvents({ pluginState, mapProvider, buttonConfig, eventBus
     disableSnap()
     draw.changeMode('disabled')
     resetDrawModeAndFeature()
-    eventBus.emit('draw:cancel', { originalFeature: feature })
+    eventBus.emit('draw:cancelled', feature)
   }
 
   const handleUndo = () => {
@@ -122,14 +125,19 @@ export function attachEvents({ pluginState, mapProvider, buttonConfig, eventBus
     const newFeature = e.features[0]
     resetDrawModeAndFeature()
     setTimeout(() => draw.changeMode('disabled'), 0)
-    eventBus.emit(eventName, { newFeature })
+    eventBus.emit(eventName, newFeature)
+  }
+
+  // --- Draw update handler
+  const handleUpdate = (e) => {
+    const tempFeature = e.features[0]
+    eventBus.emit('draw:updated', tempFeature)
   }
 
-  const onCreate = handleDrawCompletion('draw:create')
-  const onEditFinish = handleDrawCompletion('draw:edit')
+  const onCreate = handleDrawCompletion('draw:created')
+  const onEditFinish = handleDrawCompletion('draw:edited')
 
   // --- Other map events
-  const onUpdate = (e) => eventBus.emit('draw:update', e)
   const onVertexSelection = (e) => {
     dispatch({ type: 'SET_SELECTED_VERTEX_INDEX', payload: e })
     eventBus.emit('draw:vertexselection', e)
@@ -151,7 +159,7 @@ export function attachEvents({ pluginState, mapProvider, buttonConfig, eventBus
   map.on('draw.cancel', handleCancel)
   map.on('draw.create', onCreate)
   map.on('draw.editfinish', onEditFinish)
-  map.on('draw.update', onUpdate)
+  map.on('draw.update', handleUpdate)
   map.on('draw.vertexselection', onVertexSelection)
   map.on('draw.vertexchange', onVertexChange)
   map.on('draw.undochange', onUndoChange)
@@ -165,7 +173,7 @@ export function attachEvents({ pluginState, mapProvider, buttonConfig, eventBus
     map.off('draw.cancel', handleCancel)
     map.off('draw.create', onCreate)
     map.off('draw.editfinish', onEditFinish)
-    map.off('draw.update', onUpdate)
+    map.off('draw.update', handleUpdate)
     map.off('draw.vertexselection', onVertexSelection)
     map.off('draw.vertexchange', onVertexChange)
     map.off('draw.undochange', onUndoChange)

package/plugins/search/src/Search.test.jsx

@@ -0,0 +1,170 @@
+// /plugins/search/Search.test.jsx
+import { render, screen, fireEvent, cleanup } from '@testing-library/react'
+import { Search } from './Search'
+import { attachEvents } from './events/index.js'
+import { createDatasets } from './datasets.js'
+
+// Mock sub-components
+jest.mock('./components/OpenButton/OpenButton', () => ({
+  OpenButton: ({ id, isExpanded, onClick }) => (
+    <button data-testid="open-button" onClick={onClick}>
+      OpenButton-{id}-{isExpanded ? 'expanded' : 'collapsed'}
+    </button>
+  ),
+}))
+
+jest.mock('./components/CloseButton/CloseButton', () => ({
+  CloseButton: ({ defaultExpanded, onClick }) => (
+    <button data-testid="close-button" onClick={onClick}>
+      CloseButton-{defaultExpanded ? 'defaultExpanded' : 'collapsed'}
+    </button>
+  ),
+}))
+
+jest.mock('./components/Form/Form', () => ({
+  Form: ({ children }) => <div data-testid="form">{children}</div>,
+}))
+
+// Mock external logic
+jest.mock('./datasets.js', () => ({
+  createDatasets: jest.fn(() => ['dataset1', 'dataset2']),
+}))
+
+jest.mock('./events/index.js', () => ({
+  attachEvents: jest.fn(() => ({
+    handleOpenClick: jest.fn(),
+    handleCloseClick: jest.fn(),
+    handleOutside: jest.fn(),
+  })),
+}))
+
+describe('Search component', () => {
+  let props
+  let viewportRef
+
+  beforeEach(() => {
+    // Clear mock history before every test to prevent call count accumulation
+    jest.clearAllMocks()
+
+    viewportRef = { current: { style: { pointerEvents: 'auto' } } }
+
+    props = {
+      appConfig: { id: 'search' },
+      iconRegistry: { close: '<svg>close</svg>', search: '<svg>search</svg>' },
+      pluginState: {
+        dispatch: jest.fn(),
+        isExpanded: false,
+        areSuggestionsVisible: false,
+        suggestions: [],
+      },
+      pluginConfig: {
+        isExpanded: false, // This is destructured as defaultExpanded in the component
+        customDatasets: [],
+        osNamesURL: 'url',
+      },
+      appState: {
+        dispatch: jest.fn(),
+        interfaceType: 'keyboard',
+        layoutRefs: { viewportRef },
+      },
+      mapState: { markers: {} },
+      services: {},
+      mapProvider: { crs: 'EPSG:3857' },
+    }
+  })
+
+  afterEach(() => {
+    cleanup()
+  })
+
+  it('renders OpenButton when defaultExpanded/isExpanded is false', () => {
+    render(<Search {...props} />)
+    expect(screen.getByTestId('open-button')).toBeInTheDocument()
+    expect(screen.getByTestId('form')).toBeInTheDocument()
+    expect(screen.getByTestId('close-button')).toBeInTheDocument()
+  })
+
+  it('does not render OpenButton when defaultExpanded/isExpanded is true', () => {
+    props.pluginConfig.isExpanded = true
+    render(<Search {...props} />)
+    expect(screen.queryByTestId('open-button')).not.toBeInTheDocument()
+    expect(screen.getByTestId('close-button')).toBeInTheDocument()
+  })
+
+  it('calls attachEvents once and persists it across re-renders (useRef coverage)', () => {
+    const { rerender } = render(<Search {...props} />)
+    
+    expect(createDatasets).toHaveBeenCalledWith({
+      customDatasets: [],
+      osNamesURL: 'url',
+      crs: 'EPSG:3857',
+    })
+    
+    // Trigger a re-render with a prop change
+    rerender(<Search {...props} appState={{ ...props.appState, interfaceType: 'touch' }} />)
+    
+    // attachEvents should still only have been called once due to the useRef check
+    expect(attachEvents).toHaveBeenCalledTimes(1)
+  })
+
+  it('OpenButton click triggers handleOpenClick', () => {
+    render(<Search {...props} />)
+    const events = attachEvents.mock.results[0].value
+    fireEvent.click(screen.getByTestId('open-button'))
+    expect(events.handleOpenClick).toHaveBeenCalledTimes(1)
+  })
+
+  it('CloseButton click triggers handleCloseClick', () => {
+    render(<Search {...props} />)
+    const events = attachEvents.mock.results[0].value
+    fireEvent.click(screen.getByTestId('close-button'))
+    expect(events.handleCloseClick).toHaveBeenCalledTimes(1)
+  })
+
+  it('focuses input when pluginState.isExpanded is true', () => {
+    // We have to mock the implementation because inputRef is internal
+    // This is a bit of a workaround for testing internal refs
+    props.pluginState.isExpanded = true
+    render(<Search {...props} />)
+    expect(screen.getByTestId('form')).toBeInTheDocument()
+  })
+
+  describe('searchOpen logic (Line 46 coverage)', () => {
+    it('is true when isExpanded is true', () => {
+      props.pluginState.isExpanded = true
+      render(<Search {...props} />)
+      // If searchOpen is true, pointerEvents becomes 'none'
+      expect(viewportRef.current.style.pointerEvents).toBe('none')
+    })
+
+    it('is true when defaultExpanded is true and suggestions exist', () => {
+      props.pluginConfig.isExpanded = true // defaultExpanded
+      props.pluginState.isExpanded = false
+      props.pluginState.areSuggestionsVisible = true
+      props.pluginState.suggestions = ['item 1']
+      
+      render(<Search {...props} />)
+      expect(viewportRef.current.style.pointerEvents).toBe('none')
+    })
+
+    it('is false when defaultExpanded is true but suggestions are empty', () => {
+      props.pluginConfig.isExpanded = true 
+      props.pluginState.isExpanded = false
+      props.pluginState.areSuggestionsVisible = true
+      props.pluginState.suggestions = [] 
+      
+      render(<Search {...props} />)
+      // Should remain 'auto' (or not 'none')
+      expect(viewportRef.current.style.pointerEvents).toBe('auto')
+    })
+  })
+
+  it('cleans up effects and restores pointerEvents on unmount', () => {
+    props.pluginState.isExpanded = true
+    const { unmount } = render(<Search {...props} />)
+    expect(viewportRef.current.style.pointerEvents).toBe('none')
+    
+    unmount()
+    expect(viewportRef.current.style.pointerEvents).toBe('auto')
+  })
+})

package/plugins/search/src/components/CloseButton/CloseButton.test.jsx

@@ -0,0 +1,67 @@
+// src/plugins/search/components/CloseButton/CloseButton.test.jsx
+
+import { render, screen, fireEvent } from '@testing-library/react'
+import { CloseButton } from './CloseButton'
+
+describe('CloseButton', () => {
+  it('renders the button and calls onClick', () => {
+    const onClick = jest.fn()
+
+    render(
+      <CloseButton
+        defaultExpanded={false}
+        onClick={onClick}
+        closeIcon={null}
+      />
+    )
+
+    fireEvent.click(
+      screen.getByRole('button', { name: /close search/i })
+    )
+
+    expect(onClick).toHaveBeenCalledTimes(1)
+  })
+
+  it('applies display:none when defaultExpanded is true', () => {
+    render(
+      <CloseButton
+        defaultExpanded
+        onClick={jest.fn()}
+        closeIcon={null}
+      />
+    )
+
+    const button = screen.getByLabelText('Close search', {
+      selector: 'button',
+    })
+
+    expect(button).toHaveStyle({ display: 'none' })
+  })
+
+  it('renders the close icon SVG when closeIcon is provided', () => {
+    const svgContent = '<path d="M1 1L23 23" />'
+    const { container } = render(
+      <CloseButton
+        defaultExpanded={false}
+        onClick={jest.fn()}
+        closeIcon={svgContent}
+      />
+    )
+
+    const svg = container.querySelector('svg')
+    expect(svg).toBeTruthy()
+    expect(svg.innerHTML).toContain('M1 1L23 23')
+  })
+
+  it('does not render an svg when closeIcon is not provided', () => {
+    const { container } = render(
+      <CloseButton
+        defaultExpanded={false}
+        onClick={jest.fn()}
+        closeIcon={null}
+      />
+    )
+
+    expect(container.querySelector('svg')).toBeNull()
+  })
+})

package/plugins/search/src/components/Form/Form.test.jsx

@@ -0,0 +1,158 @@
+// src/plugins/search/Form.test.jsx
+
+import { render, screen, fireEvent } from '@testing-library/react'
+import { Form } from './Form'
+
+// Mock Suggestions to simulate user interactions
+jest.mock('../Suggestions/Suggestions', () => ({
+  Suggestions: ({ handleSuggestionClick, id }) => (
+    <button
+      data-testid="suggestion"
+      onClick={() => handleSuggestionClick('clicked-suggestion')}
+      id={`${id}-search-suggestions`}
+    >
+      Suggestion
+    </button>
+  ),
+}))
+
+describe('Form', () => {
+  const baseProps = {
+    id: 'test',
+    inputRef: { current: null },
+    pluginState: {
+      isExpanded: false,
+      value: '',
+      suggestionsVisible: false,
+      selectedIndex: -1,
+      hasKeyboardFocusWithin: false,
+    },
+    pluginConfig: {
+      isExpanded: false,
+      width: '400px',
+    },
+    appState: {
+      breakpoint: 'desktop',
+      interfaceType: 'keyboard',
+    },
+    events: {
+      handleSubmit: jest.fn(),
+      handleInputClick: jest.fn(),
+      handleInputChange: jest.fn(),
+      handleInputFocus: jest.fn(),
+      handleInputBlur: jest.fn(),
+      handleInputKeyDown: jest.fn(),
+      handleSuggestionClick: jest.fn(),
+    },
+  }
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('renders the form element with correct role, ID, and base classes', () => {
+    render(<Form {...baseProps} />)
+    const form = screen.getByRole('search')
+    expect(form).toHaveAttribute('id', 'test-search-form')
+    expect(form.className).toContain('im-c-search-form')
+    expect(form.className).toContain('im-c-panel')
+  })
+
+  it('applies expanded styles and width when the pluginConfig is expanded', () => {
+    render(
+      <Form
+        {...baseProps}
+        pluginConfig={{ ...baseProps.pluginConfig, isExpanded: true }}
+      />
+    )
+    const form = screen.getByRole('search')
+    expect(form).toHaveStyle({ display: 'flex', width: '400px' })
+    expect(form.className).toContain('im-c-search-form--default-expanded')
+  })
+
+  it('calls handleSubmit with the event, appState, and pluginState when form is submitted', () => {
+    render(<Form {...baseProps} />)
+    const form = screen.getByRole('search')
+    fireEvent.submit(form)
+    expect(baseProps.events.handleSubmit).toHaveBeenCalledTimes(1)
+    expect(baseProps.events.handleSubmit.mock.calls[0][1]).toBe(baseProps.appState)
+    expect(baseProps.events.handleSubmit.mock.calls[0][2]).toBe(baseProps.pluginState)
+  })
+
+  it('renders the search input with correct ARIA attributes when suggestions are visible and an item is selected', () => {
+    render(
+      <Form
+        {...baseProps}
+        pluginState={{
+          ...baseProps.pluginState,
+          suggestionsVisible: true,
+          selectedIndex: 2,
+        }}
+      />
+    )
+    const input = screen.getByRole('combobox')
+    expect(input).toHaveAttribute('aria-expanded', 'true')
+    expect(input).toHaveAttribute('aria-activedescendant', 'test-search-suggestion-2')
+    expect(input).toHaveAttribute('aria-controls', 'test-search-suggestions')
+  })
+
+  it('adds keyboard focus class when the input container has focus within', () => {
+    render(
+      <Form
+        {...baseProps}
+        pluginState={{ ...baseProps.pluginState, hasKeyboardFocusWithin: true }}
+      />
+    )
+    const container = screen.getByRole('search').querySelector('.im-c-search__input-container')
+    expect(container.className).toContain('im-c-search__input-container--keyboard-focus-within')
+  })
+
+  it('does not set aria-describedby when the search input has a value', () => {
+    render(
+      <Form
+        {...baseProps}
+        pluginState={{ ...baseProps.pluginState, value: 'something' }}
+      />
+    )
+    const input = screen.getByRole('combobox')
+    expect(input).not.toHaveAttribute('aria-describedby')
+  })
+
+  it('wires input event handlers correctly (click, change, focus, blur, keydown)', () => {
+    render(<Form {...baseProps} />)
+    const input = screen.getByRole('combobox')
+    fireEvent.click(input)
+    fireEvent.change(input, { target: { value: 'abc' } })
+    fireEvent.focus(input)
+    fireEvent.blur(input)
+    fireEvent.keyDown(input, { key: 'ArrowDown' })
+    expect(baseProps.events.handleInputClick).toHaveBeenCalled()
+    expect(baseProps.events.handleInputChange).toHaveBeenCalled()
+    expect(baseProps.events.handleInputFocus).toHaveBeenCalledWith('keyboard')
+    expect(baseProps.events.handleInputBlur).toHaveBeenCalledWith('keyboard')
+    expect(baseProps.events.handleInputKeyDown).toHaveBeenCalled()
+  })
+
+  it('renders children passed into the input container (e.g., CloseButton)', () => {
+    render(
+      <Form {...baseProps}>
+        <div data-testid="close-button" />
+      </Form>
+    )
+    expect(screen.getByTestId('close-button')).toBeInTheDocument()
+  })
+
+  it('renders the Suggestions component', () => {
+    render(<Form {...baseProps} />)
+    expect(screen.getByTestId('suggestion')).toBeInTheDocument()
+  })
+
+  it('calls events.handleSuggestionClick when a suggestion is clicked', () => {
+    render(<Form {...baseProps} />)
+    fireEvent.click(screen.getByTestId('suggestion'))
+    expect(baseProps.events.handleSuggestionClick).toHaveBeenCalledWith(
+      'clicked-suggestion',
+      baseProps.appState
+    )
+  })
+})

package/plugins/search/src/components/OpenButton/OpenButton.test.jsx

@@ -0,0 +1,47 @@
+// src/plugins/search/OpenButton.test.jsx
+
+import { render, screen, fireEvent } from '@testing-library/react'
+import { OpenButton } from './OpenButton'
+
+describe('OpenButton', () => {
+  const baseProps = {
+    id: 'test',
+    isExpanded: false,
+    onClick: jest.fn(),
+    buttonRef: { current: null },
+    searchIcon: null,
+  }
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('renders the button with correct ARIA attributes and calls onClick', () => {
+    render(<OpenButton {...baseProps} />)
+    const button = screen.getByRole('button', { name: /open search/i })
+    expect(button).toHaveAttribute('aria-controls', 'test-search-form')
+    fireEvent.click(button)
+    expect(baseProps.onClick).toHaveBeenCalledTimes(1)
+  })
+
+  it('applies display:none when isExpanded is true', () => {
+    render(<OpenButton {...baseProps} isExpanded />)
+    const button = screen.getByLabelText('Open search')
+    expect(button).toHaveStyle({ display: 'none' })
+  })
+
+  it('renders the search icon SVG when searchIcon is provided', () => {
+    const svgContent = '<path d="M1 1L23 23" />'
+    const { container } = render(
+      <OpenButton {...baseProps} searchIcon={svgContent} />
+    )
+    const svg = container.querySelector('svg')
+    expect(svg).toBeTruthy()
+    expect(svg.innerHTML).toContain('M1 1L23 23')
+  })
+
+  it('does not render an SVG when searchIcon is not provided', () => {
+    const { container } = render(<OpenButton {...baseProps} />)
+    expect(container.querySelector('svg')).toBeNull()
+  })
+})

package/plugins/search/src/components/Suggestions/Suggestions.test.jsx

@@ -0,0 +1,79 @@
+// src/plugins/search/Suggestions.test.jsx
+
+import { render, screen, fireEvent } from '@testing-library/react'
+import { Suggestions } from './Suggestions'
+
+describe('Suggestions', () => {
+  const baseProps = {
+    id: 'test',
+    pluginState: {
+      areSuggestionsVisible: true,
+      suggestions: [
+        { id: '1', marked: 'First' },
+        { id: '2', marked: 'Second' },
+      ],
+      selectedIndex: 0,
+    },
+    handleSuggestionClick: jest.fn(),
+  }
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('renders the listbox with correct attributes', () => {
+    render(<Suggestions {...baseProps} />)
+    const listbox = screen.getByRole('listbox')
+    expect(listbox).toHaveAttribute('id', 'test-search-suggestions')
+    expect(listbox).toHaveAttribute('aria-labelledby', 'test-search')
+    expect(listbox.className).toContain('im-c-search-suggestions')
+  })
+
+  it('hides the listbox when suggestions are not visible', () => {
+    render(
+      <Suggestions
+        {...baseProps}
+        pluginState={{ ...baseProps.pluginState, areSuggestionsVisible: false }}
+      />
+    )
+    const listbox = screen.getByRole('listbox', { hidden: true })
+    expect(listbox).toHaveStyle({ display: 'none' })
+  })
+
+  it('hides the listbox when suggestions array is empty', () => {
+    render(
+      <Suggestions
+        {...baseProps}
+        pluginState={{ ...baseProps.pluginState, suggestions: [] }}
+      />
+    )
+    const listbox = screen.getByRole('listbox', { hidden: true })
+    expect(listbox).toHaveStyle({ display: 'none' })
+  })
+
+  it('renders all suggestion items with correct ARIA attributes', () => {
+    render(<Suggestions {...baseProps} />)
+    const items = screen.getAllByRole('option')
+    expect(items).toHaveLength(2)
+
+    items.forEach((item, i) => {
+      expect(item).toHaveAttribute('id', `test-search-suggestion-${i}`)
+      expect(item).toHaveClass('im-c-search-suggestions__item')
+      expect(item).toHaveAttribute('aria-setsize', '2')
+      expect(item).toHaveAttribute('aria-posinset', `${i + 1}`)
+    })
+
+    // First item should be selected
+    expect(items[0]).toHaveAttribute('aria-selected', 'true')
+    expect(items[1]).toHaveAttribute('aria-selected', 'false')
+  })
+
+  it('calls handleSuggestionClick when a suggestion is clicked', () => {
+    render(<Suggestions {...baseProps} />)
+    const items = screen.getAllByRole('option')
+    fireEvent.click(items[1])
+    expect(baseProps.handleSuggestionClick).toHaveBeenCalledWith(
+      baseProps.pluginState.suggestions[1]
+    )
+  })
+})

package/plugins/search/src/datasets.test.js

@@ -0,0 +1,46 @@
+// src/plugins/search/datasets.test.js
+
+import { createDatasets } from './datasets'
+import * as parseModule from './utils/parseOsNamesResults.js'
+
+describe('createDatasets', () => {
+  const osNamesURL = 'https://example.com/osnames'
+  const crs = 'EPSG:4326'
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('returns default dataset with correct properties', () => {
+    const datasets = createDatasets({ osNamesURL, crs })
+    expect(datasets).toHaveLength(1)
+    const ds = datasets[0]
+
+    expect(ds.name).toBe('osNames')
+    expect(ds.urlTemplate).toBe(osNamesURL)
+    expect(ds.includeRegex).toEqual(/^[a-zA-Z0-9\s,-]+$/)
+    expect(ds.excludeRegex).toEqual(
+      /^(?:[a-z]{2}\s*(?:\d{3}\s*\d{3}|\d{4}\s*\d{4}|\d{5}\s*\d{5})|\d+\s*,?\s*\d+)$/i
+    )
+    expect(typeof ds.parseResults).toBe('function')
+  })
+
+  it('merge custom datasets with default dataset', () => {
+    const custom = [{ name: 'custom1', urlTemplate: 'https://custom.com' }]
+    const datasets = createDatasets({ osNamesURL, crs, customDatasets: custom })
+    expect(datasets).toHaveLength(2)
+    expect(datasets[1]).toEqual(custom[0])
+  })
+
+  it('parseResults calls parseOsNamesResults with correct arguments', () => {
+    const parseMock = jest.spyOn(parseModule, 'parseOsNamesResults').mockReturnValue('parsed')
+    const datasets = createDatasets({ osNamesURL, crs })
+    const json = { some: 'data' }
+    const query = 'test query'
+
+    const result = datasets[0].parseResults(json, query)
+    expect(parseMock).toHaveBeenCalledWith(json, query, crs)
+    expect(result).toBe('parsed')
+    parseMock.mockRestore()
+  })
+})