From c4c50aeb279fe12fca11520ac5e7653bb5571853 Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Mon, 20 May 2024 15:27:54 +0100
Subject: [PATCH 01/29] find place searching on alerts and warnings

---
 server/models/views/alerts-and-warnings.js |   6 +-
 server/routes/alerts-and-warnings.js       | 210 ++++++++++++++------
 server/views/layout.html                   |   2 +-
 server/views/location-not-found.html       |   2 +-
 test/routes/alerts-and-warnings-POST.js    |  86 --------
 test/routes/alerts-and-warnings.js         | 219 +++++++++++++++------
 6 files changed, 318 insertions(+), 207 deletions(-)
 delete mode 100644 test/routes/alerts-and-warnings-POST.js

diff --git a/server/models/views/alerts-and-warnings.js b/server/models/views/alerts-and-warnings.js
index 65ef129d3..22450e30e 100644
--- a/server/models/views/alerts-and-warnings.js
+++ b/server/models/views/alerts-and-warnings.js
@@ -2,15 +2,17 @@ const { bingKeyMaps } = require('../../config')
 const config = require('../../config')
 
 class ViewModel {
-  constructor ({ location, place, floods, station, error }) {
+  constructor ({ q, location, place, floods, station, canonical, error }) {
     Object.assign(this, {
-      q: location,
+      q: q || location,
       map: station ? 'map-station' : 'map',
       station: station || null,
       placeName: place ? place.name : '',
       placeBbox: place ? place.bbox2k : [],
       placeCentre: place ? place.center : [],
       timestamp: Date.now(),
+      metaCanonical: canonical,
+      canonicalUrl: canonical,
       error: error ? true : null,
       displayGetWarningsLink: true,
       displayLongTermLink: true,
diff --git a/server/routes/alerts-and-warnings.js b/server/routes/alerts-and-warnings.js
index f371f2b6c..7baaf0a01 100644
--- a/server/routes/alerts-and-warnings.js
+++ b/server/routes/alerts-and-warnings.js
@@ -1,92 +1,182 @@
+const qs = require('qs')
 const joi = require('@hapi/joi')
+const boom = require('@hapi/boom')
 const ViewModel = require('../models/views/alerts-and-warnings')
 const Floods = require('../models/floods')
 const locationService = require('../services/location')
 const util = require('../util')
+const { slugify } = require('./lib/utils')
 
-module.exports = [{
-  method: 'GET',
-  path: '/alerts-and-warnings',
-  handler: async (request, h) => {
-    const { q: location } = request.query
-    let model, place, floods
-
-    const direction = request.query.direction === 'downstream' ? 'd' : 'u'
-    const station = request.query.station
-      ? await request.server.methods.flood.getStationById(request.query.station, direction)
-      : null
-
-    if (station) {
-      const warningsAlerts = await request.server.methods.flood.getWarningsAlertsWithinStationBuffer(station.rloi_id)
-      floods = new Floods({ floods: warningsAlerts })
-      model = new ViewModel({ location, place, floods, station })
-      return h.view('alerts-and-warnings', { model })
-    } else if (typeof location === 'undefined' || location === '' || location.match(/^england$/i)) {
-      floods = new Floods(await request.server.methods.flood.getFloods())
-      model = new ViewModel({ location, place, floods, station })
-      return h.view('alerts-and-warnings', { model })
-    } else {
-      try {
-        [place] = await locationService.find(util.cleanseLocation(location))
-      } catch (error) {
-        request.logger.warn({
-          situation: `Location search error: [${error.name}] [${error.message}]`,
-          err: error
-        })
-        const floods = new Floods(await request.server.methods.flood.getFloods())
-        model = new ViewModel({ location, place, floods, station, error })
-        return h.view('alerts-and-warnings', { model })
-      }
+function createQueryParametersString (queryObject) {
+  const { q, location, ...otherParameters } = queryObject
+  const queryString = qs.stringify(otherParameters, { addQueryPrefix: true, encode: false })
+  return queryString
+}
 
-      if (!place) {
-        model = new ViewModel({ location, place, floods, station })
-        return h.view('alerts-and-warnings', { model })
-      }
+async function routeHandler (request, h) {
+  let location = request.query.q || request.query.location || request.payload?.location
+  const direction = request.query.direction === 'downstream' ? 'd' : 'u'
+
+  const station = request.query.station
+    ? await request.server.methods.flood.getStationById(request.query.station, direction)
+    : null
+
+  let model, floods
 
-      if (!place?.isEngland.is_england) {
-        // If no place return empty floods
-        model = new ViewModel({ location, place, floods, station })
-        return h.view('alerts-and-warnings', { model })
+  request.yar.set('q', location)
+
+  if (station) {
+    const warningsAlerts = await request.server.methods.flood.getWarningsAlertsWithinStationBuffer(station.rloi_id)
+    floods = new Floods({ floods: warningsAlerts })
+    model = new ViewModel({ location, floods, station })
+    return h.view('alerts-and-warnings', { model })
+  }
+
+  if (location) {
+    location = util.cleanseLocation(location)
+
+    const [place] = await locationService.find(location)
+
+    if (!place) {
+      if (request.method === 'get') {
+        return boom.notFound(`Location ${location} not found`)
       } else {
-        // Data passed to floods model so the schema is the same as cached floods
-        const data = await request.server.methods.flood.getFloodsWithin(place.bbox2k)
-        floods = new Floods(data)
-        model = new ViewModel({ location, place, floods, station })
-        return h.view('alerts-and-warnings', { model })
+        return h.view('location-not-found', { pageTitle: 'Error: Find location - Check for flooding', href: 'alerts-and-warnings', location }).takeover()
+      }
+    }
+
+    if (!place.isEngland.is_england) {
+      request.logger.warn({
+        situation: 'Location search error: Valid response but location not in England.'
+      })
+
+      if (request.method === 'post') {
+        return h.view('location-not-found', { pageTitle: 'Error: Find location - Check for flooding', href: 'alerts-and-warnings', location }).takeover()
       }
     }
-  },
+
+    const queryString = createQueryParametersString(request.query)
+
+    return h.redirect(`/alerts-and-warnings/${slugify(place?.name)}${queryString}`).permanent()
+  }
+
+  const data = await request.server.methods.flood.getFloods()
+  floods = new Floods(data)
+  model = new ViewModel({ location, floods })
+  return h.view('alerts-and-warnings', { model })
+}
+
+async function locationRouteHandler (request, h) {
+  const canonicalUrl = request.url.origin + request.url.pathname
+  const location = util.cleanseLocation(request.params.location)
+  const direction = request.query.direction === 'downstream' ? 'd' : 'u'
+
+  const station = request.query.station
+    ? await request.server.methods.flood.getStationById(request.query.station, direction)
+    : null
+
+  const [place] = await locationService.find(location)
+
+  let model, floods
+
+  if (station) {
+    const warningsAlerts = await request.server.methods.flood.getWarningsAlertsWithinStationBuffer(station.rloi_id)
+    floods = new Floods({ floods: warningsAlerts })
+    model = new ViewModel({ location, place, floods, station, canonical: canonicalUrl, q: request.yar.get('q') })
+    return h.view('alerts-and-warnings', { model })
+  }
+
+  if (location.match(/^england$/i)) {
+    return h.redirect('/alerts-and-warnings')
+  }
+
+  if (slugify(place?.name) !== location) {
+    return boom.notFound(`Location ${location} not found`)
+  }
+
+  if (!place.isEngland.is_england) {
+    request.logger.warn({
+      situation: 'Location search error: Valid response but location not in England.'
+    })
+
+    if (request.method === 'get') {
+      return boom.notFound(`Location ${location} not found`)
+    } else {
+      return h.view('location-not-found', { pageTitle: 'Error: Find location - Check for flooding', href: 'alerts-and-warnings', location }).takeover()
+    }
+  }
+
+  // Data passed to floods model so the schema is the same as cached floods
+  const data = await request.server.methods.flood.getFloodsWithin(place.bbox2k)
+  floods = new Floods(data)
+  model = new ViewModel({ location, place, floods, station, canonical: canonicalUrl, q: request.yar.get('q') })
+  return h.view('alerts-and-warnings', { model })
+}
+
+function failActionHandler (request, h) {
+  request.logger.warn({
+    situation: 'Location search error: Invalid or no string input.'
+  })
+
+  const location = request.query.q || request.query.location || request.payload?.location
+
+  if (!location) {
+    return h.redirect('alerts-and-warnings').takeover()
+  } else {
+    return h.view('location-not-found', { pageTitle: 'Error: Find location - Check for flooding', href: 'alerts-and-warnings', location }).takeover()
+  }
+}
+
+module.exports = [{
+  method: 'GET',
+  path: '/alerts-and-warnings',
+  handler: routeHandler,
   options: {
     validate: {
       query: joi.object({
-        q: joi.string().allow('').trim().max(200),
+        q: joi.string().trim().max(200),
         station: joi.string(),
         btn: joi.string(),
         ext: joi.string(),
         fid: joi.string(),
         lyr: joi.string(),
         v: joi.string()
-      })
+      }),
+      failAction: failActionHandler
     }
   }
-}, {
+},
+{
+  method: 'GET',
+  path: '/alerts-and-warnings/{location}',
+  handler: locationRouteHandler,
+  options: {
+    validate: {
+      params: joi.object({
+        location: joi.string().lowercase()
+      }),
+      query: joi.object({
+        station: joi.string(),
+        btn: joi.string(),
+        ext: joi.string(),
+        fid: joi.string(),
+        lyr: joi.string(),
+        v: joi.string()
+      }),
+      failAction: failActionHandler
+    }
+  }
+},
+{
   method: 'POST',
   path: '/alerts-and-warnings',
-  handler: async (request, h) => {
-    const { location } = request.payload
-    if (location === '') {
-      return h.redirect(`/alerts-and-warnings?q=${location}`)
-    }
-    return h.redirect(`/alerts-and-warnings?q=${encodeURIComponent(util.cleanseLocation(location))}`)
-  },
+  handler: routeHandler,
   options: {
     validate: {
       payload: joi.object({
         location: joi.string().allow('').trim().max(200).required()
       }),
-      failAction: (request, h, _err) => {
-        return h.view('alerts-and-warnings').takeover()
-      }
+      failAction: failActionHandler
     }
   }
 }]
diff --git a/server/views/layout.html b/server/views/layout.html
index f9e35eb87..60dada24d 100644
--- a/server/views/layout.html
+++ b/server/views/layout.html
@@ -30,7 +30,7 @@
  
 
   {% if metaCanonical %}
-    <link rel="canonical" href="{{fullUrl}}"/>
+    <link rel="canonical" href="{{ model.canonicalUrl if model.canonicalUrl else fullUrl }}"/>
   {% endif %}
 
   <script>
diff --git a/server/views/location-not-found.html b/server/views/location-not-found.html
index cd38157f1..9de89d63e 100644
--- a/server/views/location-not-found.html
+++ b/server/views/location-not-found.html
@@ -12,7 +12,7 @@ <h1 class="govuk-heading-xl">
       <li>check the spelling</li>
       <li>enter a broader location</li>
     </ul>
-    <p class="govuk-body"><a href="/">Go back to search a location</a></p>
+    <p class="govuk-body"><a href="{{ href if href else '/' }}">Go back to search a location</a></p>
     <p class="govuk-body">If you want to search for a place outside England, you should go to:</p>
     <ul class="govuk-list govuk-list--bullet">
       <li><a href="https://www.sepa.org.uk/environment/water/flooding/">Scottish Environment Protection Agency</a></li>
diff --git a/test/routes/alerts-and-warnings-POST.js b/test/routes/alerts-and-warnings-POST.js
deleted file mode 100644
index 49b6093e8..000000000
--- a/test/routes/alerts-and-warnings-POST.js
+++ /dev/null
@@ -1,86 +0,0 @@
-'use strict'
-
-const Hapi = require('@hapi/hapi')
-const Lab = require('@hapi/lab')
-const Code = require('@hapi/code')
-const sinon = require('sinon')
-const lab = exports.lab = Lab.script()
-
-lab.experiment('Routes test - alerts-and-warnings', () => {
-  let sandbox
-  let server
-
-  lab.beforeEach(async () => {
-    sandbox = await sinon.createSandbox()
-    server = Hapi.server({
-      port: 3000,
-      host: 'localhost'
-    })
-
-    const alertsPlugin = {
-      plugin: {
-        name: 'alerts-and-warnings',
-        register: (server, options) => {
-          server.route(require('../../server/routes/alerts-and-warnings'))
-        }
-      }
-    }
-
-    await server.register(require('@hapi/inert'))
-    await server.register(require('@hapi/h2o2'))
-    await server.register(require('../../server/plugins/views'))
-    await server.register(alertsPlugin)
-    await server.initialize()
-  })
-
-  lab.afterEach(async () => {
-    await server.stop()
-    await sandbox.restore()
-    const regex = /.\/server\/models\/./
-    Object.keys(require.cache).forEach((key) => {
-      if (key.match(regex)) {
-        delete require.cache[key]
-      }
-    })
-  })
-
-  lab.test('POST /alerts and warnings', async () => {
-    const options = {
-      method: 'POST',
-      url: '/alerts-and-warnings',
-      payload: {
-        location: 'Warrington'
-      }
-    }
-
-    const response = await server.inject(options)
-    Code.expect(response.statusCode).to.equal(302)
-    Code.expect(response.headers['content-type']).to.include('text/html')
-  })
-  lab.test('POST /alerts and warnings payload fails joi validation', async () => {
-    const options = {
-      method: 'POST',
-      url: '/alerts-and-warnings',
-      payload: {
-        river: 'Test'
-      }
-    }
-
-    const response = await server.inject(options)
-    Code.expect(response.statusCode).to.equal(200)
-    Code.expect(response.headers['content-type']).to.include('text/html')
-  })
-  lab.test('POST /alerts and warnings with blank location', async () => {
-    const options = {
-      method: 'POST',
-      url: '/alerts-and-warnings',
-      payload: {
-        location: ''
-      }
-    }
-
-    const response = await server.inject(options)
-    Code.expect(response.statusCode).to.equal(302)
-    Code.expect(response.headers['content-type']).to.include('text/html')
-  })
-})
diff --git a/test/routes/alerts-and-warnings.js b/test/routes/alerts-and-warnings.js
index 562319712..87b454723 100644
--- a/test/routes/alerts-and-warnings.js
+++ b/test/routes/alerts-and-warnings.js
@@ -74,7 +74,7 @@ lab.experiment('Test - /alerts-warnings', () => {
     delete require.cache[require.resolve('../../server/util')]
   })
 
-  lab.test('GET /alerts-and-warnings with query parameters of Warrington and no warnings or alerts', async () => {
+  lab.test('GET /alerts-and-warnings with legacy query parameters of Warrington', async () => {
     stubs.getJson.callsFake(() => data.warringtonGetJson)
     stubs.getIsEngland.callsFake(() => ({ is_england: true }))
     stubs.getFloodsWithin.callsFake(() => ({ floods: [] }))
@@ -87,81 +87,44 @@ lab.experiment('Test - /alerts-warnings', () => {
 
     const response = await server.inject(options)
 
-    Code.expect(response.statusCode).to.equal(200)
-    Code.expect(response.payload).to.contain('No alerts or warnings')
+    Code.expect(response.statusCode).to.equal(301)
+    Code.expect(response.headers.location).to.equal('/alerts-and-warnings/warrington')
   })
-  lab.test('GET /alerts-and-warnings TYPO or non location "afdv vdaf adfv  fda" ', async () => {
-    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+
+  lab.test('GET /alerts-and-warnings with location of Warrington', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getFloodsWithin.callsFake(() => ({ floods: [] }))
 
     const options = {
       method: 'GET',
-      url: '/alerts-and-warnings?q=wefwe%20we%20fwef%20str'
+      url: '/alerts-and-warnings/warrington'
     }
 
     const response = await server.inject(options)
 
-    Code.expect(response.payload).to.contain('No alerts or warnings')
     Code.expect(response.statusCode).to.equal(200)
   })
-  lab.test('GET /alerts-and-warnings with query parameters of Kinghorn, Scotland', async () => {
-    stubs.getIsEngland.callsFake(() => ({ is_england: false }))
-    stubs.getJson.callsFake(() => data.scotlandGetJson)
-    const options = {
-      method: 'GET',
-      url: '/alerts-and-warnings?q=kinghorn'
-    }
 
-    const response = await server.inject(options)
+  lab.test('GET /alerts-and-warnings with legacy query parameters should 404', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
 
-    Code.expect(response.payload).to.contain('If you searched a place in England, you should:')
-    Code.expect(response.statusCode).to.equal(200)
-  })
-  lab.test('GET /alerts-and-warnings with query parameters, show alert, warnings and severe', async () => {
-    stubs.getJson.callsFake(() => data.warringtonGetJson)
-    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
-    stubs.getFloodsWithin.callsFake(() => data.fakeFloodsData)
-    stubs.getStationsWithin.callsFake(() => [])
-    stubs.getImpactsWithin.callsFake(() => [])
     const options = {
       method: 'GET',
-      url: '/alerts-and-warnings?q=Warrington'
+      url: '/alerts-and-warnings?q=not-found'
     }
 
     const response = await server.inject(options)
 
-    Code.expect(response.payload).to.contain('1 flood warning')
-    Code.expect(response.payload).to.contain('1 severe flood warning')
-    Code.expect(response.payload).to.contain('3 flood alerts')
-    Code.expect(response.payload).to.contain('1 flood warning removed')
-    Code.expect(response.payload).to.contain('<a href="/target-area/013WAFGL" class="defra-flood-warnings-list-item__title">River Glaze catchment including Leigh and East Wigan</a>')
-    Code.expect(response.payload).to.contain('<a href="/target-area/013FWFCH29" class="defra-flood-warnings-list-item__title">Wider area at risk from Sankey Brook at Dallam</a>')
-    Code.expect(response.payload).to.contain('<a href="/target-area/013WAFDI" class="defra-flood-warnings-list-item__title">River Ditton catchment including areas around Huyton-with-Roby and Widnes</a>')
-    Code.expect(response.statusCode).to.equal(200)
+    Code.expect(response.statusCode).to.equal(404)
+    Code.expect(response.headers.location).to.equal(undefined)
   })
-  lab.test('GET /alerts-and-warnings with query parameters of WA4 1HT', async () => {
+
+  lab.test('GET /alerts-and-warnings with legacy query parameters of WA4 1HT', async () => {
     stubs.getJson.callsFake(() => data.warringtonGetJson)
     stubs.getIsEngland.callsFake(() => ({ is_england: true }))
     stubs.getFloodsWithin.callsFake(() => data.floodsByPostCode)
-    stubs.getStationsWithin.callsFake(() => [])
-    stubs.getImpactsWithin.callsFake(() => [])
-    const options = {
-      method: 'GET',
-      url: '/alerts-and-warnings?q=WA4%201HT'
-    }
-
-    const response = await server.inject(options)
 
-    Code.expect(response.payload).to.contain('4 flood alerts')
-    Code.expect(response.payload).to.contain('<a href="/target-area/013WAFLM" class="defra-flood-warnings-list-item__title">Lower River Mersey including Warrington, Runcorn and Lymm areas</a>')
-    Code.expect(response.statusCode).to.equal(200)
-  })
-  lab.test('GET /alerts-and-warnings Bing returns error', async () => {
-    stubs.getJson.callsFake(() => {
-      throw new Error('Bing error')
-    })
-    stubs.getFloods.callsFake(() => ({
-      floods: []
-    }))
     const options = {
       method: 'GET',
       url: '/alerts-and-warnings?q=WA4%201HT'
@@ -169,11 +132,11 @@ lab.experiment('Test - /alerts-warnings', () => {
 
     const response = await server.inject(options)
 
-    Code.expect(response.payload).to.contain('Sorry, there is currently a problem searching a location - GOV.UK')
-    Code.expect(response.payload).to.contain('Sorry, there is currently a problem searching a location')
-    Code.expect(response.statusCode).to.equal(200)
+    Code.expect(response.statusCode).to.equal(301)
+    // Code.expect(response.headers.location).to.equal('/alerts-and-warnings/warrington-wa4-1ht')
   })
-  lab.test('GET /alerts-and-warnings - England parameter query', async () => {
+
+  lab.test('GET /alerts-and-warnings with legacy query parameters of England', async () => {
     // Create dummy flood data in place of cached data
     stubs.getFloods.callsFake(() => ({
       floods: [
@@ -203,9 +166,146 @@ lab.experiment('Test - /alerts-warnings', () => {
 
     const response = await server.inject(options)
 
+    Code.expect(response.statusCode).to.equal(404)
+  })
+
+  lab.test('POST /alerts and warnings', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getFloodsWithin.callsFake(() => data.fakeFloodsData)
+
+    const options = {
+      method: 'POST',
+      url: '/alerts-and-warnings',
+      payload: {
+        location: 'Warrington'
+      }
+    }
+
+    const response = await server.inject(options)
+    Code.expect(response.statusCode).to.equal(301)
+    Code.expect(response.headers['content-type']).to.include('text/html')
+  })
+
+  lab.test('POST /alerts and warnings payload fails joi validation', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+
+    const options = {
+      method: 'POST',
+      url: '/alerts-and-warnings',
+      payload: {
+        river: 'Test'
+      }
+    }
+
+    const response = await server.inject(options)
+    Code.expect(response.statusCode).to.equal(302)
+    Code.expect(response.headers['content-type']).to.include('text/html')
+  })
+
+  lab.test('POST /alerts and warnings with blank location', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+    stubs.getFloods.callsFake(() => ({ floods: [] }))
+
+    const options = {
+      method: 'POST',
+      url: '/alerts-and-warnings',
+      payload: {
+        location: ''
+      }
+    }
+
+    const response = await server.inject(options)
     Code.expect(response.statusCode).to.equal(200)
+    Code.expect(response.headers['content-type']).to.include('text/html')
+  })
+
+  lab.test('GET /alerts-and-warnings TYPO or non location "afdv vdaf adfv  fda" ', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+
+    const options = {
+      method: 'GET',
+      url: '/alerts-and-warnings?q=wefwe%20we%20fwef%20str'
+    }
+
+    const response = await server.inject(options)
+
+    Code.expect(response.statusCode).to.equal(404)
+  })
+
+  lab.test('GET /alerts-and-warnings with query parameters of Kinghorn, Scotland', async () => {
+    stubs.getIsEngland.callsFake(() => ({ is_england: false }))
+    stubs.getJson.callsFake(() => data.scotlandGetJson)
+    const options = {
+      method: 'GET',
+      url: '/alerts-and-warnings?q=kinghorn'
+    }
+
+    const response = await server.inject(options)
+
+    Code.expect(response.statusCode).to.equal(301)
+    Code.expect(response.headers.location).to.equal('/alerts-and-warnings/kinghorn-fife')
+  })
+
+  lab.test('GET /alerts-and-warnings location, show alert, warnings and severe', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getFloodsWithin.callsFake(() => data.fakeFloodsData)
+    stubs.getStationsWithin.callsFake(() => [])
+    stubs.getImpactsWithin.callsFake(() => [])
+    const options = {
+      method: 'GET',
+      url: '/alerts-and-warnings/Warrington'
+    }
+
+    const response = await server.inject(options)
+
     Code.expect(response.payload).to.contain('1 flood warning')
+    Code.expect(response.payload).to.contain('1 severe flood warning')
+    Code.expect(response.payload).to.contain('3 flood alerts')
+    Code.expect(response.payload).to.contain('1 flood warning removed')
+    Code.expect(response.payload).to.contain('<a href="/target-area/013WAFGL" class="defra-flood-warnings-list-item__title">River Glaze catchment including Leigh and East Wigan</a>')
+    Code.expect(response.payload).to.contain('<a href="/target-area/013FWFCH29" class="defra-flood-warnings-list-item__title">Wider area at risk from Sankey Brook at Dallam</a>')
+    Code.expect(response.payload).to.contain('<a href="/target-area/013WAFDI" class="defra-flood-warnings-list-item__title">River Ditton catchment including areas around Huyton-with-Roby and Widnes</a>')
+    Code.expect(response.statusCode).to.equal(200)
+  })
+
+  lab.test('GET /alerts-and-warnings should set the canonical url', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getFloodsWithin.callsFake(() => data.fakeFloodsData)
+
+    const options = {
+      method: 'GET',
+      url: '/alerts-and-warnings/warrington?active=true'
+    }
+
+    const response = await server.inject(options)
+
+    Code.expect(response.payload).to.contain('<link rel="canonical" href="http://localhost:3000/alerts-and-warnings/warrington"/>')
+    Code.expect(response.statusCode).to.equal(200)
   })
+
+  // lab.test('GET /alerts-and-warnings Bing returns error', async () => {
+  //   // stubs.getJson.callsFake(() => { throw new Error('Bing error') })
+  //   // stubs.getJson.callsFake(() => data.warringtonGetJson)
+  //   // stubs.getFloodsWithin.callsFake(() => ({ floods: [] }))
+  //   stubs.getJson.callsFake(() => data.warringtonGetJson)
+  //   stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+  //   stubs.getFloodsWithin.callsFake(() => data.fakeFloodsData)
+
+  //   const options = {
+  //     method: 'GET',
+  //     url: '/alerts-and-warnings'
+  //   }
+
+  //   const response = await server.inject(options)
+
+  //   Code.expect(response.payload).to.contain('Sorry, there is currently a problem searching a location - GOV.UK')
+  //   Code.expect(response.payload).to.contain('Sorry, there is currently a problem searching a location')
+  //   Code.expect(response.statusCode).to.equal(500)
+  // })
+
   lab.test('GET /alerts-and-warnings ', async () => {
     stubs.getFloods.callsFake(() => ({
       floods: []
@@ -221,9 +321,12 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.statusCode).to.equal(200)
     Code.expect(response.payload).to.contain('No flood alerts or warnings')
   })
+
   lab.test('GET /alerts-and-warnings?station=1001 ', async () => {
+    stubs.getFloods.callsFake(() => ({ floods: [] }))
     stubs.getStationById.callsFake(() => data.fakeGetStationById)
     stubs.getWarningsAlertsWithinStationBuffer.callsFake(() => [])
+
     const options = {
       method: 'GET',
       url: '/alerts-and-warnings?station=1001'
@@ -234,6 +337,7 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.statusCode).to.equal(200)
     Code.expect(response.payload).to.contain('Beeding Bridge - flood alerts and warnings - GOV.UK')
   })
+
   lab.test('GET /alerts-and-warnings with unknown parameter e.g. facebook click id ', async () => {
     stubs.getStationById.callsFake(() => data.fakeGetStationById)
     stubs.getWarningsAlertsWithinStationBuffer.callsFake(() => [])
@@ -247,6 +351,7 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.payload).to.contain('Beeding Bridge - flood alerts and warnings - GOV.UK')
     Code.expect(response.statusCode).to.equal(200)
   })
+
   lab.test('GET /alerts-and-warnings check for related content links ', async () => {
     stubs.getFloods.callsFake(() => ({
       floods: []

From ff4e7a88c9e9b54948ab14802d9c7c4b0a2b7ccb Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Tue, 21 May 2024 11:04:29 +0100
Subject: [PATCH 02/29] sonar fix 1

---
 server/models/views/alerts-and-warnings.js | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/server/models/views/alerts-and-warnings.js b/server/models/views/alerts-and-warnings.js
index 22450e30e..bf147101b 100644
--- a/server/models/views/alerts-and-warnings.js
+++ b/server/models/views/alerts-and-warnings.js
@@ -6,18 +6,18 @@ class ViewModel {
     Object.assign(this, {
       q: q || location,
       map: station ? 'map-station' : 'map',
-      station: station || null,
-      placeName: place ? place.name : '',
-      placeBbox: place ? place.bbox2k : [],
-      placeCentre: place ? place.center : [],
+      station: station,
+      placeName: place?.name || '',
+      placeBbox: place?.bbox2k || [],
+      placeCentre: place?.center || [],
       timestamp: Date.now(),
       metaCanonical: canonical,
       canonicalUrl: canonical,
       error: error ? true : null,
       displayGetWarningsLink: true,
       displayLongTermLink: true,
-      isEngland: place ? place.isEngland.is_england : null,
-      isDummyData: floods ? floods.isDummyData : false,
+      isEngland: place?.isEngland?.is_england || null,
+      isDummyData: floods?.isDummyData || false,
       floodRiskUrl: config.floodRiskUrl
     })
 

From b40cb1e0dcaafcaa40ae14f976e56f39f6163411 Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Tue, 21 May 2024 12:03:46 +0100
Subject: [PATCH 03/29] path var

---
 server/routes/alerts-and-warnings.js | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/server/routes/alerts-and-warnings.js b/server/routes/alerts-and-warnings.js
index 7baaf0a01..f4317a59b 100644
--- a/server/routes/alerts-and-warnings.js
+++ b/server/routes/alerts-and-warnings.js
@@ -7,6 +7,9 @@ const locationService = require('../services/location')
 const util = require('../util')
 const { slugify } = require('./lib/utils')
 
+const pathUrl = '/alerts-and-warnings'
+const QUERY_STRING_LOCATION_MAX_LENGTH = 200
+
 function createQueryParametersString (queryObject) {
   const { q, location, ...otherParameters } = queryObject
   const queryString = qs.stringify(otherParameters, { addQueryPrefix: true, encode: false })
@@ -57,7 +60,7 @@ async function routeHandler (request, h) {
 
     const queryString = createQueryParametersString(request.query)
 
-    return h.redirect(`/alerts-and-warnings/${slugify(place?.name)}${queryString}`).permanent()
+    return h.redirect(`${pathUrl}/${slugify(place?.name)}${queryString}`).permanent()
   }
 
   const data = await request.server.methods.flood.getFloods()
@@ -87,7 +90,7 @@ async function locationRouteHandler (request, h) {
   }
 
   if (location.match(/^england$/i)) {
-    return h.redirect('/alerts-and-warnings')
+    return h.redirect(pathUrl)
   }
 
   if (slugify(place?.name) !== location) {
@@ -129,12 +132,12 @@ function failActionHandler (request, h) {
 
 module.exports = [{
   method: 'GET',
-  path: '/alerts-and-warnings',
+  path: pathUrl,
   handler: routeHandler,
   options: {
     validate: {
       query: joi.object({
-        q: joi.string().trim().max(200),
+        q: joi.string().trim().max(QUERY_STRING_LOCATION_MAX_LENGTH),
         station: joi.string(),
         btn: joi.string(),
         ext: joi.string(),
@@ -148,7 +151,7 @@ module.exports = [{
 },
 {
   method: 'GET',
-  path: '/alerts-and-warnings/{location}',
+  path: `${pathUrl}/{location}`,
   handler: locationRouteHandler,
   options: {
     validate: {
@@ -169,12 +172,12 @@ module.exports = [{
 },
 {
   method: 'POST',
-  path: '/alerts-and-warnings',
+  path: pathUrl,
   handler: routeHandler,
   options: {
     validate: {
       payload: joi.object({
-        location: joi.string().allow('').trim().max(200).required()
+        location: joi.string().allow('').trim().max(QUERY_STRING_LOCATION_MAX_LENGTH).required()
       }),
       failAction: failActionHandler
     }

From acf1fd3536b431b8c5180fefb677f5e6a0b2d12e Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Tue, 21 May 2024 12:20:53 +0100
Subject: [PATCH 04/29] sonar fixes 3

---
 server/routes/alerts-and-warnings.js | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/server/routes/alerts-and-warnings.js b/server/routes/alerts-and-warnings.js
index f4317a59b..f437a6aca 100644
--- a/server/routes/alerts-and-warnings.js
+++ b/server/routes/alerts-and-warnings.js
@@ -10,6 +10,14 @@ const { slugify } = require('./lib/utils')
 const pathUrl = '/alerts-and-warnings'
 const QUERY_STRING_LOCATION_MAX_LENGTH = 200
 
+function renderLocationNotFound (location, h) {
+  return h.view('location-not-found', { pageTitle: 'Error: Find location - Check for flooding', href: 'alerts-and-warnings', location }).takeover()
+}
+
+function renderNotFound (location) {
+  return boom.notFound(`Location ${location} not found`)
+}
+
 function createQueryParametersString (queryObject) {
   const { q, location, ...otherParameters } = queryObject
   const queryString = qs.stringify(otherParameters, { addQueryPrefix: true, encode: false })
@@ -42,9 +50,9 @@ async function routeHandler (request, h) {
 
     if (!place) {
       if (request.method === 'get') {
-        return boom.notFound(`Location ${location} not found`)
+        return renderNotFound(location)
       } else {
-        return h.view('location-not-found', { pageTitle: 'Error: Find location - Check for flooding', href: 'alerts-and-warnings', location }).takeover()
+        return renderLocationNotFound(location, h)
       }
     }
 
@@ -54,7 +62,7 @@ async function routeHandler (request, h) {
       })
 
       if (request.method === 'post') {
-        return h.view('location-not-found', { pageTitle: 'Error: Find location - Check for flooding', href: 'alerts-and-warnings', location }).takeover()
+        return renderLocationNotFound(location, h)
       }
     }
 
@@ -94,7 +102,7 @@ async function locationRouteHandler (request, h) {
   }
 
   if (slugify(place?.name) !== location) {
-    return boom.notFound(`Location ${location} not found`)
+    return renderNotFound(location)
   }
 
   if (!place.isEngland.is_england) {
@@ -103,9 +111,9 @@ async function locationRouteHandler (request, h) {
     })
 
     if (request.method === 'get') {
-      return boom.notFound(`Location ${location} not found`)
+      return renderNotFound(location)
     } else {
-      return h.view('location-not-found', { pageTitle: 'Error: Find location - Check for flooding', href: 'alerts-and-warnings', location }).takeover()
+      return renderLocationNotFound(location, h)
     }
   }
 
@@ -126,7 +134,7 @@ function failActionHandler (request, h) {
   if (!location) {
     return h.redirect('alerts-and-warnings').takeover()
   } else {
-    return h.view('location-not-found', { pageTitle: 'Error: Find location - Check for flooding', href: 'alerts-and-warnings', location }).takeover()
+    return renderLocationNotFound(location, h)
   }
 }
 

From d063d151dfa58d4a43b604262be614bba6cd2fd4 Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Wed, 22 May 2024 08:50:36 +0100
Subject: [PATCH 05/29] sonar fixes 4

---
 server/routes/alerts-and-warnings.js | 50 +++++++++++++---------------
 1 file changed, 23 insertions(+), 27 deletions(-)

diff --git a/server/routes/alerts-and-warnings.js b/server/routes/alerts-and-warnings.js
index f437a6aca..981572cc3 100644
--- a/server/routes/alerts-and-warnings.js
+++ b/server/routes/alerts-and-warnings.js
@@ -7,11 +7,11 @@ const locationService = require('../services/location')
 const util = require('../util')
 const { slugify } = require('./lib/utils')
 
-const pathUrl = '/alerts-and-warnings'
+const page = 'alerts-and-warnings'
 const QUERY_STRING_LOCATION_MAX_LENGTH = 200
 
 function renderLocationNotFound (location, h) {
-  return h.view('location-not-found', { pageTitle: 'Error: Find location - Check for flooding', href: 'alerts-and-warnings', location }).takeover()
+  return h.view('location-not-found', { pageTitle: 'Error: Find location - Check for flooding', href: page, location }).takeover()
 }
 
 function renderNotFound (location) {
@@ -26,21 +26,19 @@ function createQueryParametersString (queryObject) {
 
 async function routeHandler (request, h) {
   let location = request.query.q || request.query.location || request.payload?.location
+  request.yar.set('q', location)
+
   const direction = request.query.direction === 'downstream' ? 'd' : 'u'
 
-  const station = request.query.station
-    ? await request.server.methods.flood.getStationById(request.query.station, direction)
-    : null
+  let model, floods, station
 
-  let model, floods
+  if (request.query.station) {
+    station = await request.server.methods.flood.getStationById(request.query.station, direction)
 
-  request.yar.set('q', location)
-
-  if (station) {
     const warningsAlerts = await request.server.methods.flood.getWarningsAlertsWithinStationBuffer(station.rloi_id)
     floods = new Floods({ floods: warningsAlerts })
     model = new ViewModel({ location, floods, station })
-    return h.view('alerts-and-warnings', { model })
+    return h.view(page, { model })
   }
 
   if (location) {
@@ -51,9 +49,9 @@ async function routeHandler (request, h) {
     if (!place) {
       if (request.method === 'get') {
         return renderNotFound(location)
-      } else {
-        return renderLocationNotFound(location, h)
       }
+
+      return renderLocationNotFound(location, h)
     }
 
     if (!place.isEngland.is_england) {
@@ -68,13 +66,13 @@ async function routeHandler (request, h) {
 
     const queryString = createQueryParametersString(request.query)
 
-    return h.redirect(`${pathUrl}/${slugify(place?.name)}${queryString}`).permanent()
+    return h.redirect(`/${page}/${slugify(place?.name)}${queryString}`).permanent()
   }
 
   const data = await request.server.methods.flood.getFloods()
   floods = new Floods(data)
   model = new ViewModel({ location, floods })
-  return h.view('alerts-and-warnings', { model })
+  return h.view(page, { model })
 }
 
 async function locationRouteHandler (request, h) {
@@ -82,23 +80,21 @@ async function locationRouteHandler (request, h) {
   const location = util.cleanseLocation(request.params.location)
   const direction = request.query.direction === 'downstream' ? 'd' : 'u'
 
-  const station = request.query.station
-    ? await request.server.methods.flood.getStationById(request.query.station, direction)
-    : null
-
   const [place] = await locationService.find(location)
 
-  let model, floods
+  let model, floods, station
+
+  if (request.query.station) {
+    station = await request.server.methods.flood.getStationById(request.query.station, direction)
 
-  if (station) {
     const warningsAlerts = await request.server.methods.flood.getWarningsAlertsWithinStationBuffer(station.rloi_id)
     floods = new Floods({ floods: warningsAlerts })
     model = new ViewModel({ location, place, floods, station, canonical: canonicalUrl, q: request.yar.get('q') })
-    return h.view('alerts-and-warnings', { model })
+    return h.view(page, { model })
   }
 
   if (location.match(/^england$/i)) {
-    return h.redirect(pathUrl)
+    return h.redirect(`/${page}`)
   }
 
   if (slugify(place?.name) !== location) {
@@ -121,7 +117,7 @@ async function locationRouteHandler (request, h) {
   const data = await request.server.methods.flood.getFloodsWithin(place.bbox2k)
   floods = new Floods(data)
   model = new ViewModel({ location, place, floods, station, canonical: canonicalUrl, q: request.yar.get('q') })
-  return h.view('alerts-and-warnings', { model })
+  return h.view(page, { model })
 }
 
 function failActionHandler (request, h) {
@@ -132,7 +128,7 @@ function failActionHandler (request, h) {
   const location = request.query.q || request.query.location || request.payload?.location
 
   if (!location) {
-    return h.redirect('alerts-and-warnings').takeover()
+    return h.redirect(page).takeover()
   } else {
     return renderLocationNotFound(location, h)
   }
@@ -140,7 +136,7 @@ function failActionHandler (request, h) {
 
 module.exports = [{
   method: 'GET',
-  path: pathUrl,
+  path: `/${page}`,
   handler: routeHandler,
   options: {
     validate: {
@@ -159,7 +155,7 @@ module.exports = [{
 },
 {
   method: 'GET',
-  path: `${pathUrl}/{location}`,
+  path: `/${page}/{location}`,
   handler: locationRouteHandler,
   options: {
     validate: {
@@ -180,7 +176,7 @@ module.exports = [{
 },
 {
   method: 'POST',
-  path: pathUrl,
+  path: `/${page}`,
   handler: routeHandler,
   options: {
     validate: {

From 9b0fd338723c2018dfdadffd3d48531456d10654 Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Wed, 22 May 2024 09:26:20 +0100
Subject: [PATCH 06/29] code tidy

---
 server/models/views/alerts-and-warnings.js |  4 +-
 server/routes/alerts-and-warnings.js       | 72 ++++++++++------------
 2 files changed, 33 insertions(+), 43 deletions(-)

diff --git a/server/models/views/alerts-and-warnings.js b/server/models/views/alerts-and-warnings.js
index bf147101b..430e0c9af 100644
--- a/server/models/views/alerts-and-warnings.js
+++ b/server/models/views/alerts-and-warnings.js
@@ -4,9 +4,9 @@ const config = require('../../config')
 class ViewModel {
   constructor ({ q, location, place, floods, station, canonical, error }) {
     Object.assign(this, {
-      q: q || location,
+      q,
+      station,
       map: station ? 'map-station' : 'map',
-      station: station,
       placeName: place?.name || '',
       placeBbox: place?.bbox2k || [],
       placeCentre: place?.center || [],
diff --git a/server/routes/alerts-and-warnings.js b/server/routes/alerts-and-warnings.js
index 981572cc3..c9e36e4a6 100644
--- a/server/routes/alerts-and-warnings.js
+++ b/server/routes/alerts-and-warnings.js
@@ -26,14 +26,15 @@ function createQueryParametersString (queryObject) {
 
 async function routeHandler (request, h) {
   let location = request.query.q || request.query.location || request.payload?.location
-  request.yar.set('q', location)
+
+  request.yar.set('q', { location })
 
   const direction = request.query.direction === 'downstream' ? 'd' : 'u'
 
-  let model, floods, station
+  let model, floods
 
   if (request.query.station) {
-    station = await request.server.methods.flood.getStationById(request.query.station, direction)
+    const station = await request.server.methods.flood.getStationById(request.query.station, direction)
 
     const warningsAlerts = await request.server.methods.flood.getWarningsAlertsWithinStationBuffer(station.rloi_id)
     floods = new Floods({ floods: warningsAlerts })
@@ -41,58 +42,46 @@ async function routeHandler (request, h) {
     return h.view(page, { model })
   }
 
-  if (location) {
-    location = util.cleanseLocation(location)
+  if (!location) {
+    const data = await request.server.methods.flood.getFloods()
+    floods = new Floods(data)
+    model = new ViewModel({ location, floods })
+    return h.view(page, { model })
+  }
 
-    const [place] = await locationService.find(location)
+  location = util.cleanseLocation(location)
 
-    if (!place) {
-      if (request.method === 'get') {
-        return renderNotFound(location)
-      }
+  const [place] = await locationService.find(location)
 
-      return renderLocationNotFound(location, h)
+  if (!place) {
+    if (request.method === 'get') {
+      return renderNotFound(location)
     }
 
-    if (!place.isEngland.is_england) {
-      request.logger.warn({
-        situation: 'Location search error: Valid response but location not in England.'
-      })
-
-      if (request.method === 'post') {
-        return renderLocationNotFound(location, h)
-      }
-    }
+    return renderLocationNotFound(location, h)
+  }
 
-    const queryString = createQueryParametersString(request.query)
+  if (!place.isEngland.is_england) {
+    request.logger.warn({
+      situation: 'Location search error: Valid response but location not in England.'
+    })
 
-    return h.redirect(`/${page}/${slugify(place?.name)}${queryString}`).permanent()
+    if (request.method === 'post') {
+      return renderLocationNotFound(location, h)
+    }
   }
 
-  const data = await request.server.methods.flood.getFloods()
-  floods = new Floods(data)
-  model = new ViewModel({ location, floods })
-  return h.view(page, { model })
+  const queryString = createQueryParametersString(request.query)
+
+  return h.redirect(`/${page}/${slugify(place?.name)}${queryString}`).permanent()
 }
 
 async function locationRouteHandler (request, h) {
   const canonicalUrl = request.url.origin + request.url.pathname
   const location = util.cleanseLocation(request.params.location)
-  const direction = request.query.direction === 'downstream' ? 'd' : 'u'
 
   const [place] = await locationService.find(location)
 
-  let model, floods, station
-
-  if (request.query.station) {
-    station = await request.server.methods.flood.getStationById(request.query.station, direction)
-
-    const warningsAlerts = await request.server.methods.flood.getWarningsAlertsWithinStationBuffer(station.rloi_id)
-    floods = new Floods({ floods: warningsAlerts })
-    model = new ViewModel({ location, place, floods, station, canonical: canonicalUrl, q: request.yar.get('q') })
-    return h.view(page, { model })
-  }
-
   if (location.match(/^england$/i)) {
     return h.redirect(`/${page}`)
   }
@@ -101,7 +90,7 @@ async function locationRouteHandler (request, h) {
     return renderNotFound(location)
   }
 
-  if (!place.isEngland.is_england) {
+  if (!place?.isEngland.is_england) {
     request.logger.warn({
       situation: 'Location search error: Valid response but location not in England.'
     })
@@ -115,8 +104,9 @@ async function locationRouteHandler (request, h) {
 
   // Data passed to floods model so the schema is the same as cached floods
   const data = await request.server.methods.flood.getFloodsWithin(place.bbox2k)
-  floods = new Floods(data)
-  model = new ViewModel({ location, place, floods, station, canonical: canonicalUrl, q: request.yar.get('q') })
+  const floods = new Floods(data)
+  const model = new ViewModel({ location, place, floods, canonical: canonicalUrl, q: request.yar.get('q')?.location })
+  request.yar.set('q', null)
   return h.view(page, { model })
 }
 

From a36714bd58d4696207aa9939748e3b45f45060f2 Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Wed, 22 May 2024 09:34:10 +0100
Subject: [PATCH 07/29] sonar fixes 5

---
 server/models/views/alerts-and-warnings.js | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/server/models/views/alerts-and-warnings.js b/server/models/views/alerts-and-warnings.js
index 430e0c9af..abf614f33 100644
--- a/server/models/views/alerts-and-warnings.js
+++ b/server/models/views/alerts-and-warnings.js
@@ -13,11 +13,11 @@ class ViewModel {
       timestamp: Date.now(),
       metaCanonical: canonical,
       canonicalUrl: canonical,
-      error: error ? true : null,
+      error: !!error,
       displayGetWarningsLink: true,
       displayLongTermLink: true,
-      isEngland: place?.isEngland?.is_england || null,
-      isDummyData: floods?.isDummyData || false,
+      isEngland: place?.isEngland?.is_england,
+      isDummyData: floods?.isDummyData,
       floodRiskUrl: config.floodRiskUrl
     })
 
@@ -30,10 +30,8 @@ class ViewModel {
         this.pageTitle = `${location ? location + ' - f' : 'F'}lood alerts and warnings`
       }
     }
-    this.countFloods = floods ? floods.floods.length : 0
-    this.floods = floods
-      ? floods.groups.map(item => item)
-      : []
+    this.countFloods = floods?.floods?.length ?? 0
+    this.floods = floods?.groups?.map(item => item) ?? []
 
     this.expose = {
       station: this.station,

From 08d26def1d0314ff7890d80a6ccb226af57fe288 Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Wed, 22 May 2024 09:40:55 +0100
Subject: [PATCH 08/29] sonar fixes 6

---
 server/models/views/alerts-and-warnings.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/models/views/alerts-and-warnings.js b/server/models/views/alerts-and-warnings.js
index abf614f33..73bebb3c7 100644
--- a/server/models/views/alerts-and-warnings.js
+++ b/server/models/views/alerts-and-warnings.js
@@ -2,7 +2,7 @@ const { bingKeyMaps } = require('../../config')
 const config = require('../../config')
 
 class ViewModel {
-  constructor ({ q, location, place, floods, station, canonical, error }) {
+  constructor ({ q, location, place, floods = [], station, canonical, error }) {
     Object.assign(this, {
       q,
       station,

From 7cab4d2d78f77fa55cdeaae3394e32c45917b2b2 Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Wed, 22 May 2024 09:44:48 +0100
Subject: [PATCH 09/29] sonar fixes 6

---
 server/models/views/alerts-and-warnings.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/models/views/alerts-and-warnings.js b/server/models/views/alerts-and-warnings.js
index 73bebb3c7..aa03914bc 100644
--- a/server/models/views/alerts-and-warnings.js
+++ b/server/models/views/alerts-and-warnings.js
@@ -31,7 +31,7 @@ class ViewModel {
       }
     }
     this.countFloods = floods?.floods?.length ?? 0
-    this.floods = floods?.groups?.map(item => item) ?? []
+    this.floods = floods?.groups?.map(item => item)
 
     this.expose = {
       station: this.station,

From 043ba744e9ec173f9188393d3a2ab048374a67f2 Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Wed, 22 May 2024 10:54:18 +0100
Subject: [PATCH 10/29] add not found location route test

---
 test/routes/alerts-and-warnings.js | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/test/routes/alerts-and-warnings.js b/test/routes/alerts-and-warnings.js
index 87b454723..bf1badf2f 100644
--- a/test/routes/alerts-and-warnings.js
+++ b/test/routes/alerts-and-warnings.js
@@ -255,7 +255,7 @@ lab.experiment('Test - /alerts-warnings', () => {
     stubs.getImpactsWithin.callsFake(() => [])
     const options = {
       method: 'GET',
-      url: '/alerts-and-warnings/Warrington'
+      url: '/alerts-and-warnings/warrington'
     }
 
     const response = await server.inject(options)
@@ -286,6 +286,19 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.statusCode).to.equal(200)
   })
 
+  lab.test('GET /alerts-and-warnings should not find location', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+
+    const options = {
+      method: 'GET',
+      url: '/alerts-and-warnings/not-found'
+    }
+
+    const response = await server.inject(options)
+
+    Code.expect(response.statusCode).to.equal(404)
+  })
+
   // lab.test('GET /alerts-and-warnings Bing returns error', async () => {
   //   // stubs.getJson.callsFake(() => { throw new Error('Bing error') })
   //   // stubs.getJson.callsFake(() => data.warringtonGetJson)

From c1c62b3ed59747e95f048f62c6d48dd80d6521e5 Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Wed, 22 May 2024 11:12:53 +0100
Subject: [PATCH 11/29] add not found location route test

---
 test/routes/alerts-and-warnings.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/test/routes/alerts-and-warnings.js b/test/routes/alerts-and-warnings.js
index bf1badf2f..ffb1d0907 100644
--- a/test/routes/alerts-and-warnings.js
+++ b/test/routes/alerts-and-warnings.js
@@ -220,6 +220,35 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.headers['content-type']).to.include('text/html')
   })
 
+  lab.test('POST /alerts and warnings should have status code 200 with invalid location', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+    stubs.getFloods.callsFake(() => ({ floods: [] }))
+
+    const options = {
+      method: 'POST',
+      url: '/alerts-and-warnings',
+      payload: {
+        location: 'not-found'
+      }
+    }
+
+    const response = await server.inject(options)
+    Code.expect(response.statusCode).to.equal(200)
+  })
+
+  lab.test('GET /alerts-and-warnings should not find location', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+
+    const options = {
+      method: 'GET',
+      url: '/alerts-and-warnings/not-found'
+    }
+
+    const response = await server.inject(options)
+
+    Code.expect(response.statusCode).to.equal(404)
+  })
+
   lab.test('GET /alerts-and-warnings TYPO or non location "afdv vdaf adfv  fda" ', async () => {
     stubs.getJson.callsFake(() => data.nonLocationGetJson)
 

From 1752c4e77b432ecfb45fed23bed742785ce8c778 Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Wed, 22 May 2024 11:34:24 +0100
Subject: [PATCH 12/29] add not found location route test

---
 test/routes/alerts-and-warnings.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/test/routes/alerts-and-warnings.js b/test/routes/alerts-and-warnings.js
index ffb1d0907..1f9dfb483 100644
--- a/test/routes/alerts-and-warnings.js
+++ b/test/routes/alerts-and-warnings.js
@@ -233,7 +233,27 @@ lab.experiment('Test - /alerts-warnings', () => {
     }
 
     const response = await server.inject(options)
+
+    Code.expect(response.statusCode).to.equal(200)
+    Code.expect(response.payload).to.contain('Error: Find location - Check for flooding - GOV.UK')
+  })
+
+  lab.test('POST /alerts-and-warnings with non-england location', async () => {
+    stubs.getIsEngland.callsFake(() => ({ is_england: false }))
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+
+    const options = {
+      method: 'POST',
+      url: '/alerts-and-warnings',
+      payload: {
+        location: 'kinghorn'
+      }
+    }
+
+    const response = await server.inject(options)
+
     Code.expect(response.statusCode).to.equal(200)
+    Code.expect(response.payload).to.contain('Error: Find location - Check for flooding - GOV.UK')
   })
 
   lab.test('GET /alerts-and-warnings should not find location', async () => {

From ff76aeff029f339d9cc2d42989845920d6bc906b Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Wed, 22 May 2024 12:14:43 +0100
Subject: [PATCH 13/29] tidy up tests

---
 test/routes/alerts-and-warnings.js | 267 +++++++++++------------------
 1 file changed, 104 insertions(+), 163 deletions(-)

diff --git a/test/routes/alerts-and-warnings.js b/test/routes/alerts-and-warnings.js
index 1f9dfb483..83aeb72b5 100644
--- a/test/routes/alerts-and-warnings.js
+++ b/test/routes/alerts-and-warnings.js
@@ -74,7 +74,7 @@ lab.experiment('Test - /alerts-warnings', () => {
     delete require.cache[require.resolve('../../server/util')]
   })
 
-  lab.test('GET /alerts-and-warnings with legacy query parameters of Warrington', async () => {
+  lab.test('GET /alerts-and-warnings with legacy query parameter', async () => {
     stubs.getJson.callsFake(() => data.warringtonGetJson)
     stubs.getIsEngland.callsFake(() => ({ is_england: true }))
     stubs.getFloodsWithin.callsFake(() => ({ floods: [] }))
@@ -82,7 +82,7 @@ lab.experiment('Test - /alerts-warnings', () => {
     stubs.getImpactsWithin.callsFake(() => [])
     const options = {
       method: 'GET',
-      url: '/alerts-and-warnings?q=Warrington'
+      url: '/alerts-and-warnings?q=warrington'
     }
 
     const response = await server.inject(options)
@@ -91,22 +91,7 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.headers.location).to.equal('/alerts-and-warnings/warrington')
   })
 
-  lab.test('GET /alerts-and-warnings with location of Warrington', async () => {
-    stubs.getJson.callsFake(() => data.warringtonGetJson)
-    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
-    stubs.getFloodsWithin.callsFake(() => ({ floods: [] }))
-
-    const options = {
-      method: 'GET',
-      url: '/alerts-and-warnings/warrington'
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.statusCode).to.equal(200)
-  })
-
-  lab.test('GET /alerts-and-warnings with legacy query parameters should 404', async () => {
+  lab.test('GET /alerts-and-warnings with legacy query parameter invalid location', async () => {
     stubs.getJson.callsFake(() => data.nonLocationGetJson)
 
     const options = {
@@ -120,7 +105,7 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.headers.location).to.equal(undefined)
   })
 
-  lab.test('GET /alerts-and-warnings with legacy query parameters of WA4 1HT', async () => {
+  lab.test('GET /alerts-and-warnings with legacy query parameter postcode', async () => {
     stubs.getJson.callsFake(() => data.warringtonGetJson)
     stubs.getIsEngland.callsFake(() => ({ is_england: true }))
     stubs.getFloodsWithin.callsFake(() => data.floodsByPostCode)
@@ -136,8 +121,7 @@ lab.experiment('Test - /alerts-warnings', () => {
     // Code.expect(response.headers.location).to.equal('/alerts-and-warnings/warrington-wa4-1ht')
   })
 
-  lab.test('GET /alerts-and-warnings with legacy query parameters of England', async () => {
-    // Create dummy flood data in place of cached data
+  lab.test('GET /alerts-and-warnings with legacy query parameter england', async () => {
     stubs.getFloods.callsFake(() => ({
       floods: [
         {
@@ -169,120 +153,7 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.statusCode).to.equal(404)
   })
 
-  lab.test('POST /alerts and warnings', async () => {
-    stubs.getJson.callsFake(() => data.warringtonGetJson)
-    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
-    stubs.getFloodsWithin.callsFake(() => data.fakeFloodsData)
-
-    const options = {
-      method: 'POST',
-      url: '/alerts-and-warnings',
-      payload: {
-        location: 'Warrington'
-      }
-    }
-
-    const response = await server.inject(options)
-    Code.expect(response.statusCode).to.equal(301)
-    Code.expect(response.headers['content-type']).to.include('text/html')
-  })
-
-  lab.test('POST /alerts and warnings payload fails joi validation', async () => {
-    stubs.getJson.callsFake(() => data.nonLocationGetJson)
-
-    const options = {
-      method: 'POST',
-      url: '/alerts-and-warnings',
-      payload: {
-        river: 'Test'
-      }
-    }
-
-    const response = await server.inject(options)
-    Code.expect(response.statusCode).to.equal(302)
-    Code.expect(response.headers['content-type']).to.include('text/html')
-  })
-
-  lab.test('POST /alerts and warnings with blank location', async () => {
-    stubs.getJson.callsFake(() => data.nonLocationGetJson)
-    stubs.getFloods.callsFake(() => ({ floods: [] }))
-
-    const options = {
-      method: 'POST',
-      url: '/alerts-and-warnings',
-      payload: {
-        location: ''
-      }
-    }
-
-    const response = await server.inject(options)
-    Code.expect(response.statusCode).to.equal(200)
-    Code.expect(response.headers['content-type']).to.include('text/html')
-  })
-
-  lab.test('POST /alerts and warnings should have status code 200 with invalid location', async () => {
-    stubs.getJson.callsFake(() => data.nonLocationGetJson)
-    stubs.getFloods.callsFake(() => ({ floods: [] }))
-
-    const options = {
-      method: 'POST',
-      url: '/alerts-and-warnings',
-      payload: {
-        location: 'not-found'
-      }
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.statusCode).to.equal(200)
-    Code.expect(response.payload).to.contain('Error: Find location - Check for flooding - GOV.UK')
-  })
-
-  lab.test('POST /alerts-and-warnings with non-england location', async () => {
-    stubs.getIsEngland.callsFake(() => ({ is_england: false }))
-    stubs.getJson.callsFake(() => data.nonLocationGetJson)
-
-    const options = {
-      method: 'POST',
-      url: '/alerts-and-warnings',
-      payload: {
-        location: 'kinghorn'
-      }
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.statusCode).to.equal(200)
-    Code.expect(response.payload).to.contain('Error: Find location - Check for flooding - GOV.UK')
-  })
-
-  lab.test('GET /alerts-and-warnings should not find location', async () => {
-    stubs.getJson.callsFake(() => data.nonLocationGetJson)
-
-    const options = {
-      method: 'GET',
-      url: '/alerts-and-warnings/not-found'
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.statusCode).to.equal(404)
-  })
-
-  lab.test('GET /alerts-and-warnings TYPO or non location "afdv vdaf adfv  fda" ', async () => {
-    stubs.getJson.callsFake(() => data.nonLocationGetJson)
-
-    const options = {
-      method: 'GET',
-      url: '/alerts-and-warnings?q=wefwe%20we%20fwef%20str'
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.statusCode).to.equal(404)
-  })
-
-  lab.test('GET /alerts-and-warnings with query parameters of Kinghorn, Scotland', async () => {
+  lab.test('GET /alerts-and-warnings with legacy query parameter valid non-england', async () => {
     stubs.getIsEngland.callsFake(() => ({ is_england: false }))
     stubs.getJson.callsFake(() => data.scotlandGetJson)
     const options = {
@@ -296,12 +167,13 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.headers.location).to.equal('/alerts-and-warnings/kinghorn-fife')
   })
 
-  lab.test('GET /alerts-and-warnings location, show alert, warnings and severe', async () => {
+  lab.test('GET /alerts-and-warnings/{location} with location', async () => {
     stubs.getJson.callsFake(() => data.warringtonGetJson)
     stubs.getIsEngland.callsFake(() => ({ is_england: true }))
     stubs.getFloodsWithin.callsFake(() => data.fakeFloodsData)
     stubs.getStationsWithin.callsFake(() => [])
     stubs.getImpactsWithin.callsFake(() => [])
+
     const options = {
       method: 'GET',
       url: '/alerts-and-warnings/warrington'
@@ -309,6 +181,7 @@ lab.experiment('Test - /alerts-warnings', () => {
 
     const response = await server.inject(options)
 
+    Code.expect(response.statusCode).to.equal(200)
     Code.expect(response.payload).to.contain('1 flood warning')
     Code.expect(response.payload).to.contain('1 severe flood warning')
     Code.expect(response.payload).to.contain('3 flood alerts')
@@ -316,36 +189,35 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.payload).to.contain('<a href="/target-area/013WAFGL" class="defra-flood-warnings-list-item__title">River Glaze catchment including Leigh and East Wigan</a>')
     Code.expect(response.payload).to.contain('<a href="/target-area/013FWFCH29" class="defra-flood-warnings-list-item__title">Wider area at risk from Sankey Brook at Dallam</a>')
     Code.expect(response.payload).to.contain('<a href="/target-area/013WAFDI" class="defra-flood-warnings-list-item__title">River Ditton catchment including areas around Huyton-with-Roby and Widnes</a>')
-    Code.expect(response.statusCode).to.equal(200)
   })
 
-  lab.test('GET /alerts-and-warnings should set the canonical url', async () => {
-    stubs.getJson.callsFake(() => data.warringtonGetJson)
-    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
-    stubs.getFloodsWithin.callsFake(() => data.fakeFloodsData)
+  lab.test('GET /alerts-and-warnings/{location} with invalid location', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
 
     const options = {
       method: 'GET',
-      url: '/alerts-and-warnings/warrington?active=true'
+      url: '/alerts-and-warnings/not-found'
     }
 
     const response = await server.inject(options)
 
-    Code.expect(response.payload).to.contain('<link rel="canonical" href="http://localhost:3000/alerts-and-warnings/warrington"/>')
-    Code.expect(response.statusCode).to.equal(200)
+    Code.expect(response.statusCode).to.equal(404)
   })
 
-  lab.test('GET /alerts-and-warnings should not find location', async () => {
-    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+  lab.test('GET /alerts-and-warnings/{location} should set the canonical url', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getFloodsWithin.callsFake(() => data.fakeFloodsData)
 
     const options = {
       method: 'GET',
-      url: '/alerts-and-warnings/not-found'
+      url: '/alerts-and-warnings/warrington?active=true'
     }
 
     const response = await server.inject(options)
 
-    Code.expect(response.statusCode).to.equal(404)
+    Code.expect(response.payload).to.contain('<link rel="canonical" href="http://localhost:3000/alerts-and-warnings/warrington"/>')
+    Code.expect(response.statusCode).to.equal(200)
   })
 
   // lab.test('GET /alerts-and-warnings Bing returns error', async () => {
@@ -368,10 +240,8 @@ lab.experiment('Test - /alerts-warnings', () => {
   //   Code.expect(response.statusCode).to.equal(500)
   // })
 
-  lab.test('GET /alerts-and-warnings ', async () => {
-    stubs.getFloods.callsFake(() => ({
-      floods: []
-    }))
+  lab.test('GET /alerts-and-warnings should show default page', async () => {
+    stubs.getFloods.callsFake(() => ({ floods: [] }))
     stubs.getStationsWithin.callsFake(() => [])
     stubs.getImpactsWithin.callsFake(() => [])
     const options = {
@@ -382,9 +252,10 @@ lab.experiment('Test - /alerts-warnings', () => {
     const response = await server.inject(options)
     Code.expect(response.statusCode).to.equal(200)
     Code.expect(response.payload).to.contain('No flood alerts or warnings')
+    fullRelatedContentChecker(parse(response.payload))
   })
 
-  lab.test('GET /alerts-and-warnings?station=1001 ', async () => {
+  lab.test('GET /alerts-and-warnings should show with station', async () => {
     stubs.getFloods.callsFake(() => ({ floods: [] }))
     stubs.getStationById.callsFake(() => data.fakeGetStationById)
     stubs.getWarningsAlertsWithinStationBuffer.callsFake(() => [])
@@ -414,20 +285,90 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.statusCode).to.equal(200)
   })
 
-  lab.test('GET /alerts-and-warnings check for related content links ', async () => {
-    stubs.getFloods.callsFake(() => ({
-      floods: []
-    }))
-    stubs.getStationsWithin.callsFake(() => [])
-    stubs.getImpactsWithin.callsFake(() => [])
+  lab.test('POST /alerts-and-warnings with location payload', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getFloodsWithin.callsFake(() => data.fakeFloodsData)
+
     const options = {
-      method: 'GET',
-      url: '/alerts-and-warnings'
+      method: 'POST',
+      url: '/alerts-and-warnings',
+      payload: {
+        location: 'warrington'
+      }
+    }
+
+    const response = await server.inject(options)
+    Code.expect(response.statusCode).to.equal(301)
+    Code.expect(response.headers['content-type']).to.include('text/html')
+  })
+
+  lab.test('POST /alerts-and-warnings with invalid payload', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+
+    const options = {
+      method: 'POST',
+      url: '/alerts-and-warnings',
+      payload: {
+        river: 'Test'
+      }
+    }
+
+    const response = await server.inject(options)
+    Code.expect(response.statusCode).to.equal(302)
+    Code.expect(response.headers['content-type']).to.include('text/html')
+  })
+
+  lab.test('POST /alerts-and-warnings with empty location payload', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+    stubs.getFloods.callsFake(() => ({ floods: [] }))
+
+    const options = {
+      method: 'POST',
+      url: '/alerts-and-warnings',
+      payload: {
+        location: ''
+      }
     }
 
     const response = await server.inject(options)
     Code.expect(response.statusCode).to.equal(200)
-    Code.expect(response.payload).to.contain('No flood alerts or warnings')
-    fullRelatedContentChecker(parse(response.payload))
+    Code.expect(response.headers['content-type']).to.include('text/html')
+  })
+
+  lab.test('POST /alerts-and-warnings with invalid location payload', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+    stubs.getFloods.callsFake(() => ({ floods: [] }))
+
+    const options = {
+      method: 'POST',
+      url: '/alerts-and-warnings',
+      payload: {
+        location: 'not-found'
+      }
+    }
+
+    const response = await server.inject(options)
+
+    Code.expect(response.statusCode).to.equal(200)
+    Code.expect(response.payload).to.contain('Error: Find location - Check for flooding - GOV.UK')
+  })
+
+  lab.test('POST /alerts-and-warnings with non-england location payload', async () => {
+    stubs.getIsEngland.callsFake(() => ({ is_england: false }))
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+
+    const options = {
+      method: 'POST',
+      url: '/alerts-and-warnings',
+      payload: {
+        location: 'kinghorn'
+      }
+    }
+
+    const response = await server.inject(options)
+
+    Code.expect(response.statusCode).to.equal(200)
+    Code.expect(response.payload).to.contain('Error: Find location - Check for flooding - GOV.UK')
   })
 })

From 1f7223491889db95fe60205da3f2e54acee1bbf4 Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Wed, 22 May 2024 12:21:45 +0100
Subject: [PATCH 14/29] remove unused query param option

---
 server/routes/alerts-and-warnings.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/server/routes/alerts-and-warnings.js b/server/routes/alerts-and-warnings.js
index c9e36e4a6..e366e2de4 100644
--- a/server/routes/alerts-and-warnings.js
+++ b/server/routes/alerts-and-warnings.js
@@ -25,7 +25,7 @@ function createQueryParametersString (queryObject) {
 }
 
 async function routeHandler (request, h) {
-  let location = request.query.q || request.query.location || request.payload?.location
+  let location = request.query.q || request.payload?.location
 
   request.yar.set('q', { location })
 
@@ -115,7 +115,7 @@ function failActionHandler (request, h) {
     situation: 'Location search error: Invalid or no string input.'
   })
 
-  const location = request.query.q || request.query.location || request.payload?.location
+  const location = request.query.q || request.payload?.location
 
   if (!location) {
     return h.redirect(page).takeover()

From 2bcece72ae27092cfb5d21bbbadffe0e2bc95687 Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Wed, 22 May 2024 12:28:37 +0100
Subject: [PATCH 15/29] add test for /england

---
 test/routes/alerts-and-warnings.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/test/routes/alerts-and-warnings.js b/test/routes/alerts-and-warnings.js
index 83aeb72b5..34c24da88 100644
--- a/test/routes/alerts-and-warnings.js
+++ b/test/routes/alerts-and-warnings.js
@@ -220,6 +220,22 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.statusCode).to.equal(200)
   })
 
+  lab.test('GET /alerts-and-warnings/{location} with england should redirect to default page', async () => {
+    stubs.getJson.callsFake(() => ({ floods: [] }))
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getOutlook.callsFake(() => outlookData.statements[0])
+
+    const options = {
+      method: 'GET',
+      url: '/alerts-and-warnings/england'
+    }
+
+    const response = await server.inject(options)
+
+    Code.expect(response.statusCode).to.equal(302)
+    Code.expect(response.headers.location).to.equal('/alerts-and-warnings')
+  })
+
   // lab.test('GET /alerts-and-warnings Bing returns error', async () => {
   //   // stubs.getJson.callsFake(() => { throw new Error('Bing error') })
   //   // stubs.getJson.callsFake(() => data.warringtonGetJson)

From 1f587ebd56bbd0aa3a6f9aafdafe16bf97315257 Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Wed, 22 May 2024 12:42:56 +0100
Subject: [PATCH 16/29] test tidy

---
 server/routes/alerts-and-warnings.js |  6 +-----
 test/routes/alerts-and-warnings.js   | 14 ++++++++++++++
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/server/routes/alerts-and-warnings.js b/server/routes/alerts-and-warnings.js
index e366e2de4..5bbccd591 100644
--- a/server/routes/alerts-and-warnings.js
+++ b/server/routes/alerts-and-warnings.js
@@ -95,11 +95,7 @@ async function locationRouteHandler (request, h) {
       situation: 'Location search error: Valid response but location not in England.'
     })
 
-    if (request.method === 'get') {
-      return renderNotFound(location)
-    } else {
-      return renderLocationNotFound(location, h)
-    }
+    return renderNotFound(location)
   }
 
   // Data passed to floods model so the schema is the same as cached floods
diff --git a/test/routes/alerts-and-warnings.js b/test/routes/alerts-and-warnings.js
index 34c24da88..76ea5167e 100644
--- a/test/routes/alerts-and-warnings.js
+++ b/test/routes/alerts-and-warnings.js
@@ -236,6 +236,20 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.headers.location).to.equal('/alerts-and-warnings')
   })
 
+  lab.test('GET /alerts-and-warnings/{location} with valid non-england location', async () => {
+    stubs.getIsEngland.callsFake(() => ({ is_england: false }))
+    stubs.getJson.callsFake(() => data.scotlandGetJson)
+
+    const options = {
+      method: 'GET',
+      url: '/alerts-and-warnings/kinghorn-fife'
+    }
+
+    const response = await server.inject(options)
+
+    Code.expect(response.statusCode).to.equal(404)
+  })
+
   // lab.test('GET /alerts-and-warnings Bing returns error', async () => {
   //   // stubs.getJson.callsFake(() => { throw new Error('Bing error') })
   //   // stubs.getJson.callsFake(() => data.warringtonGetJson)

From eba3bfc4fa7ed024089c4931089440c4bb47fbfa Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Thu, 23 May 2024 09:56:05 +0100
Subject: [PATCH 17/29] test coverage for failAction

---
 test/routes/alerts-and-warnings.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/test/routes/alerts-and-warnings.js b/test/routes/alerts-and-warnings.js
index 76ea5167e..bd06df093 100644
--- a/test/routes/alerts-and-warnings.js
+++ b/test/routes/alerts-and-warnings.js
@@ -366,6 +366,36 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.headers['content-type']).to.include('text/html')
   })
 
+  lab.test('POST /alerts-and-warnings with no location payload', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+    stubs.getFloods.callsFake(() => ({ floods: [] }))
+
+    const options = {
+      method: 'POST',
+      url: '/alerts-and-warnings'
+    }
+
+    const response = await server.inject(options)
+    Code.expect(response.statusCode).to.equal(302)
+  })
+
+  lab.test('POST /alerts-and-warnings with location payload length exceeds limit', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+    stubs.getFloods.callsFake(() => ({ floods: [] }))
+
+    const options = {
+      method: 'POST',
+      url: '/alerts-and-warnings',
+      payload: {
+        location: new Array(201).join('x')
+      }
+    }
+
+    const response = await server.inject(options)
+    Code.expect(response.statusCode).to.equal(200)
+    Code.expect(response.payload).to.contain('Error: Find location - Check for flooding - GOV.UK')
+  })
+
   lab.test('POST /alerts-and-warnings with invalid location payload', async () => {
     stubs.getJson.callsFake(() => data.nonLocationGetJson)
     stubs.getFloods.callsFake(() => ({ floods: [] }))

From 7e0142c8e98a17d2d8bd7e8a19a6b4d36ed10406 Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Fri, 7 Jun 2024 11:32:57 +0100
Subject: [PATCH 18/29] FSR-1207 | remove commented out code

---
 test/routes/alerts-and-warnings.js | 21 ---------------------
 1 file changed, 21 deletions(-)

diff --git a/test/routes/alerts-and-warnings.js b/test/routes/alerts-and-warnings.js
index bd06df093..178b0ec60 100644
--- a/test/routes/alerts-and-warnings.js
+++ b/test/routes/alerts-and-warnings.js
@@ -118,7 +118,6 @@ lab.experiment('Test - /alerts-warnings', () => {
     const response = await server.inject(options)
 
     Code.expect(response.statusCode).to.equal(301)
-    // Code.expect(response.headers.location).to.equal('/alerts-and-warnings/warrington-wa4-1ht')
   })
 
   lab.test('GET /alerts-and-warnings with legacy query parameter england', async () => {
@@ -250,26 +249,6 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.statusCode).to.equal(404)
   })
 
-  // lab.test('GET /alerts-and-warnings Bing returns error', async () => {
-  //   // stubs.getJson.callsFake(() => { throw new Error('Bing error') })
-  //   // stubs.getJson.callsFake(() => data.warringtonGetJson)
-  //   // stubs.getFloodsWithin.callsFake(() => ({ floods: [] }))
-  //   stubs.getJson.callsFake(() => data.warringtonGetJson)
-  //   stubs.getIsEngland.callsFake(() => ({ is_england: true }))
-  //   stubs.getFloodsWithin.callsFake(() => data.fakeFloodsData)
-
-  //   const options = {
-  //     method: 'GET',
-  //     url: '/alerts-and-warnings'
-  //   }
-
-  //   const response = await server.inject(options)
-
-  //   Code.expect(response.payload).to.contain('Sorry, there is currently a problem searching a location - GOV.UK')
-  //   Code.expect(response.payload).to.contain('Sorry, there is currently a problem searching a location')
-  //   Code.expect(response.statusCode).to.equal(500)
-  // })
-
   lab.test('GET /alerts-and-warnings should show default page', async () => {
     stubs.getFloods.callsFake(() => ({ floods: [] }))
     stubs.getStationsWithin.callsFake(() => [])

From b2bb1e27859db9baf8d1f2ce6c15b6835eaf37c6 Mon Sep 17 00:00:00 2001
From: nikiwycherley <niki.wycherley@environment-agency.gov.uk>
Date: Wed, 19 Jun 2024 10:56:09 +0100
Subject: [PATCH 19/29] Add support for 'religiousstructure' type in
 bingResultsParser

---
 server/services/lib/bing-results-parser.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/services/lib/bing-results-parser.js b/server/services/lib/bing-results-parser.js
index 6f6f7ad55..6112102dc 100644
--- a/server/services/lib/bing-results-parser.js
+++ b/server/services/lib/bing-results-parser.js
@@ -8,7 +8,7 @@ async function bingResultsParser (bingData, getIsEngland) {
 
   const allowedConfidences = ['medium', 'high']
   const allowedTypes = [
-    'populatedplace', 'postcode1', 'postcode3', 'admindivision2', 'neighborhood'
+    'populatedplace', 'postcode1', 'postcode3', 'admindivision2', 'neighborhood', 'religiousstructure'
   ]
   const data = set.resources
     .filter(r => allowedConfidences.includes(r.confidence.toLowerCase()))

From 7c510be86e06743a3a0cf8816e72bdd5ee23a228 Mon Sep 17 00:00:00 2001
From: nikiwycherley <niki.wycherley@environment-agency.gov.uk>
Date: Wed, 19 Jun 2024 13:32:49 +0100
Subject: [PATCH 20/29] Add support for 'roadblock' type in bingResultsParser

---
 server/services/lib/bing-results-parser.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/services/lib/bing-results-parser.js b/server/services/lib/bing-results-parser.js
index 6112102dc..441023941 100644
--- a/server/services/lib/bing-results-parser.js
+++ b/server/services/lib/bing-results-parser.js
@@ -8,7 +8,7 @@ async function bingResultsParser (bingData, getIsEngland) {
 
   const allowedConfidences = ['medium', 'high']
   const allowedTypes = [
-    'populatedplace', 'postcode1', 'postcode3', 'admindivision2', 'neighborhood', 'religiousstructure'
+    'populatedplace', 'postcode1', 'postcode3', 'admindivision2', 'neighborhood', 'religiousstructure', 'roadblock'
   ]
   const data = set.resources
     .filter(r => allowedConfidences.includes(r.confidence.toLowerCase()))

From 23a382853f4cc2d1618d2aa1e63ee66a311f44aa Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Mon, 24 Jun 2024 15:47:54 +0100
Subject: [PATCH 21/29] FSR-1207 | update page title to use place name

---
 server/models/views/alerts-and-warnings.js | 4 +++-
 test/models/alerts-and-warnings.js         | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/server/models/views/alerts-and-warnings.js b/server/models/views/alerts-and-warnings.js
index aa03914bc..a053bdf55 100644
--- a/server/models/views/alerts-and-warnings.js
+++ b/server/models/views/alerts-and-warnings.js
@@ -21,13 +21,15 @@ class ViewModel {
       floodRiskUrl: config.floodRiskUrl
     })
 
+    const pageTitle = place?.name ?? location
+
     if (error) {
       this.pageTitle = 'Sorry, there is currently a problem searching a location'
     } else {
       if (this.station && this.station.agency_name) {
         this.pageTitle = `${this.station.agency_name} - flood alerts and warnings`
       } else {
-        this.pageTitle = `${location ? location + ' - f' : 'F'}lood alerts and warnings`
+        this.pageTitle = `${pageTitle ? pageTitle + ' - f' : 'F'}lood alerts and warnings`
       }
     }
     this.countFloods = floods?.floods?.length ?? 0
diff --git a/test/models/alerts-and-warnings.js b/test/models/alerts-and-warnings.js
index 3ace48a52..11b371960 100644
--- a/test/models/alerts-and-warnings.js
+++ b/test/models/alerts-and-warnings.js
@@ -27,7 +27,7 @@ lab.test('Test exposed data placeBox is blank if not a place in England', async
   const Result = await new ViewModel({ location, place, floods, station })
 
   Code.expect(Result.expose.placeBbox.length).to.equal(0)
-  Code.expect(Result.pageTitle).to.equal('Flood alerts and warnings')
+  Code.expect(Result.pageTitle).to.equal('Kinghorn - flood alerts and warnings')
 })
 
 lab.test('Test count floods function returns correct number of floods', async () => {

From 7d294bd17b690f272f4a386111495106ef04ba51 Mon Sep 17 00:00:00 2001
From: Ash <ashley@digicodeltd.com>
Date: Tue, 25 Jun 2024 12:51:02 +0100
Subject: [PATCH 22/29] sonar fix

---
 server/models/views/alerts-and-warnings.js | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/server/models/views/alerts-and-warnings.js b/server/models/views/alerts-and-warnings.js
index a053bdf55..0a109a20f 100644
--- a/server/models/views/alerts-and-warnings.js
+++ b/server/models/views/alerts-and-warnings.js
@@ -21,17 +21,18 @@ class ViewModel {
       floodRiskUrl: config.floodRiskUrl
     })
 
-    const pageTitle = place?.name ?? location
+    if (this.station && this.station.agency_name) {
+      this.pageTitle = `${this.station.agency_name} - flood alerts and warnings`
+    } else {
+      const pageTitle = place?.name ?? location
+
+      this.pageTitle = `${pageTitle ? pageTitle + ' - f' : 'F'}lood alerts and warnings`
+    }
 
     if (error) {
       this.pageTitle = 'Sorry, there is currently a problem searching a location'
-    } else {
-      if (this.station && this.station.agency_name) {
-        this.pageTitle = `${this.station.agency_name} - flood alerts and warnings`
-      } else {
-        this.pageTitle = `${pageTitle ? pageTitle + ' - f' : 'F'}lood alerts and warnings`
-      }
     }
+
     this.countFloods = floods?.floods?.length ?? 0
     this.floods = floods?.groups?.map(item => item)
 

From 59fac26b89ed9b3f727caaf43ac29317862213a9 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 27 Jun 2024 13:39:38 +0100
Subject: [PATCH 23/29] Bump node-html-parser from 6.1.12 to 6.1.13 (#658)

Bumps [node-html-parser](https://github.com/taoqf/node-fast-html-parser) from 6.1.12 to 6.1.13.
- [Release notes](https://github.com/taoqf/node-fast-html-parser/releases)
- [Changelog](https://github.com/taoqf/node-html-parser/blob/main/CHANGELOG.md)
- [Commits](https://github.com/taoqf/node-fast-html-parser/compare/v6.1.12...v6.1.13)

---
updated-dependencies:
- dependency-name: node-html-parser
  dependency-type: direct:development
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 package-lock.json | 8 ++++----
 package.json      | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index cd1faabe0..1a4c5d737 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -72,7 +72,7 @@
         "husky": "^8.0.3",
         "jsdom": "^22.1.0",
         "mockdate": "^3.0.5",
-        "node-html-parser": "^6.1.11",
+        "node-html-parser": "^6.1.13",
         "nodemon": "^3.0.1",
         "proxyquire": "^2.1.3"
       },
@@ -8791,9 +8791,9 @@
       }
     },
     "node_modules/node-html-parser": {
-      "version": "6.1.12",
-      "resolved": "https://registry.npmjs.org/node-html-parser/-/node-html-parser-6.1.12.tgz",
-      "integrity": "sha512-/bT/Ncmv+fbMGX96XG9g05vFt43m/+SYKIs9oAemQVYyVcZmDAI2Xq/SbNcpOA35eF0Zk2av3Ksf+Xk8Vt8abA==",
+      "version": "6.1.13",
+      "resolved": "https://registry.npmjs.org/node-html-parser/-/node-html-parser-6.1.13.tgz",
+      "integrity": "sha512-qIsTMOY4C/dAa5Q5vsobRpOOvPfC4pB61UVW2uSwZNUp0QU/jCekTal1vMmbO0DgdHeLUJpv/ARmDqErVxA3Sg==",
       "dev": true,
       "dependencies": {
         "css-select": "^5.1.0",
diff --git a/package.json b/package.json
index b65dcce5f..d157f917b 100644
--- a/package.json
+++ b/package.json
@@ -96,7 +96,7 @@
     "husky": "^8.0.3",
     "jsdom": "^22.1.0",
     "mockdate": "^3.0.5",
-    "node-html-parser": "^6.1.11",
+    "node-html-parser": "^6.1.13",
     "nodemon": "^3.0.1",
     "proxyquire": "^2.1.3"
   }

From 7f278b36c5bbf3d1d79418063ead2bc64fdf1d23 Mon Sep 17 00:00:00 2001
From: Ash <ashleyjtaylor@users.noreply.github.com>
Date: Thu, 11 Jul 2024 13:27:31 +0100
Subject: [PATCH 24/29] FSR-1208 | river and sea levels search redirects (#723)

* FSR-1208 | river and sea levels search redirects

* FSR-1208 | river and sea levels search redirects

* sonar fixes 1

* sonar fixes 2

* sonar fixes 3

* move duplicate functions to lib/utils

* sonar fix

* sonar fixes

* sonar fix undo

* add util funcitons

* remove commented code

* remove locationHandler fn

* Refactor locationRouteHandler in river-and-sea-levels.js

* Refactor locationRouteHandler else clause

* remove comment and use util func

* redirect on non-england locations

* remove uneeded test

* add fakeGetJson to test

* sonar fix

* fix response behaviour

* fix single character search result

* remove flakey test

* refactored tests to be inline with alerts-and-warnings

* test coverage

* typo

* test coverage

* add script encode test

---------

Co-authored-by: Ash <ashley@digicodeltd.com>
Co-authored-by: nikiwycherley <niki.wycherley@environment-agency.gov.uk>
---
 server/models/views/river-and-sea-levels.js |   12 +-
 server/routes/alerts-and-warnings.js        |   93 +-
 server/routes/lib/utils.js                  |   52 +-
 server/routes/river-and-sea-levels.js       |  181 +-
 test/routes/alerts-and-warnings.js          |   37 +-
 test/routes/river-and-sea-levels.js         | 2856 ++++---------------
 6 files changed, 784 insertions(+), 2447 deletions(-)

diff --git a/server/models/views/river-and-sea-levels.js b/server/models/views/river-and-sea-levels.js
index dc100de3b..6579a4437 100644
--- a/server/models/views/river-and-sea-levels.js
+++ b/server/models/views/river-and-sea-levels.js
@@ -112,7 +112,7 @@ function referencedStationViewModel (referencePoint, stations) {
   }
 }
 
-function placeViewModel ({ location, place, stations = [], queryGroup }) {
+function placeViewModel ({ location, place, stations = [], queryGroup, canonical, q }) {
   let distStatement, title, description
 
   const isEngland = place ? place.isEngland.is_england : true
@@ -128,10 +128,10 @@ function placeViewModel ({ location, place, stations = [], queryGroup }) {
   deleteUndefinedProperties(stations)
 
   if (location && isEngland) {
-    title = `${location} - ${pageTitle}`
+    title = `${place.name ?? location} - ${pageTitle}`
     description = `Find river, sea, groundwater and rainfall levels in ${location}. Check the last updated height, trend and state recorded by the measuring station.`
   } else {
-    title = location ? `${location} - ${pageTitle}` : pageTitle
+    title = place ? `${place.name} - ${pageTitle}` : pageTitle
     description = metaDescription
   }
 
@@ -141,13 +141,15 @@ function placeViewModel ({ location, place, stations = [], queryGroup }) {
     filters,
     floodRiskUrl,
     distStatement,
-    q: location,
+    q: q || location,
     clientModel: getClientModel(isEngland ? place.bbox10k : []),
     queryGroup: activeFilter,
     placeAddress: place.address,
     ...getDataJourneyClickStrings(),
     pageTitle: title,
-    metaDescription: description
+    metaDescription: description,
+    metaCanonical: canonical,
+    canonicalUrl: canonical
   }
 }
 
diff --git a/server/routes/alerts-and-warnings.js b/server/routes/alerts-and-warnings.js
index 5bbccd591..66557dc37 100644
--- a/server/routes/alerts-and-warnings.js
+++ b/server/routes/alerts-and-warnings.js
@@ -1,32 +1,27 @@
-const qs = require('qs')
 const joi = require('@hapi/joi')
-const boom = require('@hapi/boom')
 const ViewModel = require('../models/views/alerts-and-warnings')
 const Floods = require('../models/floods')
 const locationService = require('../services/location')
 const util = require('../util')
-const { slugify } = require('./lib/utils')
-
-const page = 'alerts-and-warnings'
+const {
+  slugify,
+  isLocationEngland,
+  isValidLocationSlug,
+  isPlaceEngland,
+  failActionHandler,
+  renderNotFound,
+  renderLocationNotFound,
+  createQueryParametersString
+} = require('./lib/utils')
+
+const route = 'alerts-and-warnings'
 const QUERY_STRING_LOCATION_MAX_LENGTH = 200
 
-function renderLocationNotFound (location, h) {
-  return h.view('location-not-found', { pageTitle: 'Error: Find location - Check for flooding', href: page, location }).takeover()
-}
-
-function renderNotFound (location) {
-  return boom.notFound(`Location ${location} not found`)
-}
-
-function createQueryParametersString (queryObject) {
-  const { q, location, ...otherParameters } = queryObject
-  const queryString = qs.stringify(otherParameters, { addQueryPrefix: true, encode: false })
-  return queryString
-}
-
 async function routeHandler (request, h) {
   let location = request.query.q || request.payload?.location
 
+  location = util.cleanseLocation(location)
+
   request.yar.set('q', { location })
 
   const direction = request.query.direction === 'downstream' ? 'd' : 'u'
@@ -35,21 +30,23 @@ async function routeHandler (request, h) {
 
   if (request.query.station) {
     const station = await request.server.methods.flood.getStationById(request.query.station, direction)
-
     const warningsAlerts = await request.server.methods.flood.getWarningsAlertsWithinStationBuffer(station.rloi_id)
+
     floods = new Floods({ floods: warningsAlerts })
     model = new ViewModel({ location, floods, station })
-    return h.view(page, { model })
+    return h.view(route, { model })
   }
 
   if (!location) {
     const data = await request.server.methods.flood.getFloods()
     floods = new Floods(data)
     model = new ViewModel({ location, floods })
-    return h.view(page, { model })
+    return h.view(route, { model })
   }
 
-  location = util.cleanseLocation(location)
+  if (isLocationEngland(location)) {
+    return h.redirect(`/${route}`)
+  }
 
   const [place] = await locationService.find(location)
 
@@ -58,22 +55,22 @@ async function routeHandler (request, h) {
       return renderNotFound(location)
     }
 
-    return renderLocationNotFound(location, h)
+    return renderLocationNotFound(route, location, h)
   }
 
-  if (!place.isEngland.is_england) {
+  if (!isPlaceEngland(place)) {
     request.logger.warn({
       situation: 'Location search error: Valid response but location not in England.'
     })
 
     if (request.method === 'post') {
-      return renderLocationNotFound(location, h)
+      return renderLocationNotFound(route, location, h)
     }
   }
 
   const queryString = createQueryParametersString(request.query)
 
-  return h.redirect(`/${page}/${slugify(place?.name)}${queryString}`).permanent()
+  return h.redirect(`/${route}/${slugify(place?.name)}${queryString}`).permanent()
 }
 
 async function locationRouteHandler (request, h) {
@@ -82,15 +79,15 @@ async function locationRouteHandler (request, h) {
 
   const [place] = await locationService.find(location)
 
-  if (location.match(/^england$/i)) {
-    return h.redirect(`/${page}`)
+  if (isLocationEngland(location)) {
+    return h.redirect(`/${route}`)
   }
 
-  if (slugify(place?.name) !== location) {
+  if (!isValidLocationSlug(location, place)) {
     return renderNotFound(location)
   }
 
-  if (!place?.isEngland.is_england) {
+  if (!isPlaceEngland(place)) {
     request.logger.warn({
       situation: 'Location search error: Valid response but location not in England.'
     })
@@ -103,26 +100,12 @@ async function locationRouteHandler (request, h) {
   const floods = new Floods(data)
   const model = new ViewModel({ location, place, floods, canonical: canonicalUrl, q: request.yar.get('q')?.location })
   request.yar.set('q', null)
-  return h.view(page, { model })
-}
-
-function failActionHandler (request, h) {
-  request.logger.warn({
-    situation: 'Location search error: Invalid or no string input.'
-  })
-
-  const location = request.query.q || request.payload?.location
-
-  if (!location) {
-    return h.redirect(page).takeover()
-  } else {
-    return renderLocationNotFound(location, h)
-  }
+  return h.view(route, { model })
 }
 
 module.exports = [{
   method: 'GET',
-  path: `/${page}`,
+  path: `/${route}`,
   handler: routeHandler,
   options: {
     validate: {
@@ -135,13 +118,13 @@ module.exports = [{
         lyr: joi.string(),
         v: joi.string()
       }),
-      failAction: failActionHandler
+      failAction: (request, h) => failActionHandler(request, h, route)
     }
   }
 },
 {
   method: 'GET',
-  path: `/${page}/{location}`,
+  path: `/${route}/{location}`,
   handler: locationRouteHandler,
   options: {
     validate: {
@@ -156,20 +139,24 @@ module.exports = [{
         lyr: joi.string(),
         v: joi.string()
       }),
-      failAction: failActionHandler
+      failAction: (request, h) => failActionHandler(request, h, route)
     }
   }
 },
 {
   method: 'POST',
-  path: `/${page}`,
+  path: `/${route}`,
   handler: routeHandler,
   options: {
     validate: {
       payload: joi.object({
-        location: joi.string().allow('').trim().max(QUERY_STRING_LOCATION_MAX_LENGTH).required()
+        location: joi.string()
+          .allow('')
+          .trim()
+          .max(QUERY_STRING_LOCATION_MAX_LENGTH)
+          .required()
       }),
-      failAction: failActionHandler
+      failAction: (request, h) => failActionHandler(request, h, route)
     }
   }
 }]
diff --git a/server/routes/lib/utils.js b/server/routes/lib/utils.js
index 0fb99ff6b..5dac60f57 100644
--- a/server/routes/lib/utils.js
+++ b/server/routes/lib/utils.js
@@ -1,7 +1,57 @@
+const qs = require('qs')
+const boom = require('@hapi/boom')
+
 function slugify (text = '') {
   return text.replace(/,/g, '').replace(/ /g, '-').toLowerCase()
 }
 
+function isLocationEngland (location) {
+  return location.match(/^england$/i)
+}
+
+function isPlaceEngland (place) {
+  return place?.isEngland.is_england
+}
+
+function isValidLocationSlug (location, place) {
+  return slugify(place?.name) === location
+}
+
+function createQueryParametersString (queryObject) {
+  const { q, location, ...otherParameters } = queryObject
+  const queryString = qs.stringify(otherParameters, { addQueryPrefix: true, encode: false })
+  return queryString
+}
+
+function renderLocationNotFound (href, location, h) {
+  return h.view('location-not-found', { pageTitle: 'Error: Find location - Check for flooding', href, location }).takeover()
+}
+
+function renderNotFound (location) {
+  return boom.notFound(`Location ${location} not found`)
+}
+
+function failActionHandler (request, h, page) {
+  request.logger.warn({
+    situation: 'Location search error: Invalid or no string input.'
+  })
+
+  const location = request.query.q || request.payload?.location
+
+  if (!location) {
+    return h.redirect(page).takeover()
+  } else {
+    return renderLocationNotFound(page, location, h)
+  }
+}
+
 module.exports = {
-  slugify
+  slugify,
+  failActionHandler,
+  isLocationEngland,
+  isPlaceEngland,
+  isValidLocationSlug,
+  renderNotFound,
+  renderLocationNotFound,
+  createQueryParametersString
 }
diff --git a/server/routes/river-and-sea-levels.js b/server/routes/river-and-sea-levels.js
index 6c0dff8d3..46af2b90e 100644
--- a/server/routes/river-and-sea-levels.js
+++ b/server/routes/river-and-sea-levels.js
@@ -12,14 +12,109 @@ const {
 } = require('../models/views/river-and-sea-levels')
 const locationService = require('../services/location')
 const util = require('../util')
+const {
+  slugify,
+  failActionHandler,
+  renderNotFound,
+  renderLocationNotFound,
+  createQueryParametersString,
+  isValidLocationSlug,
+  isLocationEngland,
+  isPlaceEngland
+} = require('./lib/utils')
 
 const route = 'river-and-sea-levels'
+const QUERY_STRING_LOCATION_MAX_LENGTH = 200
 
 const miles = 1609.344
 const joiValidationQMax = 200
 const joiValidationGroupMax = 11
 const joiValidationSearchTypeMax = 11
 
+async function locationRouteHandler (request, h) {
+  const referer = request.headers.referer
+  const queryGroup = request.query.group
+
+  const canonicalUrl = request.url.origin + request.url.pathname
+  const location = util.cleanseLocation(request.params.location)
+
+  const [place] = await locationService.find(location)
+
+  if (isLocationEngland(location)) {
+    return h.redirect(`/${route}`)
+  } else if (!isValidLocationSlug(location, place)) {
+    return renderNotFound(location)
+  } else if (!isPlaceEngland(place)) {
+    request.logger.warn({
+      situation: 'Location search error: Valid response but location not in England.'
+    })
+    return renderNotFound(location)
+  } else {
+    const stations = await request.server.methods.flood.getStationsWithin(place.bbox10k)
+    const model = placeViewModel({ location, place, stations, referer, queryGroup, canonical: canonicalUrl, q: request.yar.get('q')?.location })
+    request.yar.set('q', null)
+    return h.view(route, { model })
+  }
+}
+
+async function locationQueryHandler (request, h) {
+  let location = request.query.q || request.payload?.location
+
+  location = util.cleanseLocation(location)
+
+  request.yar.set('q', { location })
+
+  if (!location) {
+    return h.view(route, { model: emptyResultsModel() })
+  }
+
+  if (isLocationEngland(location)) {
+    return h.redirect(`/${route}`)
+  }
+
+  const rivers = await request.server.methods.flood.getRiversByName(location)
+  const places = await findPlaces(location)
+
+  if (places.length + rivers.length > 1) {
+    return h.view(`${route}-list`, { model: disambiguationModel(location, places, rivers) })
+  }
+
+  if (places.length === 0) {
+    if (rivers.length === 0) {
+      if (request.method === 'get') {
+        return renderNotFound(location)
+      }
+
+      return renderLocationNotFound(route, location, h)
+    }
+
+    return h.redirect(`/${route}/river/${rivers[0].id}`)
+  }
+
+  const place = places[0]
+
+  if (!isPlaceEngland(place)) {
+    request.logger.warn({
+      situation: 'Location search error: Valid response but location not in England.'
+    })
+
+    if (request.method === 'post') {
+      return renderLocationNotFound(route, location, h)
+    }
+  }
+
+  const queryString = createQueryParametersString(request.query)
+
+  return h.redirect(`/${route}/${slugify(place?.name)}${queryString}`).permanent()
+}
+
+async function findPlaces (location) {
+  // NOTE: at the moment locationService.find just returns a single place
+  // using the [] for no results and with a nod to upcoming work to return >1 result
+  const [place] = await locationService.find(location)
+  return place ? [place] : []
+}
+
 module.exports = [{
   method: 'GET',
   path: `/${route}/target-area/{targetAreaCode}`,
@@ -134,82 +229,48 @@ module.exports = [{
         q: joi.string().trim().max(joiValidationQMax),
         group: joi.string().trim().max(joiValidationGroupMax),
         searchType: joi.string().trim().max(joiValidationSearchTypeMax),
-        includeTypes: joi.string().default('place,river'),
         'rloi-id': joi.string(),
         'rainfall-id': joi.string(),
         'target-area': joi.string(),
         riverId: joi.string()
       }),
-      failAction: (request, h) => {
-        request.logger.warn({
-          situation: 'River and Sea levels search error: Invalid or no string input.'
-        })
-
-        return h.redirect()
-      }
+      failAction: (request, h) => failActionHandler(request, h, route)
+    }
+  }
+}, {
+  method: 'GET',
+  path: `/${route}/{location}`,
+  handler: locationRouteHandler,
+  options: {
+    validate: {
+      params: joi.object({
+        location: joi.string().lowercase()
+      }),
+      query: joi.object({
+        group: joi.string().trim().max(joiValidationGroupMax),
+        searchType: joi.string().trim().max(joiValidationSearchTypeMax),
+        'rloi-id': joi.string(),
+        'rainfall-id': joi.string(),
+        'target-area': joi.string(),
+        riverId: joi.string()
+      }),
+      failAction: (request, h) => failActionHandler(request, h, route)
     }
   }
 }, {
   method: 'POST',
   path: `/${route}`,
-  handler: async (request, h) => {
-    const { location } = request.payload
-    return h.redirect(`/${route}?q=${encodeURIComponent(location)}`).takeover()
-  },
+  handler: locationQueryHandler,
   options: {
     validate: {
       payload: joi.object({
         location: joi.string()
+          .allow('')
           .trim()
-          .regex(new RegExp(`^[${util.ALLOWED_SEARCH_CHARS}]*$`)).required()
+          .max(QUERY_STRING_LOCATION_MAX_LENGTH)
+          .required()
       }),
-      failAction: (_request, h, _err) => h.view(route, { model: emptyResultsModel(_request.payload?.location.trim()) }).takeover()
+      failAction: (request, h) => failActionHandler(request, h, route)
     }
   }
 }]
-
-async function locationQueryHandler (request, h) {
-  const location = request.query.q
-  const referer = request.headers.referer
-  const includeTypes = request.query.includeTypes.split(',')
-  const queryGroup = request.query.group
-
-  let rivers = []
-  let places = []
-  const cleanLocation = util.cleanseLocation(location)
-  if (cleanLocation && cleanLocation.length > 1 && !cleanLocation.match(/^england$/i)) {
-    if (includeTypes.includes('place')) {
-      places = await findPlaces(cleanLocation)
-    }
-    if (includeTypes.includes('river')) {
-      rivers = await request.server.methods.flood.getRiversByName(cleanLocation)
-    }
-  }
-
-  if (places.length === 0) {
-    if (rivers.length === 0) {
-      return h.view(route, { model: emptyResultsModel(location) })
-    }
-    if (rivers.length === 1) {
-      return h.redirect(`/${route}/river/${rivers[0].id}`)
-    }
-  }
-
-  if (places.length + rivers.length > 1) {
-    return h.view(`${route}-list`, { model: disambiguationModel(location, places, rivers) })
-  }
-
-  const place = places[0]
-  const stations = await request.server.methods.flood.getStationsWithin(place.bbox10k)
-  const model = placeViewModel({ location, place, stations, referer, queryGroup })
-  return h.view(route, { model })
-}
-
-const inUk = place => place?.isUK && !place?.isScotlandOrNorthernIreland
-
-async function findPlaces (location) {
-  // NOTE: at the moment locationService.find just returns a single place
-  // using the [] for no results and with a nod to upcoming work to return >1 result
-  const [place] = await locationService.find(location)
-  return inUk(place) ? [place] : []
-}
diff --git a/test/routes/alerts-and-warnings.js b/test/routes/alerts-and-warnings.js
index 178b0ec60..d504aa015 100644
--- a/test/routes/alerts-and-warnings.js
+++ b/test/routes/alerts-and-warnings.js
@@ -149,7 +149,8 @@ lab.experiment('Test - /alerts-warnings', () => {
 
     const response = await server.inject(options)
 
-    Code.expect(response.statusCode).to.equal(404)
+    Code.expect(response.statusCode).to.equal(302)
+    Code.expect(response.headers.location).to.equal('/alerts-and-warnings')
   })
 
   lab.test('GET /alerts-and-warnings with legacy query parameter valid non-england', async () => {
@@ -166,6 +167,22 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.headers.location).to.equal('/alerts-and-warnings/kinghorn-fife')
   })
 
+  lab.test('GET /alerts-and-warnings with legacy query parameter invalid characters', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getFloodsWithin.callsFake(() => ({ floods: [] }))
+
+    const options = {
+      method: 'GET',
+      url: '/alerts-and-warnings?q=warrington%*_'
+    }
+
+    const response = await server.inject(options)
+
+    Code.expect(response.statusCode).to.equal(301)
+    Code.expect(response.headers.location).to.equal('/alerts-and-warnings/warrington')
+  })
+
   lab.test('GET /alerts-and-warnings/{location} with location', async () => {
     stubs.getJson.callsFake(() => data.warringtonGetJson)
     stubs.getIsEngland.callsFake(() => ({ is_england: true }))
@@ -312,6 +329,24 @@ lab.experiment('Test - /alerts-warnings', () => {
     Code.expect(response.headers['content-type']).to.include('text/html')
   })
 
+  lab.test('POST /alerts-and-warnings with location england should show location not found', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getFloodsWithin.callsFake(() => [])
+
+    const options = {
+      method: 'POST',
+      url: '/alerts-and-warnings',
+      payload: {
+        location: 'england'
+      }
+    }
+
+    const response = await server.inject(options)
+    Code.expect(response.statusCode).to.equal(302)
+    Code.expect(response.headers.location).to.equal('/alerts-and-warnings')
+  })
+
   lab.test('POST /alerts-and-warnings with invalid payload', async () => {
     stubs.getJson.callsFake(() => data.nonLocationGetJson)
 
diff --git a/test/routes/river-and-sea-levels.js b/test/routes/river-and-sea-levels.js
index e7d826f4f..e6754245a 100644
--- a/test/routes/river-and-sea-levels.js
+++ b/test/routes/river-and-sea-levels.js
@@ -12,15 +12,33 @@ const { fullRelatedContentChecker } = require('../lib/helpers/html-expectations'
 lab.experiment('Test - /river-and-sea-levels', () => {
   let sandbox
   let server
+  let stubs
 
   lab.beforeEach(async () => {
-    delete require.cache[require.resolve('../../server/util.js')]
-    delete require.cache[require.resolve('../../server/services/location.js')]
-    delete require.cache[require.resolve('../../server/services/flood.js')]
     delete require.cache[require.resolve('../../server/services/server-methods.js')]
-    delete require.cache[require.resolve('../../server/routes/location.js')]
     delete require.cache[require.resolve('../../server/routes/river-and-sea-levels.js')]
+    delete require.cache[require.resolve('../../server/services/location.js')]
+    delete require.cache[require.resolve('../../server/services/flood.js')]
+    delete require.cache[require.resolve('../../server/util')]
+
+    const floodService = require('../../server/services/flood')
+    const util = require('../../server/util')
+
     sandbox = await sinon.createSandbox()
+    stubs = {
+      getJson: sandbox.stub(util, 'getJson'),
+      getIsEngland: sandbox.stub(floodService, 'getIsEngland'),
+      getStations: sandbox.stub(floodService, 'getStations'),
+      getStationById: sandbox.stub(floodService, 'getStationById'),
+      getStationsWithin: sandbox.stub(floodService, 'getStationsWithin'),
+      getStationsByRadius: sandbox.stub(floodService, 'getStationsByRadius'),
+      getStationsGeoJson: sandbox.stub(floodService, 'getStationsGeoJson'),
+      getStationsWithinTargetArea: sandbox.stub(floodService, 'getStationsWithinTargetArea'),
+      getRainfallStation: sandbox.stub(floodService, 'getRainfallStation'),
+      getRiverById: sandbox.stub(floodService, 'getRiverById'),
+      getRiversByName: sandbox.stub(floodService, 'getRiversByName'),
+      getTargetArea: sandbox.stub(floodService, 'getTargetArea')
+    }
     server = Hapi.server({
       port: 3000,
       host: 'localhost',
@@ -33,525 +51,366 @@ lab.experiment('Test - /river-and-sea-levels', () => {
         }
       }
     })
-  })
-
-  lab.afterEach(async () => {
-    await server.stop()
-    await sandbox.restore()
-  })
-  lab.test('GET /river-and-sea-levels TYPO or non location "afdv vdaf adfv  fda" ', async () => {
-    const floodService = require('../../server/services/flood')
-    const fakeGetJson = () => data.nonLocationGetJson
 
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
-    const fakeRiversData = () => []
-
-    sandbox.stub(floodService, 'getRiversByName').callsFake(fakeRiversData)
-
-    const riversPlugin = {
+    await server.register(require('../../server/plugins/views'))
+    await server.register(require('../../server/plugins/session'))
+    await server.register(require('../../server/plugins/logging'))
+    require('../../server/services/server-methods')(server)
+    await server.register({
       plugin: {
-        name: 'rivers',
+        name: 'warnings',
         register: (server, options) => {
           server.route(require('../../server/routes/river-and-sea-levels'))
         }
       }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(require('../../server/plugins/error-pages'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+    })
 
     await server.initialize()
+  })
+
+  lab.afterEach(async () => {
+    await sandbox.restore()
+    await server.stop()
+    delete require.cache[require.resolve('../../server/services/server-methods.js')]
+    delete require.cache[require.resolve('../../server/routes/river-and-sea-levels.js')]
+    delete require.cache[require.resolve('../../server/services/location.js')]
+    delete require.cache[require.resolve('../../server/services/flood.js')]
+    delete require.cache[require.resolve('../../server/util')]
+  })
+
+  lab.test('GET /river-and-sea-levels with legacy query parameter', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [])
+
     const options = {
       method: 'GET',
-      url: '/river-and-sea-levels?q=wefwe%20we%20fwef%20str'
+      url: '/river-and-sea-levels?q=warrington'
     }
 
     const response = await server.inject(options)
 
-    Code.expect(response.statusCode).to.equal(200)
-    Code.expect(response.payload).to.contain('No results for \'wefwe we fwef str\'')
-    // Page Title
-    Code.expect(response.payload).to.contain('wefwe we fwef str - Find river, sea, groundwater and rainfall levels - GOV.UK\n')
-
-    const root = parse(response.payload)
-    checkTitleAndDescription(
-      root,
-      'wefwe we fwef str - Find river, sea, groundwater and rainfall levels - GOV.UK',
-      'Find river, sea, groundwater and rainfall levels in England. Check the last updated height, trend and state recorded by the measuring station.'
-    )
+    Code.expect(response.statusCode).to.equal(301)
+    Code.expect(response.headers.location).to.equal('/river-and-sea-levels/warrington')
   })
-  lab.test('GET /river-and-see-levels with query parameters of Kinghorn, Scotland', async () => {
-    const floodService = require('../../server/services/flood')
 
-    const fakeIsEngland = () => {
-      return { is_england: false }
-    }
+  lab.test('GET /river-and-sea-levels with legacy query parameter invalid location', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [])
 
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
+    const options = {
+      method: 'GET',
+      url: '/river-and-sea-levels?q=not-found'
+    }
 
-    const fakeGetJson = () => data.scotlandGetJson
+    const response = await server.inject(options)
 
-    const util = require('../../server/util')
+    Code.expect(response.statusCode).to.equal(404)
+    Code.expect(response.headers.location).to.equal(undefined)
+  })
 
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
+  lab.test('GET /river-and-sea-levels with legacy query parameter postcode', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [])
 
-    const fakeRiversData = () => []
+    const options = {
+      method: 'GET',
+      url: '/river-and-sea-levels?q=WA4%201HT'
+    }
 
-    sandbox.stub(floodService, 'getRiversByName').callsFake(fakeRiversData)
+    const response = await server.inject(options)
 
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
+    Code.expect(response.statusCode).to.equal(301)
+  })
 
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+  lab.test('GET /river-and-sea-levels with legacy query parameter england', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [])
 
-    await server.initialize()
     const options = {
       method: 'GET',
-      url: '/river-and-sea-levels?q=Kinghorn'
+      url: '/river-and-sea-levels?q=England'
     }
 
     const response = await server.inject(options)
 
-    Code.expect(response.payload).to.contain('<p class="govuk-body">If you want to search for a place outside England, you should go to:</p>\n')
-    Code.expect(response.statusCode).to.equal(200)
+    Code.expect(response.statusCode).to.equal(302)
+    Code.expect(response.headers.location).to.equal('/river-and-sea-levels')
   })
-  lab.test('GET /rivers-and-sea-levels Bing returns error', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeStationsData = () => []
 
-    sandbox.stub(floodService, 'getStations').callsFake(fakeStationsData)
+  lab.test('GET /river-and-sea-levels with legacy query parameter valid non-england', async () => {
+    stubs.getJson.callsFake(() => data.scotlandGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: false }))
+    stubs.getRiversByName.callsFake(() => [])
 
-    const fakeRiversData = () => []
-
-    sandbox.stub(floodService, 'getRiversByName').callsFake(fakeRiversData)
-
-    const fakeGetJson = () => {
-      throw new Error('Bing error')
+    const options = {
+      method: 'GET',
+      url: '/river-and-sea-levels?q=kinghorn'
     }
 
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
+    const response = await server.inject(options)
 
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
+    Code.expect(response.statusCode).to.equal(301)
+    Code.expect(response.headers.location).to.equal('/river-and-sea-levels/kinghorn-fife')
+  })
 
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(require('../../server/plugins/error-pages'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+  lab.test('GET /river-and-sea-levels with legacy query parameter invalid characters', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [])
 
-    await server.initialize()
     const options = {
       method: 'GET',
-      url: '/river-and-sea-levels?q=WA4%201HT'
+      url: '/river-and-sea-levels?q=warrington%*_'
     }
 
     const response = await server.inject(options)
 
-    // TODO: check that this is really what we want to do if bing is not available
-    // Looks like current live displays all stations if bing is unavailable
-    //
-    // Code.expect(response.payload).to.contain('No results for \'WA4 1HT\'')
-    // Code.expect(response.payload).to.contain('<p><strong>Call Floodline for advice</strong></p>\n')
-    // Code.expect(response.statusCode).to.equal(200)
-
-    Code.expect(response.statusCode).to.equal(500)
-    Code.expect(response.payload).to.contain('Sorry, there is a problem with the search')
+    Code.expect(response.statusCode).to.equal(301)
+    Code.expect(response.headers.location).to.equal('/river-and-sea-levels/warrington')
   })
-  lab.test('GET /rivers-and-sea-levels Bing returns no results', async () => {
-    const floodService = require('../../server/services/flood')
 
-    const fakeStationsData = () => []
+  lab.test('GET /river-and-sea-levels/{location} with location', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [])
+    stubs.getStationsWithin.callsFake(() => [])
+
+    const options = {
+      method: 'GET',
+      url: '/river-and-sea-levels/warrington'
+    }
 
-    sandbox.stub(floodService, 'getStations').callsFake(fakeStationsData)
+    const response = await server.inject(options)
 
-    const fakeRiversData = () => []
+    Code.expect(response.statusCode).to.equal(200)
+  })
 
-    sandbox.stub(floodService, 'getRiversByName').callsFake(fakeRiversData)
+  lab.test('GET /river-and-sea-levels/{location} with invalid location', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
 
-    const fakeGetJson = () => {
-      return {
-        authenticationResultCode: 'ValidCredentials',
-        brandLogoUri: 'http://dev.virtualearth.net/Branding/logo_powered_by.png',
-        copyright: 'Copyright',
-        resourceSets: [
-          {
-            estimatedTotal: 0,
-            resources: []
-          }
-        ],
-        statusCode: 200,
-        statusDescription: 'OK',
-        traceId: 'trace-id'
-      }
+    const options = {
+      method: 'GET',
+      url: '/river-and-sea-levels/not-found'
     }
 
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
+    const response = await server.inject(options)
 
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
+    Code.expect(response.statusCode).to.equal(404)
+  })
 
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+  lab.test('GET /river-and-sea-levels/{location} should set the canonical url', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [])
 
-    await server.initialize()
     const options = {
       method: 'GET',
-      url: '/river-and-sea-levels?q=WA4%201HT'
+      url: '/river-and-sea-levels/warrington?active=true'
     }
 
     const response = await server.inject(options)
 
+    Code.expect(response.payload).to.contain('<link rel="canonical" href="http://localhost:3000/river-and-sea-levels/warrington"/>')
     Code.expect(response.statusCode).to.equal(200)
-    Code.expect(response.payload).to.contain('No results for \'WA4 1HT\'')
-    Code.expect(response.payload).to.contain('<p><strong>Call Floodline for advice</strong></p>\n')
   })
-  lab.test('GET /rivers-and-sea-levels single character search should return no results', async () => {
-    const floodService = require('../../server/services/flood')
 
-    const fakeStationsData = () => [{
-      river_id: 'river-alne',
-      river_name: 'River Alne',
-      navigable: true,
-      view_rank: 1,
-      rank: '1',
-      rloi_id: 2083,
-      up: null,
-      down: 2048,
-      telemetry_id: '2621',
-      region: 'Midlands',
-      catchment: 'Warwickshire Avon',
-      wiski_river_name: 'River Alne',
-      agency_name: 'Henley River',
-      external_name: 'Henley River',
-      station_type: 'S',
-      status: 'Active',
-      qualifier: 'u',
-      iswales: false,
-      value: '0.414',
-      value_timestamp: '2022-09-26T13:30:00.000Z',
-      value_erred: false,
-      percentile_5: '0.546',
-      percentile_95: '0.387',
-      centroid: '0101000020E6100000068A4FA62670FCBF9C9AE66602264A40',
-      lon: -1.77738060917966,
-      lat: 52.29694830188711,
-      day_total: null,
-      six_hr_total: null,
-      one_hr_total: null,
-      id: '610'
-    }]
+  lab.test('GET /river-and-sea-levels/{location} with england should redirect to default page', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [])
 
-    sandbox.stub(floodService, 'getStations').callsFake(fakeStationsData)
+    const options = {
+      method: 'GET',
+      url: '/river-and-sea-levels/england'
+    }
 
-    const fakeRiversData = () => [
-      {
-        name: 'River Mersey',
-        qualified_name: 'River Mersey',
-        id: 'river-mersey'
-      }
-    ]
+    const response = await server.inject(options)
 
-    sandbox.stub(floodService, 'getRiversByName').callsFake(fakeRiversData)
+    Code.expect(response.statusCode).to.equal(302)
+    Code.expect(response.headers.location).to.equal('/river-and-sea-levels')
+  })
 
-    const fakeGetJson = () => {
-      return {
-        authenticationResultCode: 'ValidCredentials',
-        brandLogoUri: 'http://dev.virtualearth.net/Branding/logo_powered_by.png',
-        copyright: 'Copyright',
-        resourceSets: [
-          {
-            estimatedTotal: 0,
-            resources: []
-          }
-        ],
-        statusCode: 200,
-        statusDescription: 'OK',
-        traceId: 'trace-id'
-      }
+  lab.test('GET /river-and-sea-levels?q=warrington&riverId=123 should redirect with query parameters', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [])
+
+    const options = {
+      method: 'GET',
+      url: '/river-and-sea-levels?q=warrington&riverId=123'
     }
 
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
+    const response = await server.inject(options)
 
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
+    Code.expect(response.statusCode).to.equal(301)
+    Code.expect(response.headers.location).to.equal('/river-and-sea-levels/warrington?riverId=123')
+  })
 
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+  lab.test('GET /river-and-sea-levels no query value', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [])
+    stubs.getStationsWithin.callsFake(() => [])
 
-    await server.initialize()
     const options = {
       method: 'GET',
-      url: '/river-and-sea-levels?q=e'
+      url: '/river-and-sea-levels'
     }
 
     const response = await server.inject(options)
-
     Code.expect(response.statusCode).to.equal(200)
-    Code.expect(response.payload).to.contain('No results for \'e\'')
-    Code.expect(response.payload).to.contain('<p><strong>Call Floodline for advice</strong></p>\n')
-  })
-  lab.test('GET /river-and-sea-levels with levels Low, Normal, High', async () => {
-    const floodService = require('../../server/services/flood')
 
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
+    const root = parse(response.payload)
+    Code.expect(root.querySelectorAll('h2').some(h => h.textContent.trim().startsWith('No results for'))).to.be.false()
+    Code.expect(root.querySelectorAll('table.defra-flood-levels-table#results').length).to.equal(0)
+    Code.expect(response.payload).to.contain('Find river, sea, groundwater and rainfall levels - GOV.UK\n')
+  })
 
-    const fakeStationsData = () => [
+  lab.test('GET /river-and-sea-levels only groundwater stations', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [])
+    stubs.getStationsWithin.callsFake(() => [
       {
-        river_id: 'river-mersey',
-        river_name: 'River Mersey',
-        navigable: true,
-        view_rank: 3,
-        rank: 5,
-        rloi_id: 5149,
-        up: 5052,
-        down: 5050,
-        telemetry_id: '693976',
-        region: 'North West',
-        catchment: 'Lower Mersey',
-        wiski_river_name: 'River Mersey',
-        agency_name: 'Westy',
-        external_name: 'Westy',
-        station_type: 'S',
+        river_id: 'Groundwater Levels',
+        river_name: 'Groundwater Levels',
+        navigable: false,
+        view_rank: 2,
+        rank: null,
+        rloi_id: 9306,
+        up: null,
+        down: null,
+        telemetry_id: 'TQ35_42',
+        region: 'Thames',
+        catchment: 'London',
+        wiski_river_name: 'Groundwater Level',
+        agency_name: 'Woldingham Road',
+        external_name: 'Woldingham Road',
+        station_type: 'G',
         status: 'Active',
         qualifier: 'u',
         iswales: false,
-        value: '6.122',
-        value_timestamp: '2020-02-27T14:30:00.000Z',
+        value: '77.15',
+        value_timestamp: '2020-10-02T06:00:00.000Z',
         value_erred: false,
-        percentile_5: '4.14',
-        percentile_95: '3.548',
-        centroid: '0101000020E6100000DF632687A47B04C09BC5867601B24A40',
-        lon: -2.56037240587146,
-        lat: 53.3906696470323
-      },
+        percentile_5: '104.628',
+        percentile_95: '70.609',
+        centroid: '0101000020E6100000D5C8218D26B6AFBF8266C677D7A54940',
+        lon: -0.061936573722862,
+        lat: 51.2956380575897
+      }
+    ])
+
+    const options = {
+      method: 'GET',
+      url: '/river-and-sea-levels/warrington'
+    }
+
+    const response = await server.inject(options)
+
+    Code.expect(response.statusCode).to.equal(200)
+    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=warrington&group=river" data-group-type="river">River (0)</a>')
+    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=warrington&group=sea" data-group-type="sea">Sea (0)</a>')
+    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=warrington&group=rainfall" data-group-type="rainfall">Rainfall (0)</a>')
+    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=warrington&group=groundwater" data-group-type="groundwater">Groundwater (1)</a>')
+  })
+
+  lab.test('GET /river-and-sea-levels only rainfall stations', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [])
+    stubs.getStationsWithin.callsFake(() => ([
       {
-        river_id: 'river-mersey',
-        river_name: 'River Mersey',
-        navigable: true,
-        view_rank: 3,
-        rank: 6,
-        rloi_id: 5050,
-        up: 5149,
-        down: 5084,
-        telemetry_id: '694063',
-        region: 'North West',
-        catchment: 'Lower Mersey',
-        wiski_river_name: 'River Mersey',
-        agency_name: 'Fiddlers Ferry',
-        external_name: 'Fiddlers Ferry',
-        station_type: 'S',
+        river_id: 'rainfall-Thames',
+        river_name: 'Rainfall Thames',
+        navigable: false,
+        view_rank: 5,
+        rank: null,
+        rloi_id: null,
+        up: null,
+        down: null,
+        telemetry_id: '253861TP',
+        region: 'Thames',
+        catchment: null,
+        wiski_river_name: null,
+        agency_name: 'Worsham',
+        external_name: 'Worsham',
+        station_type: 'R',
         status: 'Active',
-        qualifier: 'u',
+        qualifier: null,
         iswales: false,
-        value: '3.458',
-        value_timestamp: '2020-02-27T04:30:00.000Z',
+        value: 0,
+        value_timestamp: '2021-05-28T10:00:00.000Z',
         value_erred: false,
-        percentile_5: '6.2',
-        percentile_95: '2.611',
-        centroid: '0101000020E61000001248AD04653A05C01F4188A7E5AF4A40',
-        lon: -2.65351298955739,
-        lat: 53.3741959967904
+        percentile_5: null,
+        percentile_95: null,
+        centroid: '0101000020E610000029082C882404F9BF743F936BA6E54940',
+        lon: -1.56351140205562,
+        lat: 51.7941412419304,
+        day_total: 0,
+        six_hr_total: 0,
+        one_hr_total: 0
       },
       {
-        river_id: 'sankey-brook',
-        river_name: 'Sankey Brook',
-        navigable: true,
-        view_rank: 3,
-        rank: 1,
-        rloi_id: 5031,
+        river_id: 'rainfall-Thames',
+        river_name: 'Rainfall Thames',
+        navigable: false,
+        view_rank: 5,
+        rank: null,
+        rloi_id: null,
         up: null,
-        down: 5069,
-        telemetry_id: '694039',
-        region: 'North West',
-        catchment: 'Lower Mersey',
-        wiski_river_name: 'Sankey Brook',
-        agency_name: 'Causey Bridge',
-        external_name: 'Causey Bridge',
-        station_type: 'S',
+        down: null,
+        telemetry_id: '265415TP',
+        region: 'Thames',
+        catchment: null,
+        wiski_river_name: null,
+        agency_name: 'Yattendon',
+        external_name: 'Yattendon',
+        station_type: 'R',
         status: 'Active',
-        qualifier: 'u',
+        qualifier: null,
         iswales: false,
-        value: '0.111',
-        value_timestamp: '2020-02-27T14:30:00.000Z',
+        value: 0,
+        value_timestamp: '2021-05-28T10:30:00.000Z',
         value_erred: false,
-        percentile_5: '2.5',
-        percentile_95: '0.209',
-        centroid: '0101000020E610000095683DBA03FA04C089E4A73671B64A40',
-        lon: -2.62207742214111,
-        lat: 53.4253300018109
-      }
-    ]
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStationsWithin').callsFake(fakeStationsData)
-
-    const fakeGetJson = () => data.warringtonGetJson
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
+        percentile_5: null,
+        percentile_95: null,
+        centroid: '0101000020E6100000ABC88FF60226F3BFDBF36C518BBB4940',
+        lon: -1.19678016961238,
+        lat: 51.4651891500468,
+        day_total: 0,
+        six_hr_total: 0,
+        one_hr_total: 0
       }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+    ]))
 
-    await server.initialize()
     const options = {
       method: 'GET',
-      url: '/river-and-sea-levels?q=Warrington'
+      url: '/river-and-sea-levels/warrington'
     }
 
     const response = await server.inject(options)
 
-    const root = parse(response.payload)
-
-    checkTitleAndDescription(
-      root,
-      'Warrington - Find river, sea, groundwater and rainfall levels - GOV.UK',
-      'Find river, sea, groundwater and rainfall levels in Warrington. Check the last updated height, trend and state recorded by the measuring station.'
-    )
-
-    Code.expect(response.payload).to.contain('<span class="defra-flood-levels-table-state defra-flood-levels-table-state--grey">LOW</span>')
-    Code.expect(response.payload).to.contain('<span class="defra-flood-levels-table-state defra-flood-levels-table-state--grey">NORMAL</span>')
-    Code.expect(response.payload).to.contain('<span class="defra-flood-levels-table-state defra-flood-levels-table-state--blue">HIGH</span>')
     Code.expect(response.statusCode).to.equal(200)
+    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=warrington&group=river" data-group-type="river">River (0)</a>')
+    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=warrington&group=sea" data-group-type="sea">Sea (0)</a>')
+    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=warrington&group=rainfall" data-group-type="rainfall">Rainfall (2)</a>')
   })
 
-  lab.test('GET /river-and-sea-levels with trend falling, steady, rising ', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => [
-      {
-        river_id: 'river-mersey',
-        river_name: 'River Mersey',
-        navigable: true,
-        view_rank: 3,
-        rank: 5,
-        rloi_id: 5149,
-        up: 5052,
-        down: 5050,
-        telemetry_id: '693976',
-        region: 'North West',
-        catchment: 'Lower Mersey',
-        wiski_river_name: 'River Mersey',
-        agency_name: 'Westy',
-        external_name: 'Westy',
-        station_type: 'S',
-        status: 'Active',
-        qualifier: 'u',
-        iswales: false,
-        value: '6.122',
-        value_timestamp: '2020-02-27T14:30:00.000Z',
-        value_erred: false,
-        trend: 'steady',
-        percentile_5: '4.14',
-        percentile_95: '3.548',
-        centroid: '0101000020E6100000DF632687A47B04C09BC5867601B24A40',
-        lon: -2.56037240587146,
-        lat: 53.3906696470323
-      },
-      {
-        river_id: 'river-mersey',
-        river_name: 'River Mersey',
-        navigable: true,
-        view_rank: 3,
-        rank: 6,
-        rloi_id: 5050,
-        up: 5149,
-        down: 5084,
-        telemetry_id: '694063',
-        region: 'North West',
-        catchment: 'Lower Mersey',
-        wiski_river_name: 'River Mersey',
-        agency_name: 'Fiddlers Ferry',
-        external_name: 'Fiddlers Ferry',
-        station_type: 'S',
-        status: 'Active',
-        qualifier: 'u',
-        iswales: false,
-        value: '3.458',
-        value_timestamp: '2020-02-27T04:30:00.000Z',
-        value_erred: false,
-        trend: 'rising',
-        percentile_5: '6.2',
-        percentile_95: '2.611',
-        centroid: '0101000020E61000001248AD04653A05C01F4188A7E5AF4A40',
-        lon: -2.65351298955739,
-        lat: 53.3741959967904
-      },
+  lab.test('GET /river-and-sea-levels Test funny latest value', async () => {
+    // This test is off https://eaflood.atlassian.net/browse/FSR-354
+    // stations values were being compared to percentile5 with out being cast to
+    // a number and the string comparison is giving incorrect results
+    // if the 2 numbers were of a different factor of 10
+    // ie in this example '8.9' < '10.1' returns false
+    // fix use parseFloat on each value to ensure it returns true.
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [])
+    stubs.getStations.callsFake(() => [
       {
         river_id: 'sankey-brook',
         river_name: 'Sankey Brook',
@@ -571,1217 +430,138 @@ lab.experiment('Test - /river-and-sea-levels', () => {
         status: 'Active',
         qualifier: 'u',
         iswales: false,
-        value: '0.111',
+        value: '8.9',
         value_timestamp: '2020-02-27T14:30:00.000Z',
         value_erred: false,
-        trend: 'falling',
-        percentile_5: '2.5',
+        percentile_5: '10.1',
         percentile_95: '0.209',
         centroid: '0101000020E610000095683DBA03FA04C089E4A73671B64A40',
         lon: -2.62207742214111,
         lat: 53.4253300018109
       }
-    ]
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStationsWithin').callsFake(fakeStationsData)
+    ])
+    stubs.getJson.callsFake(() => {
+      return {
+        authenticationResultCode: 'ValidCredentials',
+        brandLogoUri: 'http://dev.virtualearth.net/Branding/logo_powered_by.png',
+        copyright: 'Copyright',
+        resourceSets: [
+          {
+            estimatedTotal: 0,
+            resources: []
+          }
+        ],
+        statusCode: 200,
+        statusDescription: 'OK',
+        traceId: 'trace-id'
+      }
+    })
 
-    const fakeGetJson = () => data.warringtonGetJson
+    const options = {
+      method: 'GET',
+      url: '/river-and-sea-levels'
+    }
 
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
+    const response = await server.inject(options)
+    Code.expect(response.statusCode).to.equal(200)
+  })
 
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
+  lab.test('GET /river-and-sea-levels?rainfall-id=E24195', async () => {
+    stubs.getStationsByRadius.callsFake(() => data.stationsWithinRadiusRainfallid)
+    stubs.getRainfallStation.callsFake(() => data.cachedRainfallStation)
+    stubs.getStationsGeoJson.callsFake(() => data.cachedRainfallStation)
 
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+    // Set cached stationsGeojson
+    const floodService = require('../../server/services/flood')
+    floodService.stationsGeojson = await floodService.getStationsGeoJson()
 
-    await server.initialize()
     const options = {
       method: 'GET',
-      url: '/river-and-sea-levels?q=Warrington'
+      url: '/river-and-sea-levels?rainfall-id=E24195'
     }
 
     const response = await server.inject(options)
+    Code.expect(response.statusCode).to.equal(302)
+    Code.expect(response.headers.location).to.equal('/river-and-sea-levels/rainfall/E24195')
+  })
 
-    const root = parse(response.payload)
+  lab.test('GET /river-and-sea-levels/rainfall/E24195', async () => {
+    stubs.getStationsByRadius.callsFake(() => data.stationsWithRadiusRainfallid)
+    stubs.getRainfallStation.callsFake(() => data.cachedRainfallStation)
+    stubs.getStationsGeoJson.callsFake(() => data.cachedRainfallStation)
+
+    // Set cached stationsGeojson
+    const floodService = require('../../server/services/flood')
+    floodService.stationsGeojson = await floodService.getStationsGeoJson()
 
-    checkTitleAndDescription(
-      root,
-      'Warrington - Find river, sea, groundwater and rainfall levels - GOV.UK',
-      'Find river, sea, groundwater and rainfall levels in Warrington. Check the last updated height, trend and state recorded by the measuring station.'
-    )
+    const options = {
+      method: 'GET',
+      url: '/river-and-sea-levels/rainfall/E24195'
+    }
 
-    Code.expect(response.payload).to.contain('falling')
-    Code.expect(response.payload).to.contain('steady')
-    Code.expect(response.payload).to.contain('rising')
+    const response = await server.inject(options)
     Code.expect(response.statusCode).to.equal(200)
+    const root = parse(response.payload)
+    const headings = root.querySelectorAll('h1').some(h => h.textContent.trim() === 'Find river, sea, groundwater and rainfall levels')
+    Code.expect(headings, 'Heading for levels found').to.be.true()
+    const searchBoxValue = root.querySelectorAll('input.defra-search__input#location')[0].attributes.value
+    Code.expect(searchBoxValue, 'Search box value').to.be.equal('')
+    const paragraphs = root.querySelectorAll('p.govuk-body').some(p => p.textContent.trim() === 'Showing levels within 5 miles of EASTHAVEN BARRIER.')
+    Code.expect(paragraphs, 'Distance message found').to.be.true()
   })
 
-  lab.test('GET /river-and-sea-levels station status Closed', async () => {
+  lab.test('GET /river-and-sea-levels/rainfall/', async () => {
+    stubs.getStationsByRadius.callsFake(() => data.stationsWithRadiusRainfallid)
+    stubs.getRainfallStation.callsFake(() => data.cachedRainfallStation)
+    stubs.getStationsGeoJson.callsFake(() => data.cachedRainfallStation)
+
+    // Set cached stationsGeojson
     const floodService = require('../../server/services/flood')
+    floodService.stationsGeojson = await floodService.getStationsGeoJson()
 
-    const fakeIsEngland = () => {
-      return { is_england: true }
+    const options = {
+      method: 'GET',
+      url: '/river-and-sea-levels/rainfall/'
     }
 
-    const fakeStationsData = () => [
-      {
-        river_id: 'sankey-brook',
-        river_name: 'Sankey Brook',
-        navigable: true,
-        view_rank: 3,
-        rank: 1,
-        rloi_id: 5031,
-        up: null,
-        down: 5069,
-        telemetry_id: '694039',
-        region: 'North West',
-        catchment: 'Lower Mersey',
-        wiski_river_name: 'Sankey Brook',
-        agency_name: 'Causey Bridge',
-        external_name: 'Causey Bridge',
-        station_type: 'S',
-        status: 'Closed',
-        qualifier: 'u',
-        iswales: false,
-        value: '0.111',
-        value_timestamp: '2020-02-27T14:30:00.000Z',
-        value_erred: false,
-        percentile_5: '2.5',
-        percentile_95: '0.209',
-        centroid: '0101000020E610000095683DBA03FA04C089E4A73671B64A40',
-        lon: -2.62207742214111,
-        lat: 53.4253300018109
-      }
-    ]
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStationsWithin').callsFake(fakeStationsData)
-
-    const fakeGetJson = () => data.warringtonGetJson
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
+    const response = await server.inject(options)
+    Code.expect(response.result.statusCode).to.equal(404)
+    Code.expect(response.result.message).to.equal('Not Found')
+  })
 
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
+  lab.test('GET /river-and-sea-levels/rainfall/GKHLETOY', async () => {
+    stubs.getStationsByRadius.callsFake(() => data.stationsWithinRadius)
+    stubs.getRainfallStation.callsFake(() => data.rainfallStation.find(function (rainfallStation) {
+      return rainfallStation.station_reference === 'GKHLETOY'
+    }))
+    stubs.getStationsGeoJson.callsFake(() => data.cachedRainfallStation)
 
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+    // Set cached stationsGeojson
+    const floodService = require('../../server/services/flood')
+    floodService.stationsGeojson = await floodService.getStationsGeoJson()
 
-    await server.initialize()
     const options = {
       method: 'GET',
-      url: '/river-and-sea-levels?q=Warrington'
+      url: '/river-and-sea-levels/rainfall/GKHLETOY'
     }
 
     const response = await server.inject(options)
 
-    Code.expect(response.payload).to.contain('Data not available')
-    Code.expect(response.payload).to.contain('<span class="defra-flood-levels-table-na">n/a</a>')
-    Code.expect(response.statusCode).to.equal(200)
+    Code.expect(response.result.statusCode).to.equal(404)
+    Code.expect(response.result.message).to.equal('Rainfall Gauge "GKHLETOY" not found')
   })
-  lab.test('GET /river-and-sea-levels station status Suspended', async () => {
+
+  lab.test('GET /river-and-sea-levels?target-area=011FWFNC6KC should redirect', async () => {
+    stubs.getStationsWithinTargetArea.callsFake(() => data.stationsWithinTa)
+    stubs.getTargetArea.callsFake(() => data.getTA)
+
+    // Set cached stationsGeojson
     const floodService = require('../../server/services/flood')
+    floodService.stationsGeojson = await floodService.getStationsGeoJson()
 
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => [
-      {
-        river_id: 'sankey-brook',
-        river_name: 'Sankey Brook',
-        navigable: true,
-        view_rank: 3,
-        rank: 1,
-        rloi_id: 5031,
-        up: null,
-        down: 5069,
-        telemetry_id: '694039',
-        region: 'North West',
-        catchment: 'Lower Mersey',
-        wiski_river_name: 'Sankey Brook',
-        agency_name: 'Causey Bridge',
-        external_name: 'Causey Bridge',
-        station_type: 'S',
-        status: 'Suspended',
-        qualifier: 'u',
-        iswales: false,
-        value: '0.111',
-        value_timestamp: '2020-02-27T14:30:00.000Z',
-        value_erred: false,
-        percentile_5: '2.5',
-        percentile_95: '0.209',
-        centroid: '0101000020E610000095683DBA03FA04C089E4A73671B64A40',
-        lon: -2.62207742214111,
-        lat: 53.4253300018109
-      }
-    ]
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStationsWithin').callsFake(fakeStationsData)
-
-    const fakeGetJson = () => data.warringtonGetJson
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels?q=Warrington'
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.payload).to.contain('Data not available')
-    Code.expect(response.payload).to.contain('<span class="defra-flood-levels-table-na">n/a</a>')
-    Code.expect(response.statusCode).to.equal(200)
-  })
-  lab.test('GET /river-and-sea-levels station status Active but no value', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => [
-      {
-        river_id: 'sankey-brook',
-        river_name: 'Sankey Brook',
-        navigable: true,
-        view_rank: 3,
-        rank: 1,
-        rloi_id: 5031,
-        up: null,
-        down: 5069,
-        telemetry_id: '694039',
-        region: 'North West',
-        catchment: 'Lower Mersey',
-        wiski_river_name: 'Sankey Brook',
-        agency_name: 'Causey Bridge',
-        external_name: 'Causey Bridge',
-        station_type: 'S',
-        status: 'Active',
-        qualifier: 'u',
-        iswales: false,
-        value: null,
-        value_timestamp: '2020-02-27T14:30:00.000Z',
-        value_erred: false,
-        percentile_5: '2.5',
-        percentile_95: '0.209',
-        centroid: '0101000020E610000095683DBA03FA04C089E4A73671B64A40',
-        lon: -2.62207742214111,
-        lat: 53.4253300018109
-      }
-    ]
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStationsWithin').callsFake(fakeStationsData)
-
-    const fakeGetJson = () => data.warringtonGetJson
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels?q=Warrington'
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.payload).to.contain('Data not available')
-    Code.expect(response.payload).to.contain('<span class="defra-flood-levels-table-na">n/a</a>')
-    Code.expect(response.statusCode).to.equal(200)
-  })
-  lab.test('GET /river-and-sea-levels stations returned but location in Wales should not show stations', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: false }
-    }
-
-    const fakeStationsData = () => [
-      {
-        river_id: 'lledan-brook',
-        river_name: 'Lledan Brook',
-        navigable: true,
-        view_rank: 3,
-        rank: 1,
-        rloi_id: 2089,
-        up: null,
-        down: null,
-        telemetry_id: '2638',
-        region: 'Wales',
-        catchment: 'Severn Uplands',
-        wiski_river_name: 'Lledan Brook',
-        agency_name: 'Welshpool',
-        external_name: 'Welshpool',
-        station_type: 'S',
-        status: 'Active',
-        qualifier: 'u',
-        iswales: true,
-        value: '0.297',
-        value_timestamp: '2020-03-04T09:00:00.000Z',
-        value_erred: false,
-        percentile_5: '0.36',
-        percentile_95: '0.065',
-        centroid: '0101000020E610000011F39E34DD3E09C0EDCA71828A544A40',
-        lon: -3.15569535360408,
-        lat: 52.6604769759777
-      },
-      {
-        river_id: 'river-severn',
-        river_name: 'River Severn',
-        navigable: true,
-        view_rank: 3,
-        rank: 7,
-        rloi_id: 2068,
-        up: 2072,
-        down: 2061,
-        telemetry_id: '2176',
-        region: 'Wales',
-        catchment: 'Severn Uplands',
-        wiski_river_name: 'River Severn',
-        agency_name: 'Buttington',
-        external_name: 'Buttington',
-        station_type: 'S',
-        status: 'Active',
-        qualifier: 'u',
-        iswales: true,
-        value: '3.192',
-        value_timestamp: '2020-03-04T09:00:00.000Z',
-        value_erred: false,
-        percentile_5: '3.509',
-        percentile_95: '0.756',
-        centroid: '0101000020E6100000188D8E3E20ED08C0AB99B41013564A40',
-        lon: -3.11578415749103,
-        lat: 52.6724568254316
-      }
-    ]
-
-    const fakeRiversData = () => []
-
-    sandbox.stub(floodService, 'getRiversByName').callsFake(fakeRiversData)
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStationsWithin').callsFake(fakeStationsData)
-
-    const fakeGetJson = () => data.welshLocationGetJson
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels?q=welshpool'
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.payload).to.contain('<p class="govuk-body">If you searched for a river or place in England, you should:</p>')
-    Code.expect(response.statusCode).to.equal(200)
-    Code.expect(response.payload).to.contain('No results for \'welshpool\'')
-    // Page Title
-    Code.expect(response.payload).to.contain('welshpool - Find river, sea, groundwater and rainfall levels - GOV.UK\n')
-
-    const root = parse(response.payload)
-    checkTitleAndDescription(
-      root,
-      'welshpool - Find river, sea, groundwater and rainfall levels - GOV.UK',
-      'Find river, sea, groundwater and rainfall levels in England. Check the last updated height, trend and state recorded by the measuring station.'
-    )
-  })
-  lab.test('GET /river-and-sea-levels Station is coastal with percentiles so should be in river section', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => [
-      {
-        river_id: 'river-mersey',
-        river_name: 'River Mersey',
-        navigable: true,
-        view_rank: 3,
-        rank: 5,
-        rloi_id: 5149,
-        up: 5052,
-        down: 5050,
-        telemetry_id: '693976',
-        region: 'North West',
-        catchment: 'Lower Mersey',
-        wiski_river_name: 'River Mersey',
-        agency_name: 'Westy',
-        external_name: 'Westy',
-        station_type: 'C',
-        status: 'Active',
-        qualifier: 'u',
-        iswales: false,
-        value: '6.122',
-        value_timestamp: '2020-02-27T14:30:00.000Z',
-        value_erred: false,
-        percentile_5: '4.14',
-        percentile_95: '3.548',
-        centroid: '0101000020E6100000DF632687A47B04C09BC5867601B24A40',
-        lon: -2.56037240587146,
-        lat: 53.3906696470323
-      }
-    ]
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStationsWithin').callsFake(fakeStationsData)
-
-    const fakeGetJson = () => data.warringtonGetJson
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels?q=Warrington'
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.statusCode).to.equal(200)
-    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=Warrington&group=river" data-group-type="river">River (1)</a>')
-    Code.expect(response.payload).to.contain('<a href="/station/5149">')
-    Code.expect(response.payload).to.contain('River Mersey at')
-  })
-  lab.test('GET /river-and-sea-levels Station is coastal with percentiles so should be in river section', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => [
-      {
-        river_id: 'river-mersey',
-        river_name: 'River Mersey',
-        navigable: true,
-        view_rank: 3,
-        rank: 5,
-        rloi_id: 5149,
-        up: 5052,
-        down: 5050,
-        telemetry_id: '693976',
-        region: 'North West',
-        catchment: 'Lower Mersey',
-        wiski_river_name: 'River Mersey',
-        agency_name: 'Westy',
-        external_name: 'Westy',
-        station_type: 'C',
-        status: 'Active',
-        qualifier: 'u',
-        iswales: false,
-        value: '6.122',
-        value_timestamp: '2020-02-27T14:30:00.000Z',
-        value_erred: false,
-        percentile_5: '4.14',
-        percentile_95: '3.548',
-        centroid: '0101000020E6100000DF632687A47B04C09BC5867601B24A40',
-        lon: -2.56037240587146,
-        lat: 53.3906696470323
-      }
-    ]
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStationsWithin').callsFake(fakeStationsData)
-
-    const fakeGetJson = () => data.warringtonGetJson
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels?q=Warrington'
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.statusCode).to.equal(200)
-    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=Warrington&group=river" data-group-type="river">River (1)</a>')
-    Code.expect(response.payload).to.contain('<a href="/station/5149">')
-    Code.expect(response.payload).to.contain('River Mersey at')
-  })
-  lab.test('GET /river-and-sea-levels Station is coastal with no percentiles so should be in sea level section', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => [
-      {
-        river_id: 'Sea Levels',
-        river_name: 'Sea Levels',
-        navigable: false,
-        view_rank: 2,
-        rank: null,
-        rloi_id: 9206,
-        up: null,
-        down: null,
-        telemetry_id: 'E11360',
-        region: 'Southern',
-        catchment: 'East Hampshire',
-        wiski_river_name: 'Tide',
-        agency_name: 'LANGSTONE HARBOUR TL',
-        external_name: 'Langstone',
-        station_type: 'C',
-        status: 'Active',
-        qualifier: 'u',
-        iswales: false,
-        value: '-8.638',
-        value_timestamp: '2022-07-04T04:30:00.000Z',
-        value_erred: false,
-        percentile_5: null,
-        percentile_95: null,
-        centroid: '0101000020E610000084189119A267F0BF4B5A5C49EC654940',
-        lon: -1.0253010748579365,
-        lat: 50.79627339372072,
-        day_total: null,
-        six_hr_total: null,
-        one_hr_total: null,
-        id: '2436'
-      }
-    ]
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStationsWithin').callsFake(fakeStationsData)
-
-    const fakeGetJson = () => data.warringtonGetJson
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels?q=Warrington'
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.statusCode).to.equal(200)
-    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=Warrington&group=river" data-group-type="river">River (0)</a>')
-    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=Warrington&group=sea" data-group-type="sea">Sea (1)</a>')
-  })
-  lab.test('GET /river-and-sea-levels England query', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => []
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStations').callsFake(fakeStationsData)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels?q=England'
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.payload).to.contain('No results for \'England\'')
-    // page title
-    Code.expect(response.payload).to.contain('Find river, sea, groundwater and rainfall levels - GOV.UK\n')
-
-    Code.expect(response.statusCode).to.equal(200)
-  })
-  lab.test('GET /river-and-sea-levels empty query', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => []
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStations').callsFake(fakeStationsData)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels'
-    }
-
-    const response = await server.inject(options)
-    Code.expect(response.statusCode).to.equal(200)
-
-    const root = parse(response.payload)
-    Code.expect(root.querySelectorAll('h2').some(h => h.textContent.trim().startsWith('No results for'))).to.be.false()
-    Code.expect(root.querySelectorAll('table.defra-flood-levels-table#results').length).to.equal(0)
-    Code.expect(response.payload).to.contain('Find river, sea, groundwater and rainfall levels - GOV.UK\n')
-  })
-  lab.test('GET /river-and-sea-levels only groundwater stations', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => [
-      {
-        river_id: 'Groundwater Levels',
-        river_name: 'Groundwater Levels',
-        navigable: false,
-        view_rank: 2,
-        rank: null,
-        rloi_id: 9306,
-        up: null,
-        down: null,
-        telemetry_id: 'TQ35_42',
-        region: 'Thames',
-        catchment: 'London',
-        wiski_river_name: 'Groundwater Level',
-        agency_name: 'Woldingham Road',
-        external_name: 'Woldingham Road',
-        station_type: 'G',
-        status: 'Active',
-        qualifier: 'u',
-        iswales: false,
-        value: '77.15',
-        value_timestamp: '2020-10-02T06:00:00.000Z',
-        value_erred: false,
-        percentile_5: '104.628',
-        percentile_95: '70.609',
-        centroid: '0101000020E6100000D5C8218D26B6AFBF8266C677D7A54940',
-        lon: -0.061936573722862,
-        lat: 51.2956380575897
-      }]
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStationsWithin').callsFake(fakeStationsData)
-
-    const fakeGetJson = () => data.warringtonGetJson
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels?q=Warrington'
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.statusCode).to.equal(200)
-    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=Warrington&group=river" data-group-type="river">River (0)</a>')
-    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=Warrington&group=sea" data-group-type="sea">Sea (0)</a>')
-    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=Warrington&group=rainfall" data-group-type="rainfall">Rainfall (0)</a>')
-    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=Warrington&group=groundwater" data-group-type="groundwater">Groundwater (1)</a>')
-  })
-  lab.test('GET /river-and-sea-levels only rainfall stations', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => [
-      {
-        river_id: 'rainfall-Thames',
-        river_name: 'Rainfall Thames',
-        navigable: false,
-        view_rank: 5,
-        rank: null,
-        rloi_id: null,
-        up: null,
-        down: null,
-        telemetry_id: '253861TP',
-        region: 'Thames',
-        catchment: null,
-        wiski_river_name: null,
-        agency_name: 'Worsham',
-        external_name: 'Worsham',
-        station_type: 'R',
-        status: 'Active',
-        qualifier: null,
-        iswales: false,
-        value: 0,
-        value_timestamp: '2021-05-28T10:00:00.000Z',
-        value_erred: false,
-        percentile_5: null,
-        percentile_95: null,
-        centroid: '0101000020E610000029082C882404F9BF743F936BA6E54940',
-        lon: -1.56351140205562,
-        lat: 51.7941412419304,
-        day_total: 0,
-        six_hr_total: 0,
-        one_hr_total: 0
-      },
-      {
-        river_id: 'rainfall-Thames',
-        river_name: 'Rainfall Thames',
-        navigable: false,
-        view_rank: 5,
-        rank: null,
-        rloi_id: null,
-        up: null,
-        down: null,
-        telemetry_id: '265415TP',
-        region: 'Thames',
-        catchment: null,
-        wiski_river_name: null,
-        agency_name: 'Yattendon',
-        external_name: 'Yattendon',
-        station_type: 'R',
-        status: 'Active',
-        qualifier: null,
-        iswales: false,
-        value: 0,
-        value_timestamp: '2021-05-28T10:30:00.000Z',
-        value_erred: false,
-        percentile_5: null,
-        percentile_95: null,
-        centroid: '0101000020E6100000ABC88FF60226F3BFDBF36C518BBB4940',
-        lon: -1.19678016961238,
-        lat: 51.4651891500468,
-        day_total: 0,
-        six_hr_total: 0,
-        one_hr_total: 0
-      }
-    ]
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStationsWithin').callsFake(fakeStationsData)
-
-    const fakeGetJson = () => data.warringtonGetJson
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels?q=Warrington'
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.statusCode).to.equal(200)
-    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=Warrington&group=river" data-group-type="river">River (0)</a>')
-    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=Warrington&group=sea" data-group-type="sea">Sea (0)</a>')
-    Code.expect(response.payload).to.contain('<a href="/river-and-sea-levels?q=Warrington&group=rainfall" data-group-type="rainfall">Rainfall (2)</a>')
-  })
-  lab.test('GET /river-and-sea-levels Test funny latest value', async () => {
-    // This test is off https://eaflood.atlassian.net/browse/FSR-354
-    // stations values were being compared to percentile5 with out being cast to
-    // a number and the string comparison is giving incorrect results
-    // if the 2 numbers were of a different factor of 10
-    // ie in this example '8.9' < '10.1' returns false
-    // fix use parseFloat on each value to ensure it returns true.
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => [
-      {
-        river_id: 'sankey-brook',
-        river_name: 'Sankey Brook',
-        navigable: true,
-        view_rank: 3,
-        rank: 1,
-        rloi_id: 5031,
-        up: null,
-        down: 5069,
-        telemetry_id: '694039',
-        region: 'North West',
-        catchment: 'Lower Mersey',
-        wiski_river_name: 'Sankey Brook',
-        agency_name: 'Causey Bridge',
-        external_name: 'Causey Bridge',
-        station_type: 'S',
-        status: 'Active',
-        qualifier: 'u',
-        iswales: false,
-        value: '8.9',
-        value_timestamp: '2020-02-27T14:30:00.000Z',
-        value_erred: false,
-        percentile_5: '10.1',
-        percentile_95: '0.209',
-        centroid: '0101000020E610000095683DBA03FA04C089E4A73671B64A40',
-        lon: -2.62207742214111,
-        lat: 53.4253300018109
-      }
-    ]
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStations').callsFake(fakeStationsData)
-
-    const fakeGetJson = () => {
-      return {
-        authenticationResultCode: 'ValidCredentials',
-        brandLogoUri: 'http://dev.virtualearth.net/Branding/logo_powered_by.png',
-        copyright: 'Copyright',
-        resourceSets: [
-          {
-            estimatedTotal: 0,
-            resources: []
-          }
-        ],
-        statusCode: 200,
-        statusDescription: 'OK',
-        traceId: 'trace-id'
-      }
-    }
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels'
-    }
-
-    const response = await server.inject(options)
-    // Code.expect(response.payload).to.contain('<li class="defra-flood-list-item defra-flood-list-item--S" data-river-id="sankey-brook" data-type="S">')
-    // Code.expect(response.payload).to.contain('Normal</span>')
-    // Code.expect(response.payload).to.not.contain('High</span>')
-    Code.expect(response.statusCode).to.equal(200)
-  })
-  lab.test('GET /river-and-sea-levels?rainfall-id=E24195', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeStationsData = () => data.stationsWithinRadiusRainfallid
-
-    const cachedStation = () => data.cachedRainfallStation
-
-    sandbox.stub(floodService, 'getStationsByRadius').callsFake(fakeStationsData)
-    sandbox.stub(floodService, 'getRainfallStation').callsFake(cachedStation)
-
-    sandbox.stub(floodService, 'getStationsGeoJson').callsFake(cachedStation)
-
-    // Set cached stationsGeojson
-
-    floodService.stationsGeojson = await floodService.getStationsGeoJson()
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels?rainfall-id=E24195'
-    }
-
-    const response = await server.inject(options)
-    Code.expect(response.statusCode).to.equal(302)
-    Code.expect(response.headers.location).to.equal('/river-and-sea-levels/rainfall/E24195')
-  })
-  lab.test('GET /river-and-sea-levels/rainfall/E24195', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeStationsData = () => data.stationsWithRadiusRainfallid
-
-    const cachedStation = () => data.cachedRainfallStation
-
-    sandbox.stub(floodService, 'getStationsByRadius').callsFake(fakeStationsData)
-    sandbox.stub(floodService, 'getRainfallStation').callsFake(cachedStation)
-
-    sandbox.stub(floodService, 'getStationsGeoJson').callsFake(cachedStation)
-
-    // Set cached stationsGeojson
-
-    floodService.stationsGeojson = await floodService.getStationsGeoJson()
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels/rainfall/E24195'
-    }
-
-    const response = await server.inject(options)
-    Code.expect(response.statusCode).to.equal(200)
-    const root = parse(response.payload)
-    const headings = root.querySelectorAll('h1').some(h => h.textContent.trim() === 'Find river, sea, groundwater and rainfall levels')
-    Code.expect(headings, 'Heading for levels found').to.be.true()
-    const searchBoxValue = root.querySelectorAll('input.defra-search__input#location')[0].attributes.value
-    Code.expect(searchBoxValue, 'Search box value').to.be.equal('')
-    const paragraphs = root.querySelectorAll('p.govuk-body').some(p => p.textContent.trim() === 'Showing levels within 5 miles of EASTHAVEN BARRIER.')
-    Code.expect(paragraphs, 'Distance message found').to.be.true()
-  })
-  lab.test('GET /river-and-sea-levels/rainfall/', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeStationsData = () => data.stationsWithRadiusRainfallid
-
-    const cachedStation = () => data.cachedRainfallStation
-
-    sandbox.stub(floodService, 'getStationsByRadius').callsFake(fakeStationsData)
-    sandbox.stub(floodService, 'getRainfallStation').callsFake(cachedStation)
-
-    sandbox.stub(floodService, 'getStationsGeoJson').callsFake(cachedStation)
-
-    // Set cached stationsGeojson
-
-    floodService.stationsGeojson = await floodService.getStationsGeoJson()
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels/rainfall/'
-    }
-
-    const response = await server.inject(options)
-    Code.expect(response.result.statusCode).to.equal(404)
-    Code.expect(response.result.message).to.equal('Not Found')
-  })
-  lab.test('GET /river-and-sea-levels/rainfall/GKHLETOY', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeStationsData = () => data.stationsWithinRadius
-
-    const originalStation = () => data.rainfallStation.find(function (rainfallStation) {
-      return rainfallStation.station_reference === 'GKHLETOY'
-    })
-
-    const cachedStation = () => data.cachedRainfallStation
-
-    sandbox.stub(floodService, 'getStationsByRadius').callsFake(fakeStationsData)
-    sandbox.stub(floodService, 'getRainfallStation').callsFake(originalStation)
-    sandbox.stub(floodService, 'getStationsGeoJson').callsFake(cachedStation)
-
-    // Set cached stationsGeojson
-
-    floodService.stationsGeojson = await floodService.getStationsGeoJson()
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels/rainfall/GKHLETOY'
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.result.statusCode).to.equal(404)
-    Code.expect(response.result.message).to.equal('Rainfall Gauge "GKHLETOY" not found')
-  })
-  lab.test('GET /river-and-sea-levels?target-area=011FWFNC6KC should redirect', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeStationsData = () => data.stationsWithinTa
-
-    const fakeTargetAreaData = () => data.getTA
-
-    sandbox.stub(floodService, 'getStationsWithinTargetArea').callsFake(fakeStationsData)
-    sandbox.stub(floodService, 'getTargetArea').callsFake(fakeTargetAreaData)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels?target-area=011FWFNC6KC'
+    const options = {
+      method: 'GET',
+      url: '/river-and-sea-levels?target-area=011FWFNC6KC'
     }
 
     const response = await server.inject(options)
@@ -1789,35 +569,15 @@ lab.experiment('Test - /river-and-sea-levels', () => {
     Code.expect(response.statusCode).to.equal(302)
     Code.expect(response.headers.location).to.equal('/river-and-sea-levels/target-area/011FWFNC6KC')
   })
-  lab.test('GET /river-and-sea-levels/target-area/011FWFNC6KC', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeStationsData = () => data.stationsWithinTa
-
-    const fakeTargetAreaData = () => data.getTA
-
-    sandbox.stub(floodService, 'getStationsWithinTargetArea').callsFake(fakeStationsData)
-    sandbox.stub(floodService, 'getTargetArea').callsFake(fakeTargetAreaData)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
 
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(require('../../server/plugins/error-pages'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+  lab.test('GET /river-and-sea-levels/target-area/011FWFNC6KC', async () => {
+    stubs.getStationsWithinTargetArea.callsFake(() => data.stationsWithinTa)
+    stubs.getTargetArea.callsFake(() => data.getTA)
+
+    // Set cached stationsGeojson
+    const floodService = require('../../server/services/flood')
+    floodService.stationsGeojson = await floodService.getStationsGeoJson()
 
-    await server.initialize()
     const options = {
       method: 'GET',
       url: '/river-and-sea-levels/target-area/011FWFNC6KC'
@@ -1829,36 +589,9 @@ lab.experiment('Test - /river-and-sea-levels', () => {
     Code.expect(response.payload).to.contain('River (8)')
     Code.expect(response.payload).to.contain('Showing levels within 5 miles of Keswick Campsite.')
   })
-  lab.test('GET /river-and-sea-levels?q=tyne returns river list', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeStationsData = () => []
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-    const fakeRiversData = () => [
-      {
-        name: 'River North Tyne',
-        qualified_name: 'River North Tyne',
-        id: 'river-north-tyne'
-      },
-      {
-        name: 'River South Tyne',
-        qualified_name: 'River South Tyne',
-        id: 'river-south-tyne'
-      },
-      {
-        name: 'River Tyne',
-        qualified_name: 'River Tyne',
-        id: 'river-tyne'
-      }
-    ]
 
-    sandbox.stub(floodService, 'getStations').callsFake(fakeStationsData)
-    sandbox.stub(floodService, 'getRiversByName').callsFake(fakeRiversData)
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-
-    const fakeGetJson = () => {
+  lab.test('GET /river-and-sea-levels?q=tyne query parameter returns river list', async () => {
+    stubs.getJson.callsFake(() => {
       return {
         authenticationResultCode: 'ValidCredentials',
         brandLogoUri: 'http://dev.virtualearth.net/Branding/logo_powered_by.png',
@@ -1873,301 +606,52 @@ lab.experiment('Test - /river-and-sea-levels', () => {
         statusDescription: 'OK',
         traceId: 'trace-id'
       }
-    }
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels?q=tyne'
-    }
-
-    const response = await server.inject(options)
-
-    Code.expect(response.payload).to.contain('Tyne')
-    Code.expect(response.payload).to.contain('<mark>Tyne</mark>')
-    Code.expect(response.payload).to.contain('Rivers')
-    Code.expect(response.payload).to.contain('More than one match was found for your location.')
-    Code.expect(response.statusCode).to.equal(200)
-  })
-  lab.test('GET /river-and-sea-levels?q=avon returns multiple choice page', async () => {
-    const floodService = require('../../server/services/flood')
-    const fakeStationsData = () => [{
-      river_id: 'river-alne',
-      river_name: 'River Alne',
-      river_qualified_name: 'River Alne',
-      navigable: true,
-      view_rank: 1,
-      rank: '1',
-      rloi_id: 2083,
-      up: null,
-      down: 2048,
-      telemetry_id: '2621',
-      region: 'Midlands',
-      catchment: 'Warwickshire Avon',
-      wiski_river_name: 'River Alne',
-      agency_name: 'Henley River',
-      external_name: 'Henley River',
-      station_type: 'S',
-      status: 'Active',
-      qualifier: 'u',
-      iswales: false,
-      value: '0.414',
-      value_timestamp: '2022-09-26T13:30:00.000Z',
-      value_erred: false,
-      percentile_5: '0.546',
-      percentile_95: '0.387',
-      centroid: '0101000020E6100000068A4FA62670FCBF9C9AE66602264A40',
-      lon: -1.77738060917966,
-      lat: 52.29694830188711,
-      day_total: null,
-      six_hr_total: null,
-      one_hr_total: null,
-      id: '610'
-    }]
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeRiversData = () => [
-      {
-        local_name: 'Little Avon River',
-        qualified_name: 'Little Avon River',
-        other_names: null,
-        river_id: 'little-avon-river'
-      },
-      {
-        local_name: 'River Avon',
-        qualified_name: 'River Avon (Bristol)',
-        other_names: null,
-        river_id: 'river-avon-bristol'
-      },
-      {
-        local_name: 'River Avon',
-        qualified_name: 'River Avon (Corsham)',
-        other_names: null,
-        river_id: 'river-avon-corsham'
-      },
-      {
-        local_name: 'River Avon',
-        qualified_name: 'River Avon (Devon)',
-        other_names: null,
-        river_id: 'river-avon-devon'
-      },
-      {
-        local_name: 'River Avon',
-        qualified_name: 'River Avon (Hampshire)',
-        other_names: null,
-        river_id: 'river-avon-hampshire'
-      },
+    })
+    stubs.getStations.callsFake(() => [])
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [
       {
-        local_name: 'River Avon',
-        qualified_name: 'River Avon (Warwickshire)',
-        other_names: null,
-        river_id: 'river-avon-warwickshire'
+        name: 'River North Tyne',
+        qualified_name: 'River North Tyne',
+        id: 'river-north-tyne'
       },
       {
-        local_name: 'Sherston Avon',
-        qualified_name: 'Sherston Avon',
-        other_names: null,
-        river_id: 'sherston-avon'
+        name: 'River South Tyne',
+        qualified_name: 'River South Tyne',
+        id: 'river-south-tyne'
       },
       {
-        local_name: 'Tetbury Avon',
-        qualified_name: 'Tetbury Avon',
-        other_names: null,
-        river_id: 'tetbury-avon'
-      }
-    ]
-
-    const fakeGetJson = () => data.avonGetJson
-
-    sandbox.stub(floodService, 'getStationsWithin').callsFake(fakeStationsData)
-    sandbox.stub(floodService, 'getRiversByName').callsFake(fakeRiversData)
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
+        name: 'River Tyne',
+        qualified_name: 'River Tyne',
+        id: 'river-tyne'
       }
-    }
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
+    ])
+    stubs.getStationsGeoJson.callsFake(() => data.cachedRainfallStation)
 
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+    // Set cached stationsGeojson
+    const floodService = require('../../server/services/flood')
+    floodService.stationsGeojson = await floodService.getStationsGeoJson()
 
-    await server.initialize()
     const options = {
       method: 'GET',
-      url: '/river-and-sea-levels?q=avon'
+      url: '/river-and-sea-levels?q=tyne'
     }
 
     const response = await server.inject(options)
 
-    const root = parse(response.payload)
-
-    const metaDescription = root
-      .querySelectorAll('[name="description"]')
-
-    Code.expect(metaDescription[0]._attrs.content).to.equal('Find river, sea, groundwater and rainfall levels in England. Check the last updated height, trend and state recorded by the measuring station.')
-    Code.expect(response.payload).to.contain('avon - Find river, sea, groundwater and rainfall levels - GOV.UK')
-    Code.expect(response.payload).to.contain('Levels near')
+    Code.expect(response.payload).to.contain('Tyne')
+    Code.expect(response.payload).to.contain('<mark>Tyne</mark>')
     Code.expect(response.payload).to.contain('Rivers')
     Code.expect(response.payload).to.contain('More than one match was found for your location.')
     Code.expect(response.statusCode).to.equal(200)
   })
-  lab.test('GET /river-and-sea-levels?q=avon&includeTypes=place returns only the place', async () => {
-    const floodService = require('../../server/services/flood')
-    const fakeStationsData = () => [{
-      river_id: 'river-alne',
-      river_name: 'River Alne',
-      navigable: true,
-      view_rank: 1,
-      rank: '1',
-      rloi_id: 2083,
-      up: null,
-      down: 2048,
-      telemetry_id: '2621',
-      region: 'Midlands',
-      catchment: 'Warwickshire Avon',
-      wiski_river_name: 'River Alne',
-      agency_name: 'Henley River',
-      external_name: 'Henley River',
-      station_type: 'S',
-      status: 'Active',
-      qualifier: 'u',
-      iswales: false,
-      value: '0.414',
-      value_timestamp: '2022-09-26T13:30:00.000Z',
-      value_erred: false,
-      percentile_5: '0.546',
-      percentile_95: '0.387',
-      centroid: '0101000020E6100000068A4FA62670FCBF9C9AE66602264A40',
-      lon: -1.77738060917966,
-      lat: 52.29694830188711,
-      day_total: null,
-      six_hr_total: null,
-      one_hr_total: null,
-      id: '610'
-    }]
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-    const fakeRiversData = () => [
-      {
-        name: 'Little Avon River',
-        qualified_name: 'Little Avon River',
-        id: 'little-avon-river'
-      },
-      {
-        name: 'River Avon',
-        qualified_name: 'River Avon (Bristol)',
-        id: 'river-avon-bristol'
-      },
-      {
-        name: 'River Avon',
-        qualified_name: 'River Avon (Corsham)',
-        id: 'river-avon-corsham'
-      },
-      {
-        name: 'River Avon',
-        qualified_name: 'River Avon (Devon)',
-        id: 'river-avon-devon'
-      },
-      {
-        name: 'River Avon',
-        qualified_name: 'River Avon (Hampshire)',
-        id: 'river-avon-hampshire'
-      },
-      {
-        name: 'River Avon',
-        qualified_name: 'River Avon (Warwickshire)',
-        id: 'river-avon-warwickshire'
-      },
-      {
-        name: 'Sherston Avon',
-        qualified_name: 'Sherston Avon',
-        id: 'sherston-avon'
-      },
-      {
-        name: 'Tetbury Avon',
-        qualified_name: 'Tetbury Avon',
-        id: 'tetbury-avon'
-      }
-    ]
-
-    const fakeGetJson = () => data.avonGetJson
-
-    sandbox.stub(floodService, 'getStationsWithin').callsFake(fakeStationsData)
-    sandbox.stub(floodService, 'getRiversByName').callsFake(fakeRiversData)
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
-
-    await server.initialize()
-    const options = {
-      method: 'GET',
-      url: '/river-and-sea-levels?q=avon&includeTypes=place'
-    }
-
-    const response = await server.inject(options)
 
-    Code.expect(response.payload).to.match(/River Alne at[\s\n]+Henley River/)
-    Code.expect(response.statusCode).to.equal(200)
-  })
-  lab.test('GET /river-and-sea-levels?q=avon&includeTypes=river returns only the rivers', async () => {
-    const floodService = require('../../server/services/flood')
-    const fakeStationsData = () => [{
+  lab.test('GET /river-and-sea-levels?q=avon query parameter returns multiple choice page', async () => {
+    stubs.getJson.callsFake(() => data.avonGetJson)
+    stubs.getStationsWithin.callsFake(() => [{
       river_id: 'river-alne',
       river_name: 'River Alne',
+      river_qualified_name: 'River Alne',
       navigable: true,
       view_rank: 1,
       rank: '1',
@@ -2196,102 +680,102 @@ lab.experiment('Test - /river-and-sea-levels', () => {
       six_hr_total: null,
       one_hr_total: null,
       id: '610'
-    }]
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-    const fakeRiversData = () => [
+    }])
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [
       {
-        name: 'Little Avon River',
+        local_name: 'Little Avon River',
         qualified_name: 'Little Avon River',
-        id: 'little-avon-river'
+        other_names: null,
+        river_id: 'little-avon-river'
       },
       {
-        name: 'River Avon',
+        local_name: 'River Avon',
         qualified_name: 'River Avon (Bristol)',
-        id: 'river-avon-bristol'
+        other_names: null,
+        river_id: 'river-avon-bristol'
       },
       {
-        name: 'River Avon',
+        local_name: 'River Avon',
         qualified_name: 'River Avon (Corsham)',
-        id: 'river-avon-corsham'
+        other_names: null,
+        river_id: 'river-avon-corsham'
       },
       {
-        name: 'River Avon',
+        local_name: 'River Avon',
         qualified_name: 'River Avon (Devon)',
-        id: 'river-avon-devon'
+        other_names: null,
+        river_id: 'river-avon-devon'
       },
       {
-        name: 'River Avon',
+        local_name: 'River Avon',
         qualified_name: 'River Avon (Hampshire)',
-        id: 'river-avon-hampshire'
+        other_names: null,
+        river_id: 'river-avon-hampshire'
       },
       {
-        name: 'River Avon',
+        local_name: 'River Avon',
         qualified_name: 'River Avon (Warwickshire)',
-        id: 'river-avon-warwickshire'
+        other_names: null,
+        river_id: 'river-avon-warwickshire'
       },
       {
-        name: 'Sherston Avon',
+        local_name: 'Sherston Avon',
         qualified_name: 'Sherston Avon',
-        id: 'sherston-avon'
+        other_names: null,
+        river_id: 'sherston-avon'
       },
       {
-        name: 'Tetbury Avon',
+        local_name: 'Tetbury Avon',
         qualified_name: 'Tetbury Avon',
-        id: 'tetbury-avon'
-      }
-    ]
-
-    const fakeGetJson = () => data.avonGetJson
-
-    sandbox.stub(floodService, 'getStationsWithin').callsFake(fakeStationsData)
-    sandbox.stub(floodService, 'getRiversByName').callsFake(fakeRiversData)
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
+        other_names: null,
+        river_id: 'tetbury-avon'
       }
-    }
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
+    ])
+    stubs.getStationsGeoJson.callsFake(() => data.cachedRainfallStation)
 
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+    // Set cached stationsGeojson
+    const floodService = require('../../server/services/flood')
+    floodService.stationsGeojson = await floodService.getStationsGeoJson()
 
-    await server.initialize()
     const options = {
       method: 'GET',
-      url: '/river-and-sea-levels?q=avon&includeTypes=river'
+      url: '/river-and-sea-levels?q=avon'
     }
 
     const response = await server.inject(options)
 
-    Code.expect(response.statusCode).to.equal(200)
-
     const root = parse(response.payload)
-    const riverList = root
-      .querySelectorAll('ul.govuk-list#rivers-list li a')
-      .map(a => { return { text: a.textContent, href: a.attributes.href } })
-    Code.expect(riverList.length, 'Number of matching rivers').to.equal(8)
-    Code.expect(riverList, 'River list').to.include({ text: 'Tetbury Avon', href: '/river-and-sea-levels/river/tetbury-avon' })
-
-    const placesList = root.querySelectorAll('ul.govuk-list#places-list li a')
-    Code.expect(placesList.length, 'Number of matching places').to.equal(0)
+
+    const metaDescription = root
+      .querySelectorAll('[name="description"]')
+
+    Code.expect(metaDescription[0]._attrs.content).to.equal('Find river, sea, groundwater and rainfall levels in England. Check the last updated height, trend and state recorded by the measuring station.')
+    Code.expect(response.payload).to.contain('avon - Find river, sea, groundwater and rainfall levels - GOV.UK')
+    Code.expect(response.payload).to.contain('Levels near')
+    Code.expect(response.payload).to.contain('Rivers')
+    Code.expect(response.payload).to.contain('More than one match was found for your location.')
+    Code.expect(response.statusCode).to.equal(200)
   })
-  lab.test('GET /river-and-sea-levels?q=river mersey returns the river stations', async () => {
-    const floodService = require('../../server/services/flood')
-    const fakeStationsData = () => [{
+
+  lab.test('GET /river-and-sea-levels?q=river query parameter returns river stations', async () => {
+    stubs.getJson.callsFake(() => {
+      return {
+        authenticationResultCode: 'ValidCredentials',
+        brandLogoUri: 'http://dev.virtualearth.net/Branding/logo_powered_by.png',
+        copyright: 'Copyright',
+        resourceSets: [
+          {
+            estimatedTotal: 0,
+            resources: []
+          }
+        ],
+        statusCode: 200,
+        statusDescription: 'OK',
+        traceId: 'trace-id'
+      }
+    })
+    stubs.getStationsWithin.callsFake(() => [{
       river_id: 'river-alne',
       river_name: 'River Alne',
       navigable: true,
@@ -2322,60 +806,21 @@ lab.experiment('Test - /river-and-sea-levels', () => {
       six_hr_total: null,
       one_hr_total: null,
       id: '610'
-    }]
-    const fakeRiversData = () => [
+    }])
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
+    stubs.getRiversByName.callsFake(() => [
       {
         name: 'River Mersey',
         qualified_name: 'River Mersey',
         id: 'river-mersey'
       }
-    ]
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-    const fakeGetJson = () => {
-      return {
-        authenticationResultCode: 'ValidCredentials',
-        brandLogoUri: 'http://dev.virtualearth.net/Branding/logo_powered_by.png',
-        copyright: 'Copyright',
-        resourceSets: [
-          {
-            estimatedTotal: 0,
-            resources: []
-          }
-        ],
-        statusCode: 200,
-        statusDescription: 'OK',
-        traceId: 'trace-id'
-      }
-    }
-
-    sandbox.stub(floodService, 'getStationsWithin').callsFake(fakeStationsData)
-    sandbox.stub(floodService, 'getRiversByName').callsFake(fakeRiversData)
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    const util = require('../../server/util')
-    sandbox.stub(util, 'getJson').callsFake(fakeGetJson)
+    ])
+    stubs.getStationsGeoJson.callsFake(() => data.cachedRainfallStation)
 
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+    // Set cached stationsGeojson
+    const floodService = require('../../server/services/flood')
+    floodService.stationsGeojson = await floodService.getStationsGeoJson()
 
-    await server.initialize()
     const options = {
       method: 'GET',
       url: '/river-and-sea-levels?q=river%20mersey'
@@ -2386,75 +831,25 @@ lab.experiment('Test - /river-and-sea-levels', () => {
     Code.expect(response.statusCode).to.equal(302)
     Code.expect(response.headers.location).to.equal('/river-and-sea-levels/river/river-mersey')
   })
-  lab.test('POST /river-and-sea-levels empty query should return start page', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => []
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStations').callsFake(fakeStationsData)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
 
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+  lab.test('POST /river-and-sea-levels with no location payload', async () => {
+    stubs.getStations.callsFake(() => [])
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
 
-    await server.initialize()
     const options = {
       method: 'POST',
       url: '/river-and-sea-levels'
     }
 
     const response = await server.inject(options)
-    Code.expect(response.statusCode).to.equal(200)
+    Code.expect(response.statusCode).to.equal(302)
     Code.expect(response.payload).to.not.contain('No results for')
   })
-  lab.test('POST /river-and-sea-levels empty space query should return start page', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => []
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStations').callsFake(fakeStationsData)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
 
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+  lab.test('POST /river-and-sea-levels with empty location payload', async () => {
+    stubs.getStations.callsFake(() => [])
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
 
-    await server.initialize()
     const options = {
       method: 'POST',
       url: '/river-and-sea-levels',
@@ -2465,36 +860,13 @@ lab.experiment('Test - /river-and-sea-levels', () => {
     Code.expect(response.statusCode).to.equal(200)
     Code.expect(response.payload).to.not.contain('No results for')
   })
-  lab.test('POST /river-and-sea-levels non empty query should redirect', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => []
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStations').callsFake(fakeStationsData)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
 
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+  lab.test('POST /river-and-sea-levels with location payload', async () => {
+    stubs.getJson.callsFake(() => data.warringtonGetJson)
+    stubs.getStations.callsFake(() => [])
+    stubs.getRiversByName.callsFake(() => [])
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
 
-    await server.initialize()
     const options = {
       method: 'POST',
       url: '/river-and-sea-levels',
@@ -2502,134 +874,62 @@ lab.experiment('Test - /river-and-sea-levels', () => {
     }
 
     const response = await server.inject(options)
-    Code.expect(response.statusCode).to.equal(302)
-    Code.expect(response.headers.location).to.equal('/river-and-sea-levels?q=warrington')
+    Code.expect(response.statusCode).to.equal(301)
+    Code.expect(response.headers.location).to.equal('/river-and-sea-levels/warrington')
 
-    Code.expect(response.payload).to.not.contain('Page not found')
     // const root = parse(response.payload)
     // Code.expect(root.querySelectorAll('h2').some(h => h.textContent.trim().startsWith('No results for'))).to.be.false()
     // Code.expect(root.querySelectorAll('table.defra-flood-levels-table#results').length).to.equal(0)
   })
-  lab.test('POST /river-and-sea-levels query parameters should be encoded', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => []
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStations').callsFake(fakeStationsData)
 
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
-
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+  lab.test('POST /river-and-sea-levels with location england should show location not found', async () => {
+    stubs.getJson.callsFake(() => data.nonLocationGetJson)
+    stubs.getStations.callsFake(() => [])
+    stubs.getRiversByName.callsFake(() => [])
+    stubs.getIsEngland.callsFake(() => ({ is_england: true }))
 
-    await server.initialize()
     const options = {
       method: 'POST',
       url: '/river-and-sea-levels',
-      payload: { location: 'newcastle & gateshead' }
+      payload: {
+        location: 'england'
+      }
     }
 
     const response = await server.inject(options)
     Code.expect(response.statusCode).to.equal(302)
-    Code.expect(response.headers.location).to.equal('/river-and-sea-levels?q=newcastle%20%26%20gateshead')
-
-    // const root = parse(response.payload)
-    // Code.expect(root.querySelectorAll('h2').some(h => h.textContent.trim().startsWith('No results for'))).to.be.false()
-    // Code.expect(root.querySelectorAll('table.defra-flood-levels-table#results').length).to.equal(0)
+    Code.expect(response.headers.location).to.equal('/river-and-sea-levels')
   })
-  lab.test('POST /river-and-sea-levels query parameters should display script tags safely', async () => {
-    const floodService = require('../../server/services/flood')
-
-    const fakeIsEngland = () => {
-      return { is_england: true }
-    }
-
-    const fakeStationsData = () => []
-
-    sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-    sandbox.stub(floodService, 'getStations').callsFake(fakeStationsData)
-
-    const riversPlugin = {
-      plugin: {
-        name: 'rivers',
-        register: (server, options) => {
-          server.route(require('../../server/routes/river-and-sea-levels'))
-        }
-      }
-    }
 
-    await server.register(require('../../server/plugins/views'))
-    await server.register(require('../../server/plugins/session'))
-    await server.register(require('../../server/plugins/logging'))
-    await server.register(riversPlugin)
-    // Add Cache methods to server
-    const registerServerMethods = require('../../server/services/server-methods')
-    registerServerMethods(server)
+  lab.test('POST /alerts-and-warnings with special charcters serves 404 error', async () => {
+    stubs.getJson.callsFake(() => [])
+    stubs.getIsEngland.callsFake(() => ({ is_england: false }))
 
-    await server.initialize()
     const options = {
       method: 'POST',
-      url: '/river-and-sea-levels',
-      payload: { location: "<script>alert('TEST')</script>" }
+      url: '/alerts-and-warnings',
+      payload: {
+        location: '<script>alert(\'TEST\')</script>'
+      }
     }
 
     const response = await server.inject(options)
-    Code.expect(response.statusCode).to.equal(200)
-    const root = parse(response.payload)
-    const headers = root.querySelectorAll('h2')
-    Code.expect(headers.some(h => h.text.trim().startsWith("No results for \x3Cscript>alert('TEST')\x3C/script>"))).to.be.false()
+    Code.expect(response.statusCode).to.equal(404)
+    Code.expect(response.result.message).to.equal('Not Found')
   })
+
   lab.experiment('RLOI', () => {
     lab.test('GET /river-and-sea-levels?rloi-id=7224 should redirect', async () => {
-      const floodService = require('../../server/services/flood')
-
-      const fakeStationsData = () => data.stationsWithinRadius
-
-      const originalStation = () => data.riverStation7224
-      const cachedStation = () => data.cachedStation
-
-      sandbox.stub(floodService, 'getStationsByRadius').callsFake(fakeStationsData)
-      sandbox.stub(floodService, 'getStationById').callsFake(originalStation)
-      sandbox.stub(floodService, 'getStationsGeoJson').callsFake(cachedStation)
+      stubs.getJson.callsFake(() => data.warringtonGetJson)
+      stubs.getStationsByRadius.callsFake(() => data.stationsWithinRadius)
+      stubs.getStationById.callsFake(() => data.riverStation7224)
+      stubs.getStationsGeoJson.callsFake(() => data.cachedStation)
+      stubs.getIsEngland.callsFake(() => ({ is_england: true }))
 
       // Set cached stationsGeojson
-
+      const floodService = require('../../server/services/flood')
       floodService.stationsGeojson = await floodService.getStationsGeoJson()
 
-      const riversPlugin = {
-        plugin: {
-          name: 'rivers',
-          register: (server, options) => {
-            server.route(require('../../server/routes/river-and-sea-levels'))
-          }
-        }
-      }
-
-      await server.register(require('../../server/plugins/views'))
-      await server.register(require('../../server/plugins/session'))
-      await server.register(riversPlugin)
-      // Add Cache methods to server
-      const registerServerMethods = require('../../server/services/server-methods')
-      registerServerMethods(server)
-
-      await server.initialize()
       const options = {
         method: 'GET',
         url: '/river-and-sea-levels?rloi-id=7224'
@@ -2640,39 +940,18 @@ lab.experiment('Test - /river-and-sea-levels', () => {
       Code.expect(response.statusCode).to.equal(302)
       Code.expect(response.headers.location).to.equal('/river-and-sea-levels/rloi/7224')
     })
-    lab.test('GET /river-and-sea-levels/rloi/7224', async () => {
-      const floodService = require('../../server/services/flood')
-
-      const fakeStationsData = () => data.stationsWithinRadius
 
-      const originalStation = () => data.riverStation7224
-      const cachedStation = () => data.cachedStation
-
-      sandbox.stub(floodService, 'getStationsByRadius').callsFake(fakeStationsData)
-      sandbox.stub(floodService, 'getStationById').callsFake(originalStation)
-      sandbox.stub(floodService, 'getStationsGeoJson').callsFake(cachedStation)
+    lab.test('GET /river-and-sea-levels/rloi/7224', async () => {
+      stubs.getJson.callsFake(() => data.warringtonGetJson)
+      stubs.getStationsByRadius.callsFake(() => data.stationsWithinRadius)
+      stubs.getStationById.callsFake(() => data.riverStation7224)
+      stubs.getStationsGeoJson.callsFake(() => data.cachedStation)
+      stubs.getIsEngland.callsFake(() => ({ is_england: true }))
 
       // Set cached stationsGeojson
-
+      const floodService = require('../../server/services/flood')
       floodService.stationsGeojson = await floodService.getStationsGeoJson()
 
-      const riversPlugin = {
-        plugin: {
-          name: 'rivers',
-          register: (server, options) => {
-            server.route(require('../../server/routes/river-and-sea-levels'))
-          }
-        }
-      }
-
-      await server.register(require('../../server/plugins/views'))
-      await server.register(require('../../server/plugins/session'))
-      await server.register(riversPlugin)
-      // Add Cache methods to server
-      const registerServerMethods = require('../../server/services/server-methods')
-      registerServerMethods(server)
-
-      await server.initialize()
       const options = {
         method: 'GET',
         url: '/river-and-sea-levels/rloi/7224'
@@ -2686,40 +965,19 @@ lab.experiment('Test - /river-and-sea-levels', () => {
       Code.expect(response.payload).to.contain('Showing levels within 5 miles of Grants Bridge.')
     })
   })
+
   lab.experiment('River', () => {
     lab.test('GET /river-and-sea-levels?river-id=river-nidd should redirect', async () => {
-      const floodService = require('../../server/services/flood')
-
-      const fakeStationsData = () => data.stationsWithinRadius
-
-      const originalStation = () => data.riverStation7224
-      const cachedStation = () => data.cachedStation
-
-      sandbox.stub(floodService, 'getStationsByRadius').callsFake(fakeStationsData)
-      sandbox.stub(floodService, 'getStationById').callsFake(originalStation)
-      sandbox.stub(floodService, 'getStationsGeoJson').callsFake(cachedStation)
+      stubs.getJson.callsFake(() => data.warringtonGetJson)
+      stubs.getStationsByRadius.callsFake(() => data.stationsWithinRadius)
+      stubs.getStationById.callsFake(() => data.riverStation7224)
+      stubs.getStationsGeoJson.callsFake(() => data.cachedStation)
+      stubs.getIsEngland.callsFake(() => ({ is_england: true }))
 
       // Set cached stationsGeojson
-
+      const floodService = require('../../server/services/flood')
       floodService.stationsGeojson = await floodService.getStationsGeoJson()
 
-      const riversPlugin = {
-        plugin: {
-          name: 'rivers',
-          register: (server, options) => {
-            server.route(require('../../server/routes/river-and-sea-levels'))
-          }
-        }
-      }
-
-      await server.register(require('../../server/plugins/views'))
-      await server.register(require('../../server/plugins/session'))
-      await server.register(riversPlugin)
-      // Add Cache methods to server
-      const registerServerMethods = require('../../server/services/server-methods')
-      registerServerMethods(server)
-
-      await server.initialize()
       const options = {
         method: 'GET',
         url: '/river-and-sea-levels?riverId=river-nidd'
@@ -2730,30 +988,10 @@ lab.experiment('Test - /river-and-sea-levels', () => {
       Code.expect(response.statusCode).to.equal(302)
       Code.expect(response.headers.location).to.equal('/river-and-sea-levels/river/river-nidd')
     })
-    lab.test('GET /river-and-sea-levels/river/river-nidd', async () => {
-      const floodService = require('../../server/services/flood')
-
-      const riverStation = () => data.riverNiddStations
-
-      sandbox.stub(floodService, 'getRiverById').callsFake(riverStation)
-
-      const riversPlugin = {
-        plugin: {
-          name: 'rivers',
-          register: (server, options) => {
-            server.route(require('../../server/routes/river-and-sea-levels'))
-          }
-        }
-      }
 
-      await server.register(require('../../server/plugins/views'))
-      await server.register(require('../../server/plugins/session'))
-      await server.register(riversPlugin)
-      // Add Cache methods to server
-      const registerServerMethods = require('../../server/services/server-methods')
-      registerServerMethods(server)
+    lab.test('GET /river-and-sea-levels/river/river-nidd', async () => {
+      stubs.getRiverById.callsFake(() => data.riverNiddStations)
 
-      await server.initialize()
       const options = {
         method: 'GET',
         url: '/river-and-sea-levels/river/river-nidd'
@@ -2768,36 +1006,11 @@ lab.experiment('Test - /river-and-sea-levels', () => {
       const riversTab = root.querySelectorAll('ul#filter.defra-navbar__list li.defra-navbar__item--selected')[0].text.trim()
       Code.expect(riversTab).to.be.equal('River (6)')
     })
-    lab.test('GET /river-and-sea-levels - Check for related content links', async () => {
-      const floodService = require('../../server/services/flood')
-
-      const fakeIsEngland = () => {
-        return { is_england: true }
-      }
-
-      const fakeStationsData = () => []
-
-      sandbox.stub(floodService, 'getIsEngland').callsFake(fakeIsEngland)
-      sandbox.stub(floodService, 'getStations').callsFake(fakeStationsData)
 
-      const riversPlugin = {
-        plugin: {
-          name: 'rivers',
-          register: (server, options) => {
-            server.route(require('../../server/routes/river-and-sea-levels'))
-          }
-        }
-      }
-
-      await server.register(require('../../server/plugins/views'))
-      await server.register(require('../../server/plugins/session'))
-      await server.register(require('../../server/plugins/logging'))
-      await server.register(riversPlugin)
-      // Add Cache methods to server
-      const registerServerMethods = require('../../server/services/server-methods')
-      registerServerMethods(server)
+    lab.test('GET /river-and-sea-levels - Check for related content links', async () => {
+      stubs.getStations.callsFake(() => [])
+      stubs.getIsEngland.callsFake(() => ({ is_england: true }))
 
-      await server.initialize()
       const options = {
         method: 'GET',
         url: '/river-and-sea-levels'
@@ -2812,14 +1025,3 @@ lab.experiment('Test - /river-and-sea-levels', () => {
     })
   })
 })
-
-function checkTitleAndDescription (root, title, description) {
-  const metaDescription = root
-    .querySelectorAll('[name="description"]')
-
-  const metaTitle = root
-    .querySelectorAll('[property="og:title"]')
-
-  Code.expect(metaDescription[0]._attrs.content).to.equal(description)
-  Code.expect(metaTitle[0]._attrs.content).to.contain(title)
-}

From f2990edc77429676535034a7b6c77844ef1900bd Mon Sep 17 00:00:00 2001
From: nikiwycherley <niki.wycherley@environment-agency.gov.uk>
Date: Mon, 15 Jul 2024 15:36:18 +0100
Subject: [PATCH 25/29] Release 8.5.0 (#744)

* Bump version number (8.5.0)

* Add release notes (8.5.0)

* Update CFF-8.5.0.md

---------

Co-authored-by: GitHub Actions <actions@github.com>
Co-authored-by: Lee Gordon <40238160+LeeGordon83@users.noreply.github.com>
---
 package-lock.json         |  4 ++--
 package.json              |  2 +-
 release-docs/CFF-8.5.0.md | 27 +++++++++++++++++++++++++++
 3 files changed, 30 insertions(+), 3 deletions(-)
 create mode 100644 release-docs/CFF-8.5.0.md

diff --git a/package-lock.json b/package-lock.json
index 1a4c5d737..e3385483a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "flood-app",
-  "version": "8.4.0",
+  "version": "8.5.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "flood-app",
-      "version": "8.4.0",
+      "version": "8.5.0",
       "hasInstallScript": true,
       "license": "ISC",
       "dependencies": {
diff --git a/package.json b/package.json
index d157f917b..96ee182e3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "flood-app",
-  "version": "8.4.0",
+  "version": "8.5.0",
   "description": "Flood risk app",
   "main": "index.js",
   "repository": "github:defra/flood-app",
diff --git a/release-docs/CFF-8.5.0.md b/release-docs/CFF-8.5.0.md
new file mode 100644
index 000000000..3ec86f03b
--- /dev/null
+++ b/release-docs/CFF-8.5.0.md
@@ -0,0 +1,27 @@
+# Check For Flooding Release
+
+* Version: 8.5.0
+* Proposed Release Date: 17th July 2024
+* Jira Release Overview: https://eaflood.atlassian.net/projects/FSR/versions/17136/tab/release-report-all-issues
+
+
+## Tickets
+
+  
+  * FSR-1208 | river and sea levels search redirects (#723)
+  
+  * FSR-1207 | update page title to use place name
+ 
+
+  
+## Instructions
+
+
+  1 - Execute LFW_{STAGE}_04_UPDATE_FLOOD_APP_AND_SERVICE_PIPELINE
+
+
+Execute smoke tests and forward results
+
+## Related Infrastructure Changes Required
+
+* None

From f9976fb4fe613bcedfa3f2ff3bf95fde626088bb Mon Sep 17 00:00:00 2001
From: LeeGordon83 <lee.gordon83@gmail.com>
Date: Mon, 15 Jul 2024 15:51:56 +0100
Subject: [PATCH 26/29] Revert "Release 8.5.0 (#744)"

This reverts commit 534a131a89873d8e54866e278087acb2d1da9587.
---
 package-lock.json         |  4 ++--
 package.json              |  2 +-
 release-docs/CFF-8.5.0.md | 27 ---------------------------
 3 files changed, 3 insertions(+), 30 deletions(-)
 delete mode 100644 release-docs/CFF-8.5.0.md

diff --git a/package-lock.json b/package-lock.json
index e3385483a..1a4c5d737 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "flood-app",
-  "version": "8.5.0",
+  "version": "8.4.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "flood-app",
-      "version": "8.5.0",
+      "version": "8.4.0",
       "hasInstallScript": true,
       "license": "ISC",
       "dependencies": {
diff --git a/package.json b/package.json
index 96ee182e3..d157f917b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "flood-app",
-  "version": "8.5.0",
+  "version": "8.4.0",
   "description": "Flood risk app",
   "main": "index.js",
   "repository": "github:defra/flood-app",
diff --git a/release-docs/CFF-8.5.0.md b/release-docs/CFF-8.5.0.md
deleted file mode 100644
index 3ec86f03b..000000000
--- a/release-docs/CFF-8.5.0.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# Check For Flooding Release
-
-* Version: 8.5.0
-* Proposed Release Date: 17th July 2024
-* Jira Release Overview: https://eaflood.atlassian.net/projects/FSR/versions/17136/tab/release-report-all-issues
-
-
-## Tickets
-
-  
-  * FSR-1208 | river and sea levels search redirects (#723)
-  
-  * FSR-1207 | update page title to use place name
- 
-
-  
-## Instructions
-
-
-  1 - Execute LFW_{STAGE}_04_UPDATE_FLOOD_APP_AND_SERVICE_PIPELINE
-
-
-Execute smoke tests and forward results
-
-## Related Infrastructure Changes Required
-
-* None

From 01e8ed0ec27c9d2b7f4dc09f604b628c3d394ac5 Mon Sep 17 00:00:00 2001
From: GitHub Actions <actions@github.com>
Date: Tue, 16 Jul 2024 09:52:03 +0100
Subject: [PATCH 27/29] Bump version number (8.5.0)

---
 package-lock.json | 4 ++--
 package.json      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 1a4c5d737..e3385483a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "flood-app",
-  "version": "8.4.0",
+  "version": "8.5.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "flood-app",
-      "version": "8.4.0",
+      "version": "8.5.0",
       "hasInstallScript": true,
       "license": "ISC",
       "dependencies": {
diff --git a/package.json b/package.json
index d157f917b..96ee182e3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "flood-app",
-  "version": "8.4.0",
+  "version": "8.5.0",
   "description": "Flood risk app",
   "main": "index.js",
   "repository": "github:defra/flood-app",

From 04c48eacb1e3adddca4850a16262a427743a56f8 Mon Sep 17 00:00:00 2001
From: GitHub Actions <actions@github.com>
Date: Tue, 16 Jul 2024 09:52:24 +0100
Subject: [PATCH 28/29] Add release notes (8.5.0)

---
 release-docs/CFF-8.5.0.md | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 release-docs/CFF-8.5.0.md

diff --git a/release-docs/CFF-8.5.0.md b/release-docs/CFF-8.5.0.md
new file mode 100644
index 000000000..89127a0e0
--- /dev/null
+++ b/release-docs/CFF-8.5.0.md
@@ -0,0 +1,39 @@
+# Check For Flooding Release
+
+* Version: 8.5.0
+* Proposed Release Date: 
+* Jira Release Overview: https://eaflood.atlassian.net/projects/FSR/versions/17136/tab/release-report-all-issues
+
+## Sense Check
+
+* Note that this is the definitive release notes for WebOps. The release notes in flood-service and flood-db are for CFF dev team use only.
+* Cross check the list of Jira tickets below with those in the Jira release linked to above and update where needed
+* Add additional Jira tickets from the related release notes in the 'Release 8.5.0' PR's created in:
+  * [flood-service](https://github.com/DEFRA/flood-service)
+
+* Add any required infrastructure changes such as redirects to the infrastructure changes section below
+* Once this sense check is done, delete this section
+
+## Tickets
+
+
+  
+  * FSR-1208 | river and sea levels search redirects (#723)
+  
+  * FSR-1207 | update page title to use place name
+  
+  * FSR-1207 | remove commented out code
+  
+
+
+## Instructions
+
+
+  1 - Execute LFW_{STAGE}_04_UPDATE_FLOOD_APP_AND_SERVICE_PIPELINE
+
+
+Execute smoke tests and forward results
+
+## Related Infrastructure Changes Required
+
+* None

From 95700b1afccb5caded2900abcf17c93229db8853 Mon Sep 17 00:00:00 2001
From: Lee Gordon <40238160+LeeGordon83@users.noreply.github.com>
Date: Tue, 16 Jul 2024 09:54:20 +0100
Subject: [PATCH 29/29] Update CFF-8.5.0.md

---
 release-docs/CFF-8.5.0.md | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/release-docs/CFF-8.5.0.md b/release-docs/CFF-8.5.0.md
index 89127a0e0..fa1fb41fe 100644
--- a/release-docs/CFF-8.5.0.md
+++ b/release-docs/CFF-8.5.0.md
@@ -1,18 +1,9 @@
 # Check For Flooding Release
 
 * Version: 8.5.0
-* Proposed Release Date: 
+* Proposed Release Date: 17th July 2024
 * Jira Release Overview: https://eaflood.atlassian.net/projects/FSR/versions/17136/tab/release-report-all-issues
 
-## Sense Check
-
-* Note that this is the definitive release notes for WebOps. The release notes in flood-service and flood-db are for CFF dev team use only.
-* Cross check the list of Jira tickets below with those in the Jira release linked to above and update where needed
-* Add additional Jira tickets from the related release notes in the 'Release 8.5.0' PR's created in:
-  * [flood-service](https://github.com/DEFRA/flood-service)
-
-* Add any required infrastructure changes such as redirects to the infrastructure changes section below
-* Once this sense check is done, delete this section
 
 ## Tickets
 
@@ -22,8 +13,6 @@
   
   * FSR-1207 | update page title to use place name
   
-  * FSR-1207 | remove commented out code
-  
 
 
 ## Instructions