test(endoflife): Mock time (#22575)

lib/modules/datasource/endoflife-date/index.spec.ts

+import { DateTime, Settings } from 'luxon';
 import { getPkgReleases } from '..';
 import { Fixtures } from '../../../../test/fixtures';
 import * as httpMock from '../../../../test/http-mock';
@@ -12,6 +13,11 @@ const packageName = 'amazon-eks';
 const eksMockPath = `/${packageName}.json`;
 
 describe('modules/datasource/endoflife-date/index', () => {
+  beforeAll(() => {
+    const now = DateTime.fromISO('2023-06-03');
+    Settings.now = () => now.valueOf();
+  });
+
   describe('getReleases', () => {
     it('processes real data', async () => {
       httpMock

lib/modules/datasource/endoflife-date/index.ts

@@ -5,7 +5,7 @@ import { joinUrlParts } from '../../../util/url';
 import { Datasource } from '../datasource';
 import type { GetReleasesConfig, ReleaseResult } from '../types';
 import { datasource, registryUrl } from './common';
-import { EndoflifeHttpResponseScheme } from './schema';
+import { EndoflifeDateVersions } from './schema';
 
 export class EndoflifeDatePackagesource extends Datasource {
   static readonly id = datasource;
@@ -41,10 +41,7 @@ export class EndoflifeDatePackagesource extends Datasource {
     const url = joinUrlParts(registryUrl, `${packageName}.json`);
 
     try {
-      const response = await this.http.getJson(
-        url,
-        EndoflifeHttpResponseScheme
-      );
+      const response = await this.http.getJson(url, EndoflifeDateVersions);
 
       result.releases.push(...response.body);
 

lib/modules/datasource/endoflife-date/schema.ts

 import { DateTime } from 'luxon';
 import { z } from 'zod';
+import { UtcDate } from '../../../util/schema-utils';
 import type { Release } from '../types';
 
-const EndoflifeDateVersionScheme = z
+const ExpireableField = z.union([
+  UtcDate.transform((x) => {
+    const now = DateTime.now().toUTC();
+    return x <= now;
+  }),
+  z.boolean(),
+]);
+
+export const EndoflifeDateVersions = z
   .object({
     cycle: z.string(),
     latest: z.optional(z.string()),
     releaseDate: z.optional(z.string()),
-    eol: z.optional(z.union([z.string(), z.boolean()])),
-    discontinued: z.optional(z.union([z.string(), z.boolean()])),
+    eol: z.optional(ExpireableField),
+    discontinued: z.optional(ExpireableField),
   })
-  .transform(({ cycle, latest, releaseDate, eol, discontinued }): Release => {
-    let isDeprecated = false;
-
-    // If "eol" date or "discontinued" date has passed or any of the values is explicitly true, set to deprecated
-    // "support" is not checked because support periods sometimes end before the EOL.
-    if (
-      eol === true ||
-      discontinued === true ||
-      (typeof eol === 'string' &&
-        DateTime.fromISO(eol, { zone: 'utc' }) <= DateTime.now().toUTC()) ||
-      (typeof discontinued === 'string' &&
-        DateTime.fromISO(discontinued, { zone: 'utc' }) <=
-          DateTime.now().toUTC())
-    ) {
-      isDeprecated = true;
-    }
-
-    let version = cycle;
-    if (latest !== undefined) {
-      version = latest;
+  .transform(
+    ({
+      cycle,
+      latest,
+      releaseDate: releaseTimestamp,
+      eol,
+      discontinued,
+    }): Release => {
+      const version = latest ?? cycle;
+      const isDeprecated = eol === true || discontinued === true;
+      return { version, releaseTimestamp, isDeprecated };
     }
-
-    return {
-      version,
-      releaseTimestamp: releaseDate,
-      isDeprecated,
-    };
-  });
-
-export const EndoflifeHttpResponseScheme = z.array(EndoflifeDateVersionScheme);
+  )
+  .array();

lib/util/schema-utils.spec.ts

 import { z } from 'zod';
-import { Json, Json5, LooseArray, LooseRecord } from './schema-utils';
+import { Json, Json5, LooseArray, LooseRecord, UtcDate } from './schema-utils';
 
 describe('util/schema-utils', () => {
   describe('LooseArray', () => {
@@ -258,4 +258,16 @@ describe('util/schema-utils', () => {
       });
     });
   });
+
+  describe('UtcDate', () => {
+    it('parses date', () => {
+      expect(UtcDate.parse('2020-04-04').toString()).toBe(
+        '2020-04-04T00:00:00.000Z'
+      );
+    });
+
+    it('rejects invalid date', () => {
+      expect(() => UtcDate.parse('foobar')).toThrow();
+    });
+  });
 });

lib/util/schema-utils.ts

 import JSON5 from 'json5';
+import { DateTime } from 'luxon';
 import type { JsonValue } from 'type-fest';
 import { z } from 'zod';
 
@@ -211,3 +212,14 @@ export const Json5 = z.string().transform((str, ctx): JsonValue => {
     return z.NEVER;
   }
 });
+
+export const UtcDate = z
+  .string({ description: 'ISO 8601 string' })
+  .transform((str, ctx): DateTime => {
+    const date = DateTime.fromISO(str, { zone: 'utc' });
+    if (!date.isValid) {
+      ctx.addIssue({ code: 'custom', message: 'Invalid date' });
+      return z.NEVER;
+    }
+    return date;
+  });