Support test scenarios (#26)

* Add support for hard coded test scenarios for user research
* Add support for test scenarios and force first clinic of the day to screening

Author: edwardhorsford

app/data/breast-screening-units.js

@@ -17,13 +17,13 @@ module.exports = [
     clinicTypes: ['screening', 'assessment'], // Can do both
     // Default operating hours for the BSU
     sessionPatterns: [
-      {
-        name: 'full_day',
-        type: 'single',
-        sessions: [
-          { startTime: '09:00', endTime: '17:00' },
-        ],
-      },
+      // {
+      //   name: 'full_day',
+      //   type: 'single',
+      //   sessions: [
+      //     { startTime: '09:00', endTime: '17:00' },
+      //   ],
+      // },
       {
         name: 'split_day',
         type: 'paired',

app/data/test-scenarios.js

@@ -0,0 +1,46 @@
+// app/data/test-scenarios.js
+
+/**
+ * Test scenarios define specific participants and events that should always exist
+ * in the generated data. This ensures we have consistent test cases.
+ * 
+ * Only specify what needs to be consistent - any unspecified fields will be randomly generated.
+ * This allows natural variation while maintaining key test conditions.
+ */
+module.exports = [
+  {
+    participant: {
+      id: 'bc724e9f',
+      demographicInformation: {
+        firstName: 'Janet',
+        middleName: null,
+        lastName: 'Williams',
+        dateOfBirth: '1959-07-22',
+      },
+      extraNeeds: ['Wheelchair user'],
+    },
+    scheduling: {
+      whenRelativeToToday: 0,
+      status: 'scheduled', 
+      approximateTime: '10:30',
+    },
+  },
+  {
+    participant: {
+      id: 'aab45c3d',
+      demographicInformation: {
+        firstName: 'Dianna',
+        lastName: 'McIntosh',
+        middleName: 'Rose',
+        dateOfBirth: '1964-03-15',
+      },
+      extraNeeds: null,
+    },
+    scheduling: {
+      whenRelativeToToday: 0,
+      status: 'checked_in',
+      approximateTime: '11:30',
+      // slotIndex: 20,
+    },
+  },
+]

app/lib/generate-seed-data.js

@@ -16,69 +16,148 @@ const { generateEvent } = require('./generators/event-generator')
 const breastScreeningUnits = require('../data/breast-screening-units')
 const ethnicities = require('../data/ethnicities')
 
-const generateSnapshot = (date, allParticipants, unit) => {
+// Hardcoded scenarios for user research
+const testScenarios = require('../data/test-scenarios')
+
+// Find nearest slot at or after the target time
+// Used by test scenarios so we can populate a slot at a given time
+const findNearestSlot = (slots, targetTime) => {
+  if (!targetTime) return null
+
+  const [targetHour, targetMinute] = targetTime.split(':').map(Number)
+  const targetMinutes = targetHour * 60 + targetMinute
+
+  // Filter to only slots at or after target time
+  const eligibleSlots = slots.filter(slot => {
+    const slotTime = dayjs(slot.dateTime)
+    const slotMinutes = slotTime.hour() * 60 + slotTime.minute()
+    return slotMinutes >= targetMinutes
+  })
+
+  if (eligibleSlots.length === 0) return null
+
+  // Find the nearest from eligible slots
+  return eligibleSlots.reduce((nearest, slot) => {
+    const slotTime = dayjs(slot.dateTime)
+    const slotMinutes = slotTime.hour() * 60 + slotTime.minute()
+    
+    if (!nearest) return slot
+
+    const currentDiff = Math.abs(targetMinutes - slotMinutes)
+    const nearestDiff = Math.abs(
+      targetMinutes - 
+      (dayjs(nearest.dateTime).hour() * 60 + dayjs(nearest.dateTime).minute())
+    )
+
+    return currentDiff < nearestDiff ? slot : nearest
+  })
+}
+
+const generateClinicsForDay = (date, allParticipants, unit) => {
   const clinics = []
   const events = []
   const usedParticipantsInSnapshot = new Set()
   const participants = [...allParticipants]
 
+  // Check if this snapshot date is for the recent period (not historical)
+  const isRecentSnapshot = dayjs(date).isAfter(dayjs().subtract(1, 'month'))
+
+  // Only look for test scenarios in recent snapshots
+  const testScenariosForDay = isRecentSnapshot 
+    ? testScenarios.filter(scenario => {
+        const targetDate = dayjs().startOf('day').add(scenario.scheduling.whenRelativeToToday, 'day')
+        return targetDate.isSame(dayjs(date).startOf('day'), 'day')
+      })
+    : []
+
   // Pre-filter eligible participants once
   const clinicDate = dayjs(date)
   const eligibleParticipants = participants.filter(p => {
     const age = clinicDate.diff(dayjs(p.demographicInformation.dateOfBirth), 'year')
     return age >= 50 && age <= 70
   })
 
-  // Generate a 5 days of clinics
-  for (let i = 0; i < config.clinics.daysToGenerate; i++) {
-    const clinicDate = dayjs(date).add(i, 'day')
-    const newClinics = generateClinicsForBSU({
-      date: clinicDate.toDate(),
-      breastScreeningUnit: unit,
-    })
+  // Generate clinics for this day
+  const newClinics = generateClinicsForBSU({
+    date: date.toDate(),
+    breastScreeningUnit: unit,
+  })
+
+  // For test scenarios, only use first clinic of the day
+  if (testScenariosForDay.length > 0 && newClinics.length > 0) {
+    const firstClinic = newClinics[0]
+    
+    testScenariosForDay.forEach(scenario => {
+      const participant = participants.find(p => p.id === scenario.participant.id)
+      if (!participant) return
 
-    newClinics.forEach(clinic => {
-      const bookableSlots = clinic.slots
-        .filter(() => Math.random() < config.generation.bookingProbability)
-
-      bookableSlots.forEach(slot => {
-        // Filter from pre-filtered eligible participants
-        const availableParticipants = eligibleParticipants.filter(p =>
-          !usedParticipantsInSnapshot.has(p.id)
-        )
-
-        // If we need more participants, create them
-        if (availableParticipants.length === 0) {
-          const newParticipant = generateParticipant({
-            ethnicities,
-            breastScreeningUnits: [unit],
-          })
-          participants.push(newParticipant)
-          availableParticipants.push(newParticipant)
-        }
-
-        for (let i = 0; i < slot.capacity; i++) {
-          if (availableParticipants.length === 0) break
-          const randomIndex = Math.floor(Math.random() * availableParticipants.length)
-          const participant = availableParticipants[randomIndex]
-
-          const event = generateEvent({
-            slot,
-            participant,
-            clinic,
-            outcomeWeights: config.screening.outcomes[clinic.clinicType],
-          })
-
-          events.push(event)
-          usedParticipantsInSnapshot.add(participant.id)
-          availableParticipants.splice(randomIndex, 1)
-        }
+      const slot = scenario.scheduling.slotIndex !== undefined
+        ? firstClinic.slots[scenario.scheduling.slotIndex]
+        : findNearestSlot(firstClinic.slots, scenario.scheduling.approximateTime)
+
+      if (!slot) {
+        console.log(`Warning: Could not find suitable slot for test participant ${participant.id}`)
+        return
+      }
+
+      const event = generateEvent({
+        slot,
+        participant,
+        clinic: firstClinic,
+        outcomeWeights: config.screening.outcomes[firstClinic.clinicType],
+        forceStatus: scenario.scheduling.status,
       })
 
-      clinics.push(clinic)
+      events.push(event)
+      usedParticipantsInSnapshot.add(participant.id)
     })
   }
 
+  // Handle regular clinic slot allocation for all clinics
+  newClinics.forEach(clinic => {
+    // Continue with random slot allocation as before
+    const remainingSlots = clinic.slots
+      .filter(() => Math.random() < config.generation.bookingProbability)
+      // Filter out slots used by test participants
+      .filter(slot => !events.some(e => e.slotId === slot.id))
+
+    remainingSlots.forEach(slot => {
+      // Filter from pre-filtered eligible participants
+      const availableParticipants = eligibleParticipants.filter(p =>
+        !usedParticipantsInSnapshot.has(p.id)
+      )
+
+      // If we need more participants, create them
+      if (availableParticipants.length === 0) {
+        const newParticipant = generateParticipant({
+          ethnicities,
+          breastScreeningUnits: [unit],
+        })
+        participants.push(newParticipant)
+        availableParticipants.push(newParticipant)
+      }
+
+      for (let i = 0; i < slot.capacity; i++) {
+        if (availableParticipants.length === 0) break
+        const randomIndex = Math.floor(Math.random() * availableParticipants.length)
+        const participant = availableParticipants[randomIndex]
+
+        const event = generateEvent({
+          slot,
+          participant,
+          clinic,
+          outcomeWeights: config.screening.outcomes[clinic.clinicType],
+        })
+
+        events.push(event)
+        usedParticipantsInSnapshot.add(participant.id)
+        availableParticipants.splice(randomIndex, 1)
+      }
+    })
+
+    clinics.push(clinic)
+  })
+
   return {
     clinics,
     events,
@@ -91,24 +170,54 @@ const generateData = async () => {
     fs.mkdirSync(config.paths.generatedData, { recursive: true })
   }
 
-  console.log('Generating initial participants...')
-  const participants = Array.from(
+  // Create test participants first, using generateParticipant but with overrides
+  console.log('Generating test scenario participants...')
+  const testParticipants = testScenarios.map(scenario => {
+    return generateParticipant({
+      ethnicities,
+      breastScreeningUnits,
+      overrides: scenario.participant,
+    })
+  })
+
+  console.log('Generating random participants...')
+  const randomParticipants = Array.from(
     { length: config.generation.numberOfParticipants },
     () => generateParticipant({ ethnicities, breastScreeningUnits })
   )
 
+  // Combine test and random participants
+  const participants = [...testParticipants, ...randomParticipants]
+
   console.log('Generating clinics and events...')
   const today = dayjs().startOf('day')
-  const snapshots = [
-    today.subtract(9, 'year').add(3, 'month'),
-    today.subtract(6, 'year').add(2, 'month'),
-    today.subtract(3, 'year').add(1, 'month'),
-    today.subtract(config.clinics.daysBeforeToday, 'days'),
+
+  // Helper function to generate multiple days from a start date
+  const generateDayRange = (startDate, numberOfDays) => {
+    return Array.from(
+      { length: numberOfDays },
+      (_, i) => dayjs(startDate).add(i, 'days')
+    )
+  }
+
+  // Generate days for each historical period
+  const historicalSnapshots = [
+    ...generateDayRange(today.subtract(9, 'year').add(3, 'month'), config.clinics.daysToGenerate),
+    ...generateDayRange(today.subtract(6, 'year').add(2, 'month'), config.clinics.daysToGenerate),
+    ...generateDayRange(today.subtract(3, 'year').add(1, 'month'), config.clinics.daysToGenerate),
   ]
 
+  // Generate recent days
+  const recentSnapshots = generateDayRange(
+    today.subtract(config.clinics.daysBeforeToday, 'days'),
+    config.clinics.daysToGenerate
+  )
+
+  const snapshots = [...historicalSnapshots, ...recentSnapshots]
+
   // Generate all data in batches per BSU
   const allData = breastScreeningUnits.map(unit => {
-    const unitSnapshots = snapshots.map(date => generateSnapshot(date, participants, unit))
+    const unitSnapshots = snapshots.map(date => generateClinicsForDay(date, participants, unit))
     return {
       clinics: [].concat(...unitSnapshots.map(s => s.clinics)),
       events: [].concat(...unitSnapshots.map(s => s.events)),
@@ -124,6 +233,17 @@ const generateData = async () => {
   // Combine initial and new participants
   const finalParticipants = [...participants, ...allNewParticipants]
 
+  // Sort events by start time within each clinic
+  const sortedEvents = allEvents.sort((a, b) => {
+    // First sort by clinic ID to group events together
+    if (a.clinicId !== b.clinicId) {
+      return a.clinicId.localeCompare(b.clinicId)
+    }
+    // Then by start time within each clinic
+    return new Date(a.timing.startTime) - new Date(b.timing.startTime)
+  })
+
+
   // breastScreeningUnits.forEach(unit => {
   //   snapshots.forEach(date => {
   //     const { clinics, events, newParticipants } = generateSnapshot(date, participants, unit);
@@ -147,7 +267,7 @@ const generateData = async () => {
       slots: clinic.slots.sort((a, b) => new Date(a.dateTime) - new Date(b.dateTime)),
     })),
   })
-  writeData('events.json', { events: allEvents })
+  writeData('events.json', { events: sortedEvents })
   writeData('generation-info.json', {
     generatedAt: new Date().toISOString(),
     stats: {