fix: [VMP-2536] - Maintenance date from local to utc (#13059)

* fix: maintenance local to utc

* More tests

* Adjust the when field logic

* Added changeset: Fix incorrect maintenance time display in the Upcoming maintenance table

---------

Co-authored-by: Jaalah Ramos <[email protected]>

Author: jaalah-akamai

packages/manager/.changeset/pr-13059-fixed-1762972220664.md

@@ -0,0 +1,5 @@
+---
+"@linode/manager": Fixed
+---
+
+Fix incorrect maintenance time display in the Upcoming maintenance table ([#13059](https://github.com/linode/manager/pull/13059))

packages/manager/src/features/Account/Maintenance/MaintenanceTableRow.tsx

@@ -1,7 +1,4 @@
-import {
-  useAccountMaintenancePoliciesQuery,
-  useProfile,
-} from '@linode/queries';
+import { useProfile } from '@linode/queries';
 import { Stack, Tooltip } from '@linode/ui';
 import { Hidden } from '@linode/ui';
 import { capitalize, getFormattedStatus, truncate } from '@linode/utilities';
@@ -84,22 +81,18 @@ export const MaintenanceTableRow = (props: MaintenanceTableRowProps) => {
   const dateField = getMaintenanceDateField(tableType);
   const dateValue = props.maintenance[dateField];
 
-  // Fetch policies to derive a start time when the API doesn't provide one
-  const { data: policies } = useAccountMaintenancePoliciesQuery();
-
   // Precompute for potential use; currently used via getUpcomingRelativeLabel
   React.useMemo(
-    () => deriveMaintenanceStartISO(props.maintenance, policies),
-    [policies, props.maintenance]
+    () => deriveMaintenanceStartISO(props.maintenance),
+    [props.maintenance]
   );
 
-  const upcomingRelativeLabel = React.useMemo(
-    () =>
-      tableType === 'upcoming'
-        ? getUpcomingRelativeLabel(props.maintenance, policies)
-        : undefined,
-    [policies, props.maintenance, tableType]
-  );
+  const upcomingRelativeLabel = React.useMemo(() => {
+    if (tableType !== 'upcoming') {
+      return undefined;
+    }
+    return getUpcomingRelativeLabel(props.maintenance);
+  }, [props.maintenance, tableType]);
 
   return (
     <TableRow key={entity.id}>

packages/manager/src/features/Account/Maintenance/utilities.test.ts

@@ -5,30 +5,12 @@ import {
   getUpcomingRelativeLabel,
 } from './utilities';
 
-import type { AccountMaintenance, MaintenancePolicy } from '@linode/api-v4';
+import type { AccountMaintenance } from '@linode/api-v4';
 
 // Freeze time to a stable reference so relative labels are deterministic
 const NOW_ISO = '2025-10-27T12:00:00.000Z';
 
 describe('Account Maintenance utilities', () => {
-  const policies: MaintenancePolicy[] = [
-    {
-      description: 'Migrate',
-      is_default: true,
-      label: 'Migrate',
-      notification_period_sec: 3 * 60 * 60, // 3 hours
-      slug: 'linode/migrate',
-      type: 'linode_migrate',
-    },
-    {
-      description: 'Power Off / On',
-      is_default: false,
-      label: 'Power Off / Power On',
-      notification_period_sec: 72 * 60 * 60, // 72 hours
-      slug: 'linode/power_off_on',
-      type: 'linode_power_off_on',
-    },
-  ];
 
   const baseMaintenance: Omit<AccountMaintenance, 'when'> & { when: string } = {
     complete_time: null,
@@ -60,33 +42,33 @@ describe('Account Maintenance utilities', () => {
         ...baseMaintenance,
         start_time: '2025-10-27T12:00:00.000Z',
       };
-      expect(deriveMaintenanceStartISO(m, policies)).toBe(
+      expect(deriveMaintenanceStartISO(m)).toBe(
         '2025-10-27T12:00:00.000Z'
       );
     });
 
-    it('derives start_time from when + policy seconds when missing', () => {
+    it('uses when directly as start time (when already accounts for notification period)', () => {
       const m: AccountMaintenance = {
         ...baseMaintenance,
         start_time: null,
-        when: '2025-10-27T09:00:00.000Z', // +3h -> 12:00Z
+        when: '2025-10-27T09:00:00.000Z',
       };
-      expect(deriveMaintenanceStartISO(m, policies)).toBe(
-        '2025-10-27T12:00:00.000Z'
+      // `when` already accounts for notification_period_sec, so it IS the start time
+      expect(deriveMaintenanceStartISO(m)).toBe(
+        '2025-10-27T09:00:00.000Z'
       );
     });
 
-    it('returns undefined when policy cannot be found', () => {
+    it('uses when directly for all statuses without needing policies', () => {
       const m: AccountMaintenance = {
         ...baseMaintenance,
         start_time: null,
-        // Use an intentionally unknown slug to exercise the no-policy fallback path.
-        // Even though the API default is typically 'linode/migrate', the client may
-        // not have policies loaded yet or could encounter a fetch error; this ensures
-        // we verify the graceful fallback behavior.
+        status: 'pending',
+        // Policies not needed - when IS the start time
         maintenance_policy_set: 'unknown/policy' as any,
+        when: '2025-10-27T09:00:00.000Z',
       };
-      expect(deriveMaintenanceStartISO(m, policies)).toBeUndefined();
+      expect(deriveMaintenanceStartISO(m)).toBe('2025-10-27T09:00:00.000Z');
     });
   });
 
@@ -100,7 +82,7 @@ describe('Account Maintenance utilities', () => {
         when: '2025-10-27T10:00:00.000Z',
       };
       // NOW=12:00Z, when=10:00Z => "2 hours ago"
-      expect(getUpcomingRelativeLabel(m, policies)).toContain('hour');
+      expect(getUpcomingRelativeLabel(m)).toContain('hour');
     });
 
     it('uses derived start to express time until maintenance (hours when <1 day)', () => {
@@ -110,16 +92,15 @@ describe('Account Maintenance utilities', () => {
         when: '2025-10-27T09:00:00.000Z',
       };
       // Allow any non-empty string; exact phrasing depends on Luxon locale
-      expect(getUpcomingRelativeLabel(m, policies)).toBeTypeOf('string');
+      expect(getUpcomingRelativeLabel(m)).toBeTypeOf('string');
     });
 
     it('shows days+hours when >= 1 day away (avoids day-only rounding)', () => {
       const m: AccountMaintenance = {
         ...baseMaintenance,
-        maintenance_policy_set: 'linode/power_off_on', // 72h
-        when: '2025-10-25T20:00:00.000Z', // +72h => 2025-10-28T20:00Z; from NOW (27 12:00Z) => 1 day 8 hours
+        when: '2025-10-28T20:00:00.000Z', // from NOW (27 12:00Z) => 1 day 8 hours
       };
-      const label = getUpcomingRelativeLabel(m, policies);
+      const label = getUpcomingRelativeLabel(m);
       expect(label).toBe('in 1 day 8 hours');
     });
 
@@ -129,7 +110,7 @@ describe('Account Maintenance utilities', () => {
         ...baseMaintenance,
         start_time: '2025-10-30T04:00:00.000Z',
       };
-      const label = getUpcomingRelativeLabel(m, policies);
+      const label = getUpcomingRelativeLabel(m);
       expect(label).toBe('in 2 days 16 hours');
     });
 
@@ -139,7 +120,7 @@ describe('Account Maintenance utilities', () => {
         // NOW is 12:00Z; start in 37 minutes
         start_time: '2025-10-27T12:37:00.000Z',
       };
-      const label = getUpcomingRelativeLabel(m, policies);
+      const label = getUpcomingRelativeLabel(m);
       expect(label).toBe('in 37 minutes');
     });
 
@@ -149,8 +130,59 @@ describe('Account Maintenance utilities', () => {
         // NOW is 12:00Z; start in 30 seconds
         start_time: '2025-10-27T12:00:30.000Z',
       };
-      const label = getUpcomingRelativeLabel(m, policies);
+      const label = getUpcomingRelativeLabel(m);
       expect(label).toBe('in 30 seconds');
     });
+
+    it('uses when directly as start time (when already accounts for notification period)', () => {
+      // Real-world scenario: API returns when=2025-11-06T16:12:41
+      // `when` already accounts for notification_period_sec, so it IS the start time
+      const m: AccountMaintenance = {
+        ...baseMaintenance,
+        start_time: null,
+        when: '2025-11-06T16:12:41', // No timezone indicator, should be parsed as UTC
+      };
+
+      const derivedStart = deriveMaintenanceStartISO(m);
+      // `when` equals start time (no addition needed)
+      expect(derivedStart).toBe('2025-11-06T16:12:41.000Z');
+    });
+
+    it('shows correct relative time (when equals start)', () => {
+      // Scenario: when=2025-11-06T16:12:41 (when IS the start time)
+      // If now is 2025-11-06T16:14:41 (2 minutes after when), should show "2 minutes ago"
+      // Save original Date.now
+      const originalDateNow = Date.now;
+
+      // Mock "now" to be 2 minutes after when (which is the start time)
+      const mockNow = '2025-11-06T16:14:41.000Z';
+      Date.now = vi.fn(() => new Date(mockNow).getTime());
+
+      const m: AccountMaintenance = {
+        ...baseMaintenance,
+        start_time: null,
+        when: '2025-11-06T16:12:41',
+      };
+
+      const label = getUpcomingRelativeLabel(m);
+      // when=start=16:12:41, now=16:14:41, difference is 2 minutes in the past
+      expect(label).toContain('minute'); // Should show "2 minutes ago" or similar
+
+      // Restore original Date.now
+      Date.now = originalDateNow;
+    });
+
+    it('handles date without timezone indicator correctly (parsed as UTC)', () => {
+      // Verify that dates without timezone are parsed as UTC
+      const m: AccountMaintenance = {
+        ...baseMaintenance,
+        start_time: null,
+        when: '2025-11-06T16:12:41', // No Z suffix or timezone
+      };
+
+      const derivedStart = deriveMaintenanceStartISO(m);
+      // `when` equals start time (no addition needed)
+      expect(derivedStart).toBe('2025-11-06T16:12:41.000Z');
+    });
   });
 });

packages/manager/src/features/Account/Maintenance/utilities.ts

@@ -4,7 +4,7 @@ import { DateTime } from 'luxon';
 import { parseAPIDate } from 'src/utilities/date';
 
 import type { MaintenanceTableType } from './MaintenanceTable';
-import type { AccountMaintenance, MaintenancePolicy } from '@linode/api-v4';
+import type { AccountMaintenance } from '@linode/api-v4';
 
 export const COMPLETED_MAINTENANCE_FILTER = Object.freeze({
   status: { '+or': ['completed', 'canceled'] },
@@ -56,37 +56,36 @@ export const getMaintenanceDateLabel = (type: MaintenanceTableType): string => {
 };
 
 /**
- * Derive the maintenance start when API `start_time` is absent by adding the
- * policy notification window to the `when` (notice publish time).
+ * Derive the maintenance start timestamp.
+ *
+ * The `when` and `start_time` fields are equivalent timestamps representing
+ * when the maintenance will happen (or has happened). Prefer `start_time` if
+ * available, otherwise use `when`.
  */
 export const deriveMaintenanceStartISO = (
-  maintenance: AccountMaintenance,
-  policies?: MaintenancePolicy[]
+  maintenance: AccountMaintenance
 ): string | undefined => {
   if (maintenance.start_time) {
     return maintenance.start_time;
   }
-  const notificationSecs = policies?.find(
-    (p) => p.slug === maintenance.maintenance_policy_set
-  )?.notification_period_sec;
-  if (maintenance.when && notificationSecs) {
-    try {
-      return parseAPIDate(maintenance.when)
-        .plus({ seconds: notificationSecs })
-        .toISO();
-    } catch {
-      return undefined;
-    }
+
+  if (!maintenance.when) {
+    return undefined;
+  }
+
+  // `when` is a timestamp equivalent to `start_time`
+  try {
+    return parseAPIDate(maintenance.when).toISO();
+  } catch {
+    return undefined;
   }
-  return undefined;
 };
 
 /**
  * Build a user-friendly relative label for the Upcoming table.
  *
  * Behavior:
- * - Prefers the actual or policy-derived start time to express time until maintenance
- * - Falls back to the notice relative time when the start cannot be determined
+ * - Uses `start_time` if available, otherwise uses `when` (both are equivalent timestamps)
  * - Avoids day-only rounding by showing days + hours when >= 1 day
  *
  * Formatting rules:
@@ -96,28 +95,29 @@ export const deriveMaintenanceStartISO = (
  * - "in N seconds" when < 1 minute
  */
 export const getUpcomingRelativeLabel = (
-  maintenance: AccountMaintenance,
-  policies?: MaintenancePolicy[]
+  maintenance: AccountMaintenance
 ): string => {
-  const startISO = deriveMaintenanceStartISO(maintenance, policies);
+  const startISO = deriveMaintenanceStartISO(maintenance);
+
+  // Use the derived start timestamp (from start_time or when)
+  const targetDT = startISO
+    ? parseAPIDate(startISO)
+    : maintenance.when
+      ? parseAPIDate(maintenance.when)
+      : null;
 
-  // Fallback: when start cannot be determined, show the notice time relative to now
-  if (!startISO) {
-    return maintenance.when
-      ? (parseAPIDate(maintenance.when).toRelative() ?? '—')
-      : '—';
+  if (!targetDT) {
+    return '—';
   }
 
-  // Prefer the actual or policy-derived start time to express "time until maintenance"
-  const startDT = parseAPIDate(startISO);
-  const now = DateTime.local();
-  if (startDT <= now) {
-    return startDT.toRelative() ?? '—';
+  const now = DateTime.utc();
+  if (targetDT <= now) {
+    return targetDT.toRelative() ?? '—';
   }
 
   // Avoid day-only rounding near boundaries by including hours alongside days.
   // For times under an hour, show exact minutes remaining; under a minute, show seconds.
-  const diff = startDT
+  const diff = targetDT
     .diff(now, ['days', 'hours', 'minutes', 'seconds'])
     .toObject();
   let days = Math.floor(diff.days ?? 0);
@@ -135,6 +135,17 @@ export const getUpcomingRelativeLabel = (
     hours = 0;
   }
 
+  // Round up hours when we have significant minutes (>= 30) for better accuracy
+  if (days >= 1 && minutes >= 30) {
+    hours += 1;
+    minutes = 0;
+    // Check if rounding caused hours to overflow
+    if (hours === 24) {
+      days += 1;
+      hours = 0;
+    }
+  }
+
   if (days >= 1) {
     const dayPart = pluralize('day', 'days', days);
     const hourPart = hours ? ` ${pluralize('hour', 'hours', hours)}` : '';