chore(core): manual fix linter reported errors under __tests__

.eslintrc.js

@@ -65,6 +65,7 @@ module.exports = {
 				allow: [
 					// exceptions for core package
 					'phone_number',
+					'search_indices',
 					// exceptions for api packages
 					'graphql_headers',
 					// exceptions for the legacy config

packages/core/__tests__/BackgroundProcessManager.test.ts

@@ -96,9 +96,9 @@ describe('BackgroundProcessManager', () => {
 		const manager = new BackgroundProcessManager();
 
 		const resultPromise = manager.add(async () => {
-			return new Promise((resolve, raise) => {
+			return new Promise((resolve, reject) => {
 				setTimeout(() => {
-					raise(new Error('a fuss'));
+					reject(new Error('a fuss'));
 				}, 50);
 			});
 		});
@@ -146,7 +146,7 @@ describe('BackgroundProcessManager', () => {
 		const manager = new BackgroundProcessManager();
 
 		// add a job that will not have completed by the time we open() again
-		manager.add(async () => new Promise(unsleep => setTimeout(unsleep, 10)));
+		manager.add(async () => new Promise(resolve => setTimeout(resolve, 10)));
 
 		// close, but don't want, because we want to prove that open() will wait
 		// internally for close to resolve before re-opening.
@@ -176,8 +176,15 @@ describe('BackgroundProcessManager', () => {
 		expect(manager.isClosing).toBe(false);
 		expect(manager.isClosed).toBe(false);
 
-		let unblock;
-		manager.add(async () => new Promise(_unblock => (unblock = _unblock)));
+		let unblock: () => void = () => {
+			// no op
+		};
+		manager.add(
+			async () =>
+				new Promise<void>(resolve => {
+					unblock = resolve;
+				}),
+		);
 
 		expect(manager.state).toEqual(BackgroundProcessManagerState.Open);
 		expect(manager.isOpen).toBe(true);
@@ -195,7 +202,7 @@ describe('BackgroundProcessManager', () => {
 		// promise layers handling by awaiting another promise before the
 		// manager can register completion.
 
-		unblock();
+		unblock?.();
 		await new Promise(process.nextTick);
 
 		expect(manager.state).toEqual(BackgroundProcessManagerState.Closed);
@@ -252,8 +259,8 @@ describe('BackgroundProcessManager', () => {
 		let completed = false;
 		const manager = new BackgroundProcessManager();
 
-		const resultPromise = manager.add(async onTerminate => {
-			return new Promise<void>((resolve, reject) => {
+		const _ = manager.add(async (onTerminate: Promise<void>) => {
+			return new Promise<void>((resolve, _reject) => {
 				const timer = setTimeout(() => {
 					// this is the happy path that we plan not to reach in
 					// this test.
@@ -290,8 +297,9 @@ describe('BackgroundProcessManager', () => {
 		let completed = false;
 		let thrown;
 		const manager = new BackgroundProcessManager();
+		const expectedError = new Error('badness happened');
 
-		const resultPromise = manager.add(async onTerminate => {
+		const resultPromise = manager.add(async (onTerminate: Promise<void>) => {
 			return new Promise<void>((resolve, reject) => {
 				const timer = setTimeout(() => {
 					// this is the happy path that we plan not to reach in
@@ -305,7 +313,7 @@ describe('BackgroundProcessManager', () => {
 				// or reject.
 				onTerminate.then(() => {
 					clearTimeout(timer);
-					reject('badness happened');
+					reject(expectedError);
 				});
 			});
 		});
@@ -329,7 +337,7 @@ describe('BackgroundProcessManager', () => {
 
 		// then making sure the job really really didn't fire.
 		expect(completed).toBe(false);
-		expect(thrown).toEqual('badness happened');
+		expect(thrown).toEqual(expectedError);
 	});
 
 	test('attempts to terminate all, but patiently waits for persistent jobs', async () => {
@@ -341,7 +349,7 @@ describe('BackgroundProcessManager', () => {
 		for (let i = 0; i < 10; i++) {
 			const _i = i;
 			results.push(false);
-			manager.add(async onTerminate => {
+			manager.add(async (onTerminate: Promise<void>) => {
 				return new Promise<void>((resolve, reject) => {
 					const timer = setTimeout(() => {
 						results[_i] = true;
@@ -357,7 +365,7 @@ describe('BackgroundProcessManager', () => {
 
 							// remember, if a job *does* terminate, it still
 							// needs resolve/reject to unblock `close()`.
-							_i > 5 ? resolve() : reject();
+							_i > 5 ? resolve() : reject(new Error());
 						}
 					});
 				});
@@ -371,7 +379,9 @@ describe('BackgroundProcessManager', () => {
 		expect(results.length).toEqual(10); // sanity check
 		expect(results.filter(v => v === true).length).toBe(5);
 		expect(terminationAttemptCount).toEqual(10);
-		expect(resolutions.filter(r => r.status === 'rejected').length).toEqual(3);
+		expect(
+			resolutions.filter((r: any) => r.status === 'rejected').length,
+		).toEqual(3);
 	});
 
 	test('can be used to terminate other types of bg jobs, like zen subscriptions', async () => {
@@ -418,7 +428,7 @@ describe('BackgroundProcessManager', () => {
 		const manager = new BackgroundProcessManager();
 		let count = 0;
 
-		const subscription = new Observable(observer => {
+		const _ = new Observable(observer => {
 			const interval = setInterval(() => {
 				observer.next({});
 			}, 10);
@@ -502,7 +512,7 @@ describe('BackgroundProcessManager', () => {
 
 		// accumulate a bunch of close promises, only the first of which should
 		// send the close signal, but all of which should await resolution.
-		const closes = [0, 1, 2, 3, 4, 5].map(i => manager.close());
+		const closes = [0, 1, 2, 3, 4, 5].map(_ => manager.close());
 
 		// ensure everything has settled
 		const resolved = await Promise.allSettled(closes);
@@ -564,7 +574,7 @@ describe('BackgroundProcessManager', () => {
 		const manager = new BackgroundProcessManager();
 
 		manager.add(
-			async () => new Promise(unsleep => setTimeout(unsleep, 1)),
+			async () => new Promise(resolve => setTimeout(resolve, 1)),
 			'async function',
 		);
 
@@ -579,9 +589,9 @@ describe('BackgroundProcessManager', () => {
 		const manager = new BackgroundProcessManager();
 
 		manager.add(
-			async onTerminate =>
-				new Promise(finishJob => {
-					onTerminate.then(finishJob);
+			async (onTerminate: Promise<void>) =>
+				new Promise(resolve => {
+					onTerminate.then(resolve);
 				}),
 			'cancelable async function',
 		);
@@ -635,27 +645,31 @@ describe('BackgroundProcessManager', () => {
 		const manager = new BackgroundProcessManager();
 		await manager.close();
 
-		await expect(manager.add(async () => {}, 'some job')).rejects.toThrow(
-			'some job',
-		);
+		await expect(
+			manager.add(async () => {
+				// no-op
+			}, 'some job'),
+		).rejects.toThrow('some job');
 	});
 
 	test('manager closed error shows names of pending items in error', async () => {
 		const manager = new BackgroundProcessManager();
 
-		let unblock;
+		let unblock: any;
 		manager.add(
-			() => new Promise(_unblock => (unblock = _unblock)),
+			() => new Promise<void>(resolve => (unblock = resolve)),
 			'blocking job',
 		);
 
 		const close = manager.close();
 
-		await expect(manager.add(async () => {}, 'some job')).rejects.toThrow(
-			'blocking job',
-		);
+		await expect(
+			manager.add(async () => {
+				// no-op
+			}, 'some job'),
+		).rejects.toThrow('blocking job');
 
-		unblock();
+		unblock?.();
 		await close;
 	});
 });

packages/core/__tests__/Cache/StorageCache.test.ts

@@ -46,8 +46,8 @@ describe('StorageCache', () => {
 		}
 	}
 	// create test helpers
-	const getStorageCache = (config?: CacheConfig) =>
-		new StorageCacheTest(config);
+	const getStorageCache = (storageCacheConfig?: CacheConfig) =>
+		new StorageCacheTest(storageCacheConfig);
 
 	beforeAll(() => {
 		mockGetCurrentSizeKey.mockReturnValue(currentSizeKey);

packages/core/__tests__/Cache/StorageCacheCommon.test.ts

@@ -26,7 +26,7 @@ describe('StorageCacheCommon', () => {
 		warningThreshold: 0.8,
 	};
 	// create spies
-	const loggerSpy = {
+	const loggerSpy: Record<string, jest.SpyInstance> = {
 		debug: jest.spyOn(ConsoleLogger.prototype, 'debug'),
 		error: jest.spyOn(ConsoleLogger.prototype, 'error'),
 		warn: jest.spyOn(ConsoleLogger.prototype, 'warn'),
@@ -57,9 +57,9 @@ describe('StorageCacheCommon', () => {
 		}
 	}
 	// create test helpers
-	const getStorageCache = (config?: CacheConfig) =>
+	const getStorageCache = (storageCacheConfig?: CacheConfig) =>
 		new StorageCacheCommonTest({
-			config,
+			config: storageCacheConfig,
 			keyValueStorage: mockKeyValueStorage,
 		});
 
@@ -464,8 +464,8 @@ describe('StorageCacheCommon', () => {
 	describe('getItem()', () => {
 		const value = 'value';
 		const cache = getStorageCache(config);
-		const key = 'key';
-		const prefixedKey = `${keyPrefix}${key}`;
+		const testKey = 'key';
+		const testPrefixedKey = `${keyPrefix}${testKey}`;
 
 		beforeEach(() => {
 			mockKeyValueStorageGetItem.mockReturnValue(null);
@@ -476,11 +476,11 @@ describe('StorageCacheCommon', () => {
 				JSON.stringify({ data: value }),
 			);
 
-			expect(await cache.getItem(key)).toBe(value);
+			expect(await cache.getItem(testKey)).toBe(value);
 			expect(loggerSpy.debug).toHaveBeenCalledWith(
-				expect.stringContaining(`Get item: key is ${key}`),
+				expect.stringContaining(`Get item: key is ${testKey}`),
 			);
-			expect(mockKeyValueStorageGetItem).toHaveBeenCalledWith(prefixedKey);
+			expect(mockKeyValueStorageGetItem).toHaveBeenCalledWith(testPrefixedKey);
 		});
 
 		it('aborts on empty key', async () => {
@@ -508,39 +508,41 @@ describe('StorageCacheCommon', () => {
 				}),
 			);
 
-			expect(await cache.getItem(key)).toBeNull();
-			expect(mockKeyValueStorageRemoveItem).toHaveBeenCalledWith(prefixedKey);
+			expect(await cache.getItem(testKey)).toBeNull();
+			expect(mockKeyValueStorageRemoveItem).toHaveBeenCalledWith(
+				testPrefixedKey,
+			);
 		});
 
 		it('returns null if not in cache', async () => {
-			expect(await cache.getItem(key)).toBeNull();
+			expect(await cache.getItem(testKey)).toBeNull();
 		});
 
 		it('updates item visitedTime when fetched from cache', async () => {
 			const item = { data: value };
 			mockKeyValueStorageGetItem.mockReturnValue(JSON.stringify(item));
 
-			expect(await cache.getItem(key)).toBe(value);
-			expect(mockKeyValueStorageGetItem).toHaveBeenCalledWith(prefixedKey);
+			expect(await cache.getItem(testKey)).toBe(value);
+			expect(mockKeyValueStorageGetItem).toHaveBeenCalledWith(testPrefixedKey);
 			expect(mockKeyValueStorageSetItem).toHaveBeenCalledWith(
-				prefixedKey,
+				testPrefixedKey,
 				JSON.stringify({ ...item, visitedTime: currentTime }),
 			);
 		});
 
 		it('execute a callback if specified when key not found in cache', async () => {
 			mockGetByteLength.mockReturnValue(20);
 			const callback = jest.fn(() => value);
-			expect(await cache.getItem(key, { callback })).toBe(value);
+			expect(await cache.getItem(testKey, { callback })).toBe(value);
 			expect(callback).toHaveBeenCalled();
 			expect(mockKeyValueStorageSetItem).toHaveBeenCalled();
 		});
 	});
 
 	describe('removeItem()', () => {
 		const cache = getStorageCache(config);
-		const key = 'key';
-		const prefixedKey = `${keyPrefix}${key}`;
+		const testKey = 'key';
+		const testPrefixedKey = `${keyPrefix}${testKey}`;
 
 		beforeEach(() => {
 			mockKeyValueStorageGetItem.mockReturnValue(
@@ -549,11 +551,13 @@ describe('StorageCacheCommon', () => {
 		});
 
 		it('removes an item', async () => {
-			await cache.removeItem(key);
+			await cache.removeItem(testKey);
 			expect(loggerSpy.debug).toHaveBeenCalledWith(
-				expect.stringContaining(`Remove item: key is ${key}`),
+				expect.stringContaining(`Remove item: key is ${testKey}`),
+			);
+			expect(mockKeyValueStorageRemoveItem).toHaveBeenCalledWith(
+				testPrefixedKey,
 			);
-			expect(mockKeyValueStorageRemoveItem).toHaveBeenCalledWith(prefixedKey);
 		});
 
 		it('aborts on empty key', async () => {
@@ -574,7 +578,7 @@ describe('StorageCacheCommon', () => {
 
 		it('does nothing if item not found', async () => {
 			mockKeyValueStorageGetItem.mockReturnValue(null);
-			await cache.removeItem(key);
+			await cache.removeItem(testKey);
 			expect(mockKeyValueStorageRemoveItem).not.toHaveBeenCalled();
 		});
 	});

packages/core/__tests__/Cache/utils/CacheList.test.ts

@@ -125,8 +125,8 @@ describe('CacheList', () => {
 			test('get all keys in the list', () => {
 				const list: CacheList = new CacheList();
 				const keys: string[] = ['0', '1', '2'];
-				for (let i = 0; i < keys.length; i++) {
-					list.insertItem(keys[i]);
+				for (const key of keys) {
+					list.insertItem(key);
 				}
 
 				const listKeys: string[] = list.getKeys();

packages/core/__tests__/ConsoleLogger.test.ts

@@ -25,16 +25,18 @@ describe('ConsoleLogger', () => {
 
 		it('should do nothing when a non-logging category plugin is provided to addPluggable', () => {
 			const provider = {
-				getCategoryName: function () {
+				getCategoryName: () => {
 					return 'non-logging';
 				},
-				getProviderName: function () {
+				getProviderName: () => {
 					return 'lol';
 				},
-				configure: function () {
+				configure: () => {
 					return {};
 				},
-				pushLogs: () => {},
+				pushLogs: () => {
+					// no-op
+				},
 			} as LoggingProvider;
 
 			const logger = new ConsoleLogger('name');