fix: failed request assertion not found

src/commands/monika.ts

@@ -25,15 +25,13 @@
 import { Command, Errors } from '@oclif/core'
 import pEvent from 'p-event'
 import type { ValidatedConfig } from '../interfaces/config'
-import type { Probe } from '../interfaces/probe'
 
 import {
   getValidatedConfig,
   isSymonModeFrom,
   initConfig,
 } from '../components/config'
 import { createConfig } from '../components/config/create'
-import { sortProbes } from '../components/config/sort'
 import { printAllLogs } from '../components/logger'
 import { flush } from '../components/logger/flush'
 import { closeLog } from '../components/logger/history'
@@ -43,10 +41,10 @@ import { sendMonikaStartMessage } from '../components/notification/start-message
 import { printSummary } from '../components/summary'
 import { getContext, setContext } from '../context'
 import events from '../events'
-import { type MonikaFlags, sanitizeFlags, flags } from '../flag'
+import { sanitizeFlags, flags } from '../flag'
 import { savePidFile } from '../jobs/summary-notification'
 import initLoaders from '../loaders'
-import { sanitizeProbe, startProbing } from '../looper'
+import { startProbing } from '../looper'
 import SymonClient from '../symon'
 import { getEventEmitter } from '../utils/events'
 import { log } from '../utils/pino'
@@ -57,6 +55,7 @@ import {
   close as closeSentry,
   flush as flushSentry,
 } from '@sentry/node'
+import { getProbes } from '../components/config/probe'
 
 const em = getEventEmitter()
 let symonClient: SymonClient
@@ -163,7 +162,7 @@ export default class Monika extends Command {
 
       for (;;) {
         const config = getValidatedConfig()
-        const probes = getProbes({ config, flags })
+        const probes = getProbes()
 
         // emit the sanitized probe
         em.emit(events.config.sanitized, probes)
@@ -231,19 +230,6 @@ async function logRunningInfo({ isVerbose, isSymonMode }: RunningInfoParams) {
   }
 }
 
-type GetProbesParams = {
-  config: ValidatedConfig
-  flags: MonikaFlags
-}
-
-function getProbes({ config, flags }: GetProbesParams): Probe[] {
-  const sortedProbes = sortProbes(config.probes, flags.id)
-
-  return sortedProbes.map((probe: Probe) =>
-    sanitizeProbe(isSymonModeFrom(flags), probe)
-  )
-}
-
 function deprecationHandler(config: ValidatedConfig): ValidatedConfig {
   const showDeprecateMsg: Record<'query', boolean> = {
     query: false,

src/components/config/index.test.ts

@@ -308,3 +308,98 @@ describe('Setup Config', () => {
     ).not.undefined
   })
 })
+
+describe('sanitizeConfig', () => {
+  beforeEach(() => {
+    resetContext()
+  })
+
+  it('should sanitize probes in normal mode', () => {
+    // arrange
+    const config = {
+      probes: [
+        {
+          id: '1',
+          name: 'Test probe',
+          interval: 1000,
+          requests: [
+            {
+              url: 'https://example.com',
+              body: '',
+              followRedirects: 21,
+              timeout: 1000,
+            },
+          ],
+          alerts: [],
+        },
+      ],
+    }
+
+    // act
+    const result = sanitizeConfig(config)
+
+    // assert
+    expect(result.probes[0].alerts).to.have.lengthOf(1)
+    expect(result.probes[0].alerts[0]).to.include({
+      assertion: '',
+      message: 'Probe not accessible',
+    })
+  })
+
+  it('should sanitize probes in Symon mode', () => {
+    // arrange
+    setContext({
+      flags: sanitizeFlags({
+        symonKey: 'test-key',
+        symonUrl: 'https://example.com',
+      }),
+    })
+    const config = {
+      probes: [
+        {
+          id: '1',
+          name: 'Test probe',
+          interval: 30_000,
+          requests: [
+            {
+              url: 'https://example.com',
+              body: '',
+              followRedirects: 21,
+              timeout: 1000,
+            },
+          ],
+          alerts: [],
+        },
+      ],
+    }
+
+    // act
+    const result = sanitizeConfig(config)
+
+    // assert
+    expect(result.probes[0].alerts).to.have.lengthOf(0)
+    expect(result.probes[0].id).to.equal('1')
+    expect(result.probes[0].interval).to.equal(30_000)
+  })
+
+  it('should preserve existing config properties', () => {
+    // arrange
+    const config: Config = {
+      version: '1.0.0',
+      notifications: [{ id: 'test-1', type: 'smtp' }],
+      certificate: {
+        domains: ['example.com'],
+        reminder: 15,
+      },
+      probes: [],
+    }
+
+    // act
+    const result = sanitizeConfig(config)
+
+    // assert
+    expect(result.version).to.equal('1.0.0')
+    expect(result.notifications).to.deep.equal([{ id: 'test-1', type: 'smtp' }])
+    expect(result.certificate?.reminder).to.equal(15)
+  })
+})

src/components/config/sanitize.ts

@@ -4,14 +4,19 @@ import type {
   Config,
   ValidatedConfig,
 } from '../../interfaces/config'
+import { sanitizeProbe } from '../../looper'
+import { isSymonModeFrom } from '.'
+import { getContext } from '../../context'
 
 const DEFAULT_TLS_EXPIRY_REMINDER_DAYS = 30
 const DEFAULT_STATUS_NOTIFICATION = '0 6 * * *'
 
 export function sanitizeConfig(config: Config): ValidatedConfig {
-  const { certificate, notifications = [], version } = config
-  const sanitizedConfigWithoutVersion = {
+  const isSymonMode = isSymonModeFrom(getContext().flags)
+  const { certificate, notifications = [], version, probes } = config
+  const sanitizedConfigWithoutVersion: Omit<ValidatedConfig, 'version'> = {
     ...config,
+    probes: probes.map((probe) => sanitizeProbe(isSymonMode, probe)),
     certificate: sanitizeCertificate(certificate),
     notifications,
     'status-notification':

src/looper/index.ts

@@ -79,10 +79,15 @@ export const FAILED_REQUEST_ASSERTION = {
 }
 
 function addFailedRequestAssertions(assertions: ProbeAlert[]) {
+  // create uuid seed from FAILED_REQUEST_ASSERTION
+  // to make the id deterministic, consistent, and testable
+  const idSeed = Buffer.from(JSON.stringify(FAILED_REQUEST_ASSERTION))
   return [
     ...assertions,
     {
-      id: uuid(),
+      id: uuid({
+        random: idSeed,
+      }),
       ...FAILED_REQUEST_ASSERTION,
     },
   ]