added aggregation tests

server/uptime-calculator.js

@@ -853,7 +853,7 @@ class UptimeCalculator {
      * @returns {Array} Array of aggregated bucket data
      */
     getAggregatedBuckets(days, targetBuckets = 100) {
-        const now = dayjs.utc();
+        const now = this.getCurrentDate();
         const startTime = now.subtract(days, "day");
         const totalMinutes = days * 60 * 24;
         const bucketSizeMinutes = totalMinutes / targetBuckets;

test/backend-test/test-uptime-calculator.js

@@ -363,6 +363,208 @@ function memoryUsage() {
     };
 }
 
+test("Test getAggregatedBuckets - Basic functionality", async (t) => {
+    UptimeCalculator.currentDate = dayjs.utc("2025-08-12 12:00:00");
+    let c = new UptimeCalculator();
+    
+    // Add some test data
+    await c.update(UP);
+    await c.update(DOWN);
+    await c.update(UP);
+    
+    // Test basic 1-day aggregation
+    let buckets = c.getAggregatedBuckets(1, 10);
+    
+    // Should return exactly 10 buckets
+    assert.strictEqual(buckets.length, 10);
+    
+    // Each bucket should have required properties
+    buckets.forEach(bucket => {
+        assert.ok(typeof bucket.start === 'number');
+        assert.ok(typeof bucket.end === 'number');
+        assert.ok(typeof bucket.up === 'number');
+        assert.ok(typeof bucket.down === 'number');
+        assert.ok(typeof bucket.maintenance === 'number');
+        assert.ok(typeof bucket.pending === 'number');
+        assert.ok(bucket.start < bucket.end);
+    });
+    
+    // Buckets should be contiguous
+    for (let i = 0; i < buckets.length - 1; i++) {
+        assert.strictEqual(buckets[i].end, buckets[i + 1].start);
+    }
+});
+
+test("Test getAggregatedBuckets - Time range accuracy", async (t) => {
+    UptimeCalculator.currentDate = dayjs.utc("2025-08-12 12:00:00");
+    let c = new UptimeCalculator();
+    
+    let buckets = c.getAggregatedBuckets(2, 48); // 2 days, 48 buckets = 1 hour per bucket
+    
+    assert.strictEqual(buckets.length, 48);
+    
+    // First bucket should start 2 days ago from current time
+    let currentTime = dayjs.utc("2025-08-12 12:00:00");
+    let expectedStart = currentTime.subtract(2, "day").unix();
+    assert.strictEqual(buckets[0].start, expectedStart);
+    
+    // Last bucket should end at current time
+    let expectedEnd = currentTime.unix();
+    assert.strictEqual(buckets[buckets.length - 1].end, expectedEnd);
+    
+    // Each bucket should be exactly 1 hour (3600 seconds)
+    buckets.forEach(bucket => {
+        assert.strictEqual(bucket.end - bucket.start, 3600);
+    });
+});
+
+test("Test getAggregatedBuckets - Different time ranges", async (t) => {
+    UptimeCalculator.currentDate = dayjs.utc("2025-08-12 12:00:00");
+    let c = new UptimeCalculator();
+    
+    // Test 1 day (should use minutely data)
+    let buckets1d = c.getAggregatedBuckets(1, 24);
+    assert.strictEqual(buckets1d.length, 24);
+    
+    // Test 7 days (should use hourly data)
+    let buckets7d = c.getAggregatedBuckets(7, 50);
+    assert.strictEqual(buckets7d.length, 50);
+    
+    // Test 60 days (should use daily data)
+    let buckets60d = c.getAggregatedBuckets(60, 60);
+    assert.strictEqual(buckets60d.length, 60);
+    
+    // Test maximum days (365)
+    let buckets365d = c.getAggregatedBuckets(365, 100);
+    assert.strictEqual(buckets365d.length, 100);
+});
+
+test("Test getAggregatedBuckets - Data aggregation", async (t) => {
+    UptimeCalculator.currentDate = dayjs.utc("2025-08-12 12:00:00");
+    let c = new UptimeCalculator();
+    
+    // Create test data - add heartbeats over the past hour
+    let currentTime = dayjs.utc("2025-08-12 12:00:00");
+    
+    // Add some recent data (within the last hour) to ensure it's captured
+    for (let i = 0; i < 10; i++) {
+        UptimeCalculator.currentDate = currentTime.subtract(60 - (i * 5), "minute"); // Go back in time
+        if (i < 5) {
+            await c.update(UP);
+        } else {
+            await c.update(DOWN);
+        }
+    }
+    
+    // Reset to current time
+    UptimeCalculator.currentDate = currentTime;
+    
+    // Get aggregated buckets for 1 hour with 6 buckets (10 minutes each)
+    let buckets = c.getAggregatedBuckets(1/24, 6); // 1/24 day = 1 hour
+    
+    assert.strictEqual(buckets.length, 6);
+    
+    // Check that we have bucket structure even if no data (should not crash)
+    buckets.forEach(bucket => {
+        assert.ok(typeof bucket.start === 'number');
+        assert.ok(typeof bucket.end === 'number');
+        assert.ok(typeof bucket.up === 'number');
+        assert.ok(typeof bucket.down === 'number');
+        assert.ok(bucket.start < bucket.end);
+    });
+    
+    // For this test, we'll just verify the method works and returns proper structure
+    // The actual data aggregation depends on the complex internal storage which is tested separately
+});
+
+test("Test getAggregatedBuckets - Edge cases", async (t) => {
+    UptimeCalculator.currentDate = dayjs.utc("2025-08-12 12:00:00");
+    let c = new UptimeCalculator();
+    
+    // Test with no data
+    let emptyBuckets = c.getAggregatedBuckets(1, 10);
+    assert.strictEqual(emptyBuckets.length, 10);
+    emptyBuckets.forEach(bucket => {
+        assert.strictEqual(bucket.up, 0);
+        assert.strictEqual(bucket.down, 0);
+        assert.strictEqual(bucket.maintenance, 0);
+        assert.strictEqual(bucket.pending, 0);
+    });
+    
+    // Test with single bucket
+    let singleBucket = c.getAggregatedBuckets(1, 1);
+    assert.strictEqual(singleBucket.length, 1);
+    assert.strictEqual(singleBucket[0].end - singleBucket[0].start, 24 * 60 * 60); // 1 day in seconds
+    
+    // Test with very small time range
+    let smallRange = c.getAggregatedBuckets(0.1, 5); // 0.1 days = 2.4 hours
+    assert.strictEqual(smallRange.length, 5);
+    smallRange.forEach(bucket => {
+        assert.strictEqual(bucket.end - bucket.start, 2.4 * 60 * 60 / 5); // 2.4 hours / 5 buckets
+    });
+});
+
+test("Test getAggregatedBuckets - Bucket size calculation", async (t) => {
+    UptimeCalculator.currentDate = dayjs.utc("2025-08-12 12:00:00");
+    let c = new UptimeCalculator();
+    
+    // Test different bucket counts for same time range
+    let days = 3;
+    let buckets10 = c.getAggregatedBuckets(days, 10);
+    let buckets50 = c.getAggregatedBuckets(days, 50);
+    let buckets100 = c.getAggregatedBuckets(days, 100);
+    
+    assert.strictEqual(buckets10.length, 10);
+    assert.strictEqual(buckets50.length, 50);
+    assert.strictEqual(buckets100.length, 100);
+    
+    // Bucket sizes should be inversely proportional to bucket count
+    let bucket10Size = buckets10[0].end - buckets10[0].start;
+    let bucket50Size = buckets50[0].end - buckets50[0].start;
+    let bucket100Size = buckets100[0].end - buckets100[0].start;
+    
+    assert.ok(bucket10Size > bucket50Size);
+    assert.ok(bucket50Size > bucket100Size);
+    
+    // All buckets should cover the same total time range
+    assert.strictEqual(buckets10[buckets10.length - 1].end - buckets10[0].start, days * 24 * 60 * 60);
+    assert.strictEqual(buckets50[buckets50.length - 1].end - buckets50[0].start, days * 24 * 60 * 60);
+    assert.strictEqual(buckets100[buckets100.length - 1].end - buckets100[0].start, days * 24 * 60 * 60);
+});
+
+test("Test getAggregatedBuckets - Default parameters", async (t) => {
+    UptimeCalculator.currentDate = dayjs.utc("2025-08-12 12:00:00");
+    let c = new UptimeCalculator();
+    
+    // Test default targetBuckets (should be 100)
+    let defaultBuckets = c.getAggregatedBuckets(7);
+    assert.strictEqual(defaultBuckets.length, 100);
+    
+    // Test explicit targetBuckets
+    let explicitBuckets = c.getAggregatedBuckets(7, 50);
+    assert.strictEqual(explicitBuckets.length, 50);
+});
+
+test("Test getAggregatedBuckets - Rounding precision", async (t) => {
+    UptimeCalculator.currentDate = dayjs.utc("2025-08-12 12:00:00");
+    let c = new UptimeCalculator();
+    
+    // Test with non-integer bucket sizes (should not have rounding drift)
+    let buckets = c.getAggregatedBuckets(1, 7); // 1 day / 7 buckets = ~3.43 hours per bucket
+    
+    assert.strictEqual(buckets.length, 7);
+    
+    // Verify no gaps or overlaps between buckets
+    for (let i = 0; i < buckets.length - 1; i++) {
+        assert.strictEqual(buckets[i].end, buckets[i + 1].start, `Gap found between bucket ${i} and ${i + 1}`);
+    }
+    
+    // Verify total time range is exactly as requested
+    let totalTime = buckets[buckets.length - 1].end - buckets[0].start;
+    let expectedTime = 1 * 24 * 60 * 60; // 1 day in seconds
+    assert.strictEqual(totalTime, expectedTime);
+});
+
 test("Worst case", async (t) => {
 
     // Disable on GitHub Actions, as it is not stable on it