test: add helper method for overriding env variables

packages/relay/src/lib/services/ethService/ethFilterService/index.ts

@@ -187,7 +187,7 @@ export class FilterService implements IFilterService {
     return predefined.UNSUPPORTED_METHOD;
   }
 
-  public async getFilterLogs(filterId: string, requestDetails: RequestDetails): Promise<any> {
+  public async getFilterLogs(filterId: string, requestDetails: RequestDetails): Promise<Log[]> {
     this.logger.trace(`${requestDetails.formattedRequestId} getFilterLogs(${filterId})`);
     FilterService.requireFiltersEnabled();
 

packages/relay/tests/helpers.ts

@@ -885,40 +885,98 @@ export const calculateTxRecordChargeAmount = (exchangeRateIncents: number) => {
 };
 
 export const useInMemoryRedisServer = (logger: Logger, port: number) => {
-  let envsToReset: { TEST?: string; REDIS_ENABLED?: string; REDIS_URL?: string };
+  overrideEnvsInMochaDescribe({ TEST: 'false', REDIS_ENABLED: 'true', REDIS_URL: `redis://127.0.0.1:${port}` });
+
   let redisInMemoryServer: RedisInMemoryServer;
 
   before(async () => {
-    ({ envsToReset, redisInMemoryServer } = await startRedisInMemoryServer(logger, port));
+    redisInMemoryServer = await startRedisInMemoryServer(logger, port);
   });
 
   after(async () => {
-    await stopRedisInMemoryServer(redisInMemoryServer, envsToReset);
+    await stopRedisInMemoryServer(redisInMemoryServer);
   });
 };
 
 export const startRedisInMemoryServer = async (logger: Logger, port: number) => {
   const redisInMemoryServer = new RedisInMemoryServer(logger.child({ name: 'RedisInMemoryServer' }), port);
   await redisInMemoryServer.start();
-  const envsToReset = {
-    TEST: process.env.TEST,
-    REDIS_ENABLED: process.env.REDIS_ENABLED,
-    REDIS_URL: process.env.REDIS_URL,
-  };
-  process.env.TEST = 'false';
-  process.env.REDIS_ENABLED = 'true';
-  process.env.REDIS_URL = `redis://127.0.0.1:${port}`;
-  return { redisInMemoryServer, envsToReset };
+  return redisInMemoryServer;
 };
 
-export const stopRedisInMemoryServer = async (
-  redisInMemoryServer: RedisInMemoryServer,
-  envsToReset: { TEST?: string; REDIS_ENABLED?: string; REDIS_URL?: string },
-): Promise<void> => {
+export const stopRedisInMemoryServer = async (redisInMemoryServer: RedisInMemoryServer): Promise<void> => {
   await redisInMemoryServer.stop();
-  process.env.TEST = envsToReset.TEST;
-  process.env.REDIS_ENABLED = envsToReset.REDIS_ENABLED;
-  process.env.REDIS_URL = envsToReset.REDIS_URL;
+};
+
+/**
+ * Temporarily overrides environment variables for the duration of the encapsulating describe block.
+ * @param envs - An object containing key-value pairs of environment variables to set.
+ *
+ * @example
+ * describe('given TEST is set to false', () => {
+ *   overrideEnvsInMochaDescribe({ TEST: 'false' });
+ *
+ *   it('should return false', () => {
+ *     expect(process.env.TEST).to.equal('false');
+ *   });
+ * });
+ *
+ * it('should return true', () => {
+ *   expect(process.env.TEST).to.equal('true');
+ * });
+ */
+export const overrideEnvsInMochaDescribe = (envs: NodeJS.Dict<string>) => {
+  let envsToReset: NodeJS.Dict<string> = {};
+
+  const overrideEnv = (object: NodeJS.Dict<string>, key: string, value: string | undefined) => {
+    if (value === undefined) {
+      delete object[key];
+    } else {
+      object[key] = value;
+    }
+  };
+
+  before(() => {
+    for (const key in envs) {
+      envsToReset[key] = process.env[key];
+      overrideEnv(process.env, key, envs[key]);
+    }
+  });
+
+  after(() => {
+    for (const key in envs) {
+      overrideEnv(process.env, key, envsToReset[key]);
+    }
+  });
+};
+
+/**
+ * Overrides environment variables for the duration of the provided tests.
+ *
+ * @param {NodeJS.Dict<string>} envs - An object containing key-value pairs of environment variables to set.
+ * @param {Function} tests - A function containing the tests to run with the overridden environment variables.
+ *
+ * @example
+ * withOverriddenEnvsInMochaTest({ TEST: 'false' }, () => {
+ *   it('should return false', () => {
+ *     expect(process.env.TEST).to.equal('false');
+ *   });
+ * });
+ *
+ * it('should return true', () => {
+ *   expect(process.env.TEST).to.equal('true');
+ * });
+ */
+export const withOverriddenEnvsInMochaTest = (envs: NodeJS.Dict<string>, tests: () => void) => {
+  const overriddenEnvs = Object.entries(envs)
+    .map(([key, value]) => `${key}=${value}`)
+    .join(', ');
+
+  describe(`given ${overriddenEnvs} are set`, () => {
+    overrideEnvsInMochaDescribe(envs);
+
+    tests();
+  });
 };
 
 export const estimateFileTransactionsFee = (

packages/relay/tests/lib/clients/localLRUCache.spec.ts

@@ -23,7 +23,7 @@ import chaiAsPromised from 'chai-as-promised';
 import { Registry } from 'prom-client';
 import pino from 'pino';
 import { LocalLRUCache } from '../../../src/lib/clients';
-import constants from '../../../src/lib/constants';
+import { overrideEnvsInMochaDescribe } from '../../helpers';
 import { RequestDetails } from '../../../src/lib/types';
 
 const logger = pino();
@@ -107,13 +107,9 @@ describe('LocalLRUCache Test Suite', async function () {
   });
 
   describe('verify cache management', async function () {
-    beforeEach(() => {
-      process.env.CACHE_MAX = constants.CACHE_MAX.toString();
-    });
+    overrideEnvsInMochaDescribe({ CACHE_MAX: '2' });
 
     it('verify cache size', async function () {
-      const cacheMaxSize = 2;
-      process.env.CACHE_MAX = `${cacheMaxSize}`;
       const customLocalLRUCache = new LocalLRUCache(logger.child({ name: `cache` }), registry);
       const keyValuePairs = {
         key1: 'value1',
@@ -149,8 +145,9 @@ describe('LocalLRUCache Test Suite', async function () {
     it('verify cache ttl nature', async function () {
       const customLocalLRUCache = new LocalLRUCache(logger.child({ name: `cache` }), registry);
       const key = 'key';
-      await customLocalLRUCache.set(key, 'value', callingMethod, requestDetails, 100); // set ttl to 1 ms
-      await new Promise((r) => setTimeout(r, 500)); // wait for ttl to expire
+      const ttl = 100; // set ttl to 100ms
+      await customLocalLRUCache.set(key, 'value', callingMethod, requestDetails, ttl);
+      await new Promise((r) => setTimeout(r, ttl + 100)); // wait for ttl to expire
       const cacheValue = await customLocalLRUCache.get(key, callingMethod, requestDetails);
       expect(cacheValue).to.be.null;
     });

packages/relay/tests/lib/clients/redisCache.spec.ts

@@ -106,7 +106,7 @@ describe('RedisCache Test Suite', async function () {
     it('should be able to set cache with TTL less than 1000 milliseconds', async () => {
       const key = 'int';
       const value = 1;
-      const ttl = 500;
+      const ttl = 100;
 
       await redisCache.set(key, value, callingMethod, requestDetails, ttl);
 
@@ -122,7 +122,7 @@ describe('RedisCache Test Suite', async function () {
     it('should be able to set cache with TTL greater than 1000 milliseconds', async () => {
       const key = 'int';
       const value = 1;
-      const ttl = 1500;
+      const ttl = 1100;
 
       await redisCache.set(key, value, callingMethod, requestDetails, ttl);