fix: Group alert histories by evaluation time

Author: pulpdrew

packages/api/src/controllers/__tests__/alertHistory.test.ts

@@ -0,0 +1,378 @@
+import { ObjectId } from 'mongodb';
+
+import { getRecentAlertHistories } from '@/controllers/alertHistory';
+import { clearDBCollections, closeDB, connectDB } from '@/fixtures';
+import Alert, { AlertState } from '@/models/alert';
+import AlertHistory from '@/models/alertHistory';
+import Team from '@/models/team';
+
+describe('alertHistory controller', () => {
+  beforeAll(async () => {
+    await connectDB();
+  });
+
+  afterEach(async () => {
+    await clearDBCollections();
+  });
+
+  afterAll(async () => {
+    await closeDB();
+  });
+
+  describe('getRecentAlertHistories', () => {
+    it('should return alert histories grouped by createdAt', async () => {
+      // Create test team and alert
+      const team = await Team.create({
+        name: 'Test Team',
+      });
+
+      const alert = await Alert.create({
+        channel: { type: null },
+        interval: '15m',
+        state: AlertState.OK,
+        team: team._id,
+        threshold: 10,
+        thresholdType: 'above',
+      });
+
+      // Create alert histories with 3 distinct createdAt values
+      const date1 = new Date('2024-01-01T10:00:00Z');
+      const date2 = new Date('2024-01-01T10:15:00Z');
+      const date3 = new Date('2024-01-01T10:30:00Z');
+
+      await AlertHistory.create([
+        {
+          alert: alert._id,
+          counts: 5,
+          createdAt: date1,
+          state: AlertState.OK,
+          lastValues: [{ startTime: date1, count: 5 }],
+        },
+        {
+          alert: alert._id,
+          counts: 12,
+          createdAt: date2,
+          state: AlertState.ALERT,
+          lastValues: [{ startTime: date2, count: 12 }],
+        },
+        {
+          alert: alert._id,
+          counts: 8,
+          createdAt: date3,
+          state: AlertState.OK,
+          lastValues: [{ startTime: date3, count: 8 }],
+        },
+      ]);
+
+      const results = await getRecentAlertHistories({
+        alertId: new ObjectId(alert._id),
+        createdAtLimit: 3,
+      });
+
+      expect(results).toHaveLength(3);
+      expect(results[0].counts).toBe(8); // Most recent
+      expect(results[1].counts).toBe(12);
+      expect(results[2].counts).toBe(5); // Oldest
+    });
+
+    it('should respect createdAtLimit parameter', async () => {
+      const team = await Team.create({
+        name: 'Test Team',
+      });
+
+      const alert = await Alert.create({
+        channel: { type: null },
+        interval: '15m',
+        state: AlertState.OK,
+        team: team._id,
+        threshold: 10,
+        thresholdType: 'above',
+      });
+
+      // Create 5 alert histories with distinct createdAt values
+      const dates = [
+        new Date('2024-01-01T10:00:00Z'),
+        new Date('2024-01-01T10:15:00Z'),
+        new Date('2024-01-01T10:30:00Z'),
+        new Date('2024-01-01T10:45:00Z'),
+        new Date('2024-01-01T11:00:00Z'),
+      ];
+
+      for (const date of dates) {
+        await AlertHistory.create({
+          alert: alert._id,
+          counts: 5,
+          createdAt: date,
+          state: AlertState.OK,
+          lastValues: [{ startTime: date, count: 5 }],
+        });
+      }
+
+      const results = await getRecentAlertHistories({
+        alertId: new ObjectId(alert._id),
+        createdAtLimit: 2,
+      });
+
+      expect(results).toHaveLength(2);
+      // Should return only the 2 most recent
+      expect(new Date(results[0].createdAt)).toEqual(dates[4]);
+      expect(new Date(results[1].createdAt)).toEqual(dates[3]);
+    });
+
+    it('should return multiple histories with the same createdAt', async () => {
+      const team = await Team.create({
+        name: 'Test Team',
+      });
+
+      const alert = await Alert.create({
+        channel: { type: null },
+        interval: '15m',
+        state: AlertState.OK,
+        team: team._id,
+        threshold: 10,
+        thresholdType: 'above',
+      });
+
+      const sharedDate = new Date('2024-01-01T10:00:00Z');
+
+      // Create 3 histories with the same createdAt (for group-by alerts)
+      await AlertHistory.create([
+        {
+          alert: alert._id,
+          counts: 5,
+          createdAt: sharedDate,
+          state: AlertState.ALERT,
+          lastValues: [{ startTime: sharedDate, count: 5 }],
+          group: 'group-a',
+        },
+        {
+          alert: alert._id,
+          counts: 10,
+          createdAt: sharedDate,
+          state: AlertState.ALERT,
+          lastValues: [{ startTime: sharedDate, count: 10 }],
+          group: 'group-b',
+        },
+        {
+          alert: alert._id,
+          counts: 15,
+          createdAt: sharedDate,
+          state: AlertState.ALERT,
+          lastValues: [{ startTime: sharedDate, count: 15 }],
+          group: 'group-c',
+        },
+      ]);
+
+      const results = await getRecentAlertHistories({
+        alertId: new ObjectId(alert._id),
+        createdAtLimit: 1,
+      });
+
+      // Should return all 3 histories since they share the same createdAt
+      expect(results).toHaveLength(3);
+      expect(
+        results.every(r => r.createdAt.getTime() === sharedDate.getTime()),
+      ).toBe(true);
+    });
+
+    it('should respect optional limit parameter', async () => {
+      const team = await Team.create({
+        name: 'Test Team',
+      });
+
+      const alert = await Alert.create({
+        channel: { type: null },
+        interval: '15m',
+        state: AlertState.OK,
+        team: team._id,
+        threshold: 10,
+        thresholdType: 'above',
+      });
+
+      const sharedDate = new Date('2024-01-01T10:00:00Z');
+
+      // Create 5 histories with the same createdAt
+      for (let i = 0; i < 5; i++) {
+        await AlertHistory.create({
+          alert: alert._id,
+          counts: i,
+          createdAt: sharedDate,
+          state: AlertState.ALERT,
+          lastValues: [{ startTime: sharedDate, count: i }],
+          group: `group-${i}`,
+        });
+      }
+
+      const results = await getRecentAlertHistories({
+        alertId: new ObjectId(alert._id),
+        createdAtLimit: 1,
+        limit: 3,
+      });
+
+      // Should return only 3 histories even though there are 5 with the same createdAt
+      expect(results).toHaveLength(3);
+    });
+
+    it('should return empty array when no histories exist', async () => {
+      const team = await Team.create({
+        name: 'Test Team',
+      });
+
+      const alert = await Alert.create({
+        channel: { type: null },
+        interval: '15m',
+        state: AlertState.OK,
+        team: team._id,
+        threshold: 10,
+        thresholdType: 'above',
+      });
+
+      const results = await getRecentAlertHistories({
+        alertId: new ObjectId(alert._id),
+        createdAtLimit: 5,
+      });
+
+      expect(results).toHaveLength(0);
+    });
+
+    it('should return empty array for non-existent alert', async () => {
+      const fakeAlertId = new ObjectId().toString();
+
+      const results = await getRecentAlertHistories({
+        alertId: new ObjectId(fakeAlertId),
+        createdAtLimit: 5,
+      });
+
+      expect(results).toHaveLength(0);
+    });
+
+    it('should not include internal fields in results', async () => {
+      const team = await Team.create({
+        name: 'Test Team',
+      });
+
+      const alert = await Alert.create({
+        channel: { type: null },
+        interval: '15m',
+        state: AlertState.OK,
+        team: team._id,
+        threshold: 10,
+        thresholdType: 'above',
+      });
+
+      const date = new Date('2024-01-01T10:00:00Z');
+
+      await AlertHistory.create({
+        alert: alert._id,
+        counts: 5,
+        createdAt: date,
+        state: AlertState.OK,
+        lastValues: [{ startTime: date, count: 5 }],
+      });
+
+      const results = await getRecentAlertHistories({
+        alertId: new ObjectId(alert._id),
+        createdAtLimit: 1,
+      });
+
+      expect(results).toHaveLength(1);
+      // Should not include _id, __v, or alert fields
+      expect(results[0]).not.toHaveProperty('_id');
+      expect(results[0]).not.toHaveProperty('__v');
+      expect(results[0]).not.toHaveProperty('alert');
+      // Should include the actual data
+      expect(results[0]).toHaveProperty('counts');
+      expect(results[0]).toHaveProperty('createdAt');
+      expect(results[0]).toHaveProperty('state');
+      expect(results[0]).toHaveProperty('lastValues');
+    });
+
+    it('should handle complex scenario with multiple createdAt values and groups', async () => {
+      const team = await Team.create({
+        name: 'Test Team',
+      });
+
+      const alert = await Alert.create({
+        channel: { type: null },
+        interval: '15m',
+        state: AlertState.OK,
+        team: team._id,
+        threshold: 10,
+        thresholdType: 'above',
+      });
+
+      const date1 = new Date('2024-01-01T10:00:00Z');
+      const date2 = new Date('2024-01-01T10:15:00Z');
+      const date3 = new Date('2024-01-01T10:30:00Z');
+
+      // Create histories:
+      // - 2 at date1
+      // - 3 at date2
+      // - 1 at date3
+      await AlertHistory.create([
+        {
+          alert: alert._id,
+          counts: 5,
+          createdAt: date1,
+          state: AlertState.OK,
+          lastValues: [{ startTime: date1, count: 5 }],
+          group: 'group-a',
+        },
+        {
+          alert: alert._id,
+          counts: 6,
+          createdAt: date1,
+          state: AlertState.OK,
+          lastValues: [{ startTime: date1, count: 6 }],
+          group: 'group-b',
+        },
+        {
+          alert: alert._id,
+          counts: 10,
+          createdAt: date2,
+          state: AlertState.ALERT,
+          lastValues: [{ startTime: date2, count: 10 }],
+          group: 'group-a',
+        },
+        {
+          alert: alert._id,
+          counts: 11,
+          createdAt: date2,
+          state: AlertState.ALERT,
+          lastValues: [{ startTime: date2, count: 11 }],
+          group: 'group-b',
+        },
+        {
+          alert: alert._id,
+          counts: 12,
+          createdAt: date2,
+          state: AlertState.ALERT,
+          lastValues: [{ startTime: date2, count: 12 }],
+          group: 'group-c',
+        },
+        {
+          alert: alert._id,
+          counts: 7,
+          createdAt: date3,
+          state: AlertState.OK,
+          lastValues: [{ startTime: date3, count: 7 }],
+        },
+      ]);
+
+      const results = await getRecentAlertHistories({
+        alertId: new ObjectId(alert._id),
+        createdAtLimit: 2, // Should get date3 and date2
+        limit: 3, // Limit total to 3 entries, so one of the date2 entries gets excluded
+      });
+
+      // Should return 1 from date3 + 2 from date2 = 3 total
+      expect(results).toHaveLength(3);
+
+      // Verify the dates (most recent first)
+      const uniqueDates = [...new Set(results.map(r => r.createdAt.getTime()))];
+      expect(uniqueDates).toHaveLength(2);
+      expect(uniqueDates[0]).toBe(date3.getTime());
+      expect(uniqueDates[1]).toBe(date2.getTime());
+    });
+  });
+});