Include test files to typescript project files and fix type issues

Author: hakatashi

checkin/.eslintrc.json

@@ -1,5 +1,5 @@
 {
-    "extends": "@hakatashi",
+    "extends": "@hakatashi/eslint-config/typescript",
     "parserOptions": {
         "ecmaVersion": 2017,
         "ecmaFeatures": {

checkin/index.test.ts

@@ -55,11 +55,12 @@ describe('tiobot', () => {
 			},
 		};
 
-		const {text, username} = await slack.getResponseTo('checkin-check');
+		const message = await slack.getResponseTo('checkin-check');
 
-		expect(username).toBe('checkin');
-		expect(text).toContain('Koki Takahashi');
-		expect(text).toContain('理学部7号館');
-		expect(text).toContain('おるでｗ');
+		// eslint-disable-next-line no-restricted-syntax
+		expect('username' in message && message.username).toBe('checkin');
+		expect(message.text).toContain('Koki Takahashi');
+		expect(message.text).toContain('理学部7号館');
+		expect(message.text).toContain('おるでｗ');
 	});
 });

checkin/index.ts

@@ -4,6 +4,22 @@ import get from 'lodash/get';
 import schedule from 'node-schedule';
 import logger from '../lib/logger';
 import type {SlackInterface} from '../lib/slack';
+import type {MessageEvent} from '@slack/bolt';
+
+interface User {
+	firstName: string;
+	lastName: string;
+	photo: {
+		prefix: string;
+		suffix: string;
+	};
+}
+
+interface HereNowItem {
+	id: string;
+	user: User;
+	shout?: string;
+}
 
 const log = logger.child({bot: 'checkin'});
 
@@ -14,7 +30,7 @@ const places = [
 
 export default ({eventClient, webClient: slack}: SlackInterface) => {
 	const state = {
-		herenow: new Map<string, any[]>(),
+		herenow: new Map<string, HereNowItem[]>(),
 	};
 
 	const job = async () => {
@@ -32,11 +48,11 @@ export default ({eventClient, webClient: slack}: SlackInterface) => {
 				responseType: 'json',
 			});
 
-			const items: any[] = get(data, ['data', 'response', 'hereNow', 'items'], []);
+			const items: HereNowItem[] = get(data, ['data', 'response', 'hereNow', 'items'], []);
 
 			if (state.herenow.has(place.id)) {
 				const newUsers = items.filter(({id}) => (
-					state.herenow.get(place.id).find((user: any) => user.id === id) === undefined
+					state.herenow.get(place.id).find((user) => user.id === id) === undefined
 				));
 
 				for (const {user, shout} of newUsers) {
@@ -60,8 +76,8 @@ export default ({eventClient, webClient: slack}: SlackInterface) => {
 		schedule.scheduleJob('*/3 * * * *', job);
 	}
 
-	eventClient.on('message', (message: any) => {
-		if (message.text === 'checkin-check' && message.channel === process.env.CHANNEL_SANDBOX) {
+	eventClient.on('message', (message: MessageEvent) => {
+		if ('text' in message && message.text === 'checkin-check' && message.channel === process.env.CHANNEL_SANDBOX) {
 			job();
 		}
 	});

dajare/index.test.js

@@ -2,7 +2,7 @@
 
 vi.mock('axios');
 vi.mock('./tokenize.js');
-vi.mock('../achievements', () => ({unlock: vi.fn(), increment: vi.fn(), get: vi.fn(), set: vi.fn()}));
+vi.mock('../achievements');
 
 const dajare = require('./index.js');
 const {default: Slack} = require('../lib/slackMock.ts');

deploy/block.test.ts

@@ -1,3 +1,6 @@
+/* eslint-disable require-await */
+
+import {expect, it, beforeEach} from 'vitest';
 import Blocker from './block';
 
 let blocker: InstanceType<typeof Blocker> = null;
@@ -10,10 +13,10 @@ it('blocks until unblocked', () => new Promise<void>(async (resolve) => {
 	const unblock = await blocker.block('block1');
 	let blocked = true;
 
-	blocker.wait(() => {
+	blocker.wait(async () => {
 		expect(blocked).toBe(false);
 		resolve();
-	});
+	}, 0);
 
 	process.nextTick(() => {
 		blocked = false;
@@ -28,39 +31,41 @@ it('blocks until all unblocked', () => new Promise<void>(async (resolve) => {
 	}
 	let unblocked = 0;
 
-	blocker.wait(() => {
+	blocker.wait(async () => {
 		expect(unblocked).toBe(10);
 		resolve();
-	});
+	}, 0);
 
 	while (unblocks.length > 0) {
 		unblocked++;
 		unblocks.shift()();
 
-		await new Promise((res) => process.nextTick(res));
+		await new Promise((resolve) => process.nextTick(resolve));
 	}
 }));
 
 it('calls intervalCallback when block continues', () => new Promise<void>(async (resolve, reject) => {
 	await blocker.block('block');
 
-	blocker.wait(reject as () => void, 0, resolve);
+	blocker.wait(async () => {
+		reject(new Error());
+	}, 0, () => resolve());
 }));
 
 it('does not call intervalCallback unless blocked', () => new Promise<void>(async (resolve, reject) => {
 	const unblock = await blocker.block('block');
 	unblock();
 
-	blocker.wait(() => {
+	blocker.wait(async () => {
 		process.nextTick(resolve);
-	}, 0, reject as () => void);
+	}, 0, reject);
 }));
 
 it('cannot block while wait callback is runnning', () => new Promise<void>(async (resolve, reject) => {
 	blocker.wait(() => new Promise<void>((callbackResolve) => process.nextTick(() => {
 		resolve();
 		callbackResolve();
-	})));
+	})), 0);
 
 	await blocker.block('block');
 	reject(new Error());

discord/notifier.test.ts

@@ -104,7 +104,7 @@ describe('discord', () => {
 
 			const slack = new Slack();
 
-			const postMessage = slack.webClient.chat.postMessage as vi.MockedFunction<typeof slack.webClient.chat.postMessage>;
+			const postMessage = vi.mocked(slack.webClient.chat.postMessage);
 			postMessage.mockResolvedValue({
 				ok: true,
 				ts: '123456789.123456',
@@ -165,7 +165,7 @@ describe('discord', () => {
 
 			const slack = new Slack();
 
-			const postMessage = slack.webClient.chat.postMessage as vi.MockedFunction<typeof slack.webClient.chat.postMessage>;
+			const postMessage = vi.mocked(slack.webClient.chat.postMessage);
 			postMessage.mockResolvedValue({
 				ok: true,
 				ts: '123456789.123456',
@@ -226,7 +226,7 @@ describe('discord', () => {
 
 			const slack = new Slack();
 
-			const postMessage = slack.webClient.chat.postMessage as vi.MockedFunction<typeof slack.webClient.chat.postMessage>;
+			const postMessage = vi.mocked(slack.webClient.chat.postMessage);
 			postMessage.mockResolvedValue({ok: false});
 
 			const notifier = new Notifier(slack.webClient);
@@ -242,7 +242,7 @@ describe('discord', () => {
 
 			const slack = new Slack();
 
-			const postMessage = slack.webClient.chat.postMessage as vi.MockedFunction<typeof slack.webClient.chat.postMessage>;
+			const postMessage = vi.mocked(slack.webClient.chat.postMessage);
 			postMessage.mockImplementation((message) => {
 				if (message.channel === FAKE_SANDBOX) {
 					return Promise.resolve({
@@ -260,7 +260,7 @@ describe('discord', () => {
 
 			await notifier.voiceStateUpdate(EMPTY_CHANNEL_STATE, JOINED_CHANNEL_STATE);
 
-			const deleteMessage = slack.webClient.chat.delete as vi.MockedFunction<typeof slack.webClient.chat.delete>;
+			const deleteMessage = vi.mocked(slack.webClient.chat.delete);
 			deleteMessage.mockResolvedValue({ok: true});
 
 			await notifier.voiceStateUpdate(JOINED_CHANNEL_STATE, EMPTY_CHANNEL_STATE);
@@ -278,7 +278,7 @@ describe('discord', () => {
 
 			const slack = new Slack();
 
-			const postMessage = slack.webClient.chat.postMessage as vi.MockedFunction<typeof slack.webClient.chat.postMessage>;
+			const postMessage = vi.mocked(slack.webClient.chat.postMessage);
 			postMessage.mockResolvedValue({
 				ok: true,
 				ts: '123456789.123456',

helloworld/HelloWorld.test.ts

@@ -52,7 +52,7 @@ describe('helloworld', () => {
 	});
 
 	it('can post Hello world message', async () => {
-		const postMessage = slack.webClient.chat.postMessage as vi.MockedFunction<typeof slack.webClient.chat.postMessage>;
+		const postMessage = vi.mocked(slack.webClient.chat.postMessage);
 		postMessage.mockResolvedValueOnce({
 			ok: true,
 			ts: slack.fakeTimestamp,
@@ -69,7 +69,7 @@ describe('helloworld', () => {
 			channel: slack.fakeChannel,
 		});
 
-		const mockedPostMessage = slack.webClient.chat.postMessage as vi.MockedFunction<typeof slack.webClient.chat.postMessage>;
+		const mockedPostMessage = vi.mocked(slack.webClient.chat.postMessage);
 		expect(mockedPostMessage).toBeCalledWith({
 			username: 'helloworld [TEST_AUTHORITY]',
 			channel: slack.fakeChannel,

lib/channelLimitedBot.test.ts

@@ -1,6 +1,7 @@
 import {GenericMessageEvent} from '@slack/web-api';
 import {ChannelLimitedBot} from './channelLimitedBot';
 import Slack from './slackMock';
+import type {Mock} from 'vitest';
 
 vi.mock('../lib/slackUtils');
 
@@ -13,25 +14,25 @@ describe('ChannelLimitedBot', () => {
 		process.env.CHANNEL_GAMES = slack.fakeChannel;
 		process.env.HAKATASHI_TOKEN = 'xoxb-hakatashi-token';
 
-		(slack.webClient.chat.getPermalink as vi.Mock).mockResolvedValue({
+		(slack.webClient.chat.getPermalink as Mock).mockResolvedValue({
 			ok: true,
 			permalink: 'https://slack.com/archives/CHANNEL_ID/p1234567890123456',
 		});
-		(slack.webClient.chat.postEphemeral as vi.Mock).mockResolvedValue({
+		(slack.webClient.chat.postEphemeral as Mock).mockResolvedValue({
 			ok: true,
 			message_ts: '12345.6789',
 		});
-		(slack.webClient.chat.postMessage as vi.Mock).mockResolvedValue({
+		(slack.webClient.chat.postMessage as Mock).mockResolvedValue({
 			ok: true,
 			ts: 'progress.123',
 		});
-		(slack.webClient.chat.delete as vi.Mock).mockResolvedValue({
+		(slack.webClient.chat.delete as Mock).mockResolvedValue({
 			ok: true,
 		});
 	});
 
 	it('responds to messages containing the wake word in the allowed channel', async () => {
-		const onWakeWord = vi.fn<Promise<string | null>, [GenericMessageEvent, string]>();
+		const onWakeWord = vi.fn<(message: GenericMessageEvent, channel: string) => Promise<string | null>>();
 
 		class TestBot extends ChannelLimitedBot {
 			protected override wakeWordRegex = /wakeword/;
@@ -52,7 +53,7 @@ describe('ChannelLimitedBot', () => {
 	});
 
 	it('posts ephemeral message and deletes original when wake word is used in disallowed channel (null response)', async () => {
-		const onWakeWord = vi.fn<Promise<string | null>, [GenericMessageEvent, string]>();
+		const onWakeWord = vi.fn<(message: GenericMessageEvent, channel: string) => Promise<string | null>>();
 		const disallowedChannel = 'C9876543210';
 
 		class TestBot extends ChannelLimitedBot {
@@ -89,7 +90,7 @@ describe('ChannelLimitedBot', () => {
 	});
 
 	it('posts ephemeral message with permalink and deletes original when wake word is used in disallowed channel (with response)', async () => {
-		const onWakeWord = vi.fn<Promise<string | null>, [GenericMessageEvent, string]>();
+		const onWakeWord = vi.fn<(message: GenericMessageEvent, channel: string) => Promise<string | null>>();
 		const disallowedChannel = 'C9876543210';
 		const responseTs = '12345.6789';
 		const progressChannel = 'CPROGRESS';
@@ -134,7 +135,7 @@ describe('ChannelLimitedBot', () => {
 	});
 
 	it('ignores messages without the wake word', async () => {
-		const onWakeWord = vi.fn<Promise<string | null>, [GenericMessageEvent, string]>();
+		const onWakeWord = vi.fn<(message: GenericMessageEvent, channel: string) => Promise<string | null>>();
 
 		class TestBot extends ChannelLimitedBot {
 			protected override wakeWordRegex = /wakeword/;
@@ -149,7 +150,7 @@ describe('ChannelLimitedBot', () => {
 	});
 
 	it('ignores messages from bots', async () => {
-		const onWakeWord = vi.fn<Promise<string | null>, [GenericMessageEvent, string]>();
+		const onWakeWord = vi.fn<(message: GenericMessageEvent, channel: string) => Promise<string | null>>();
 
 		class TestBot extends ChannelLimitedBot {
 			protected override wakeWordRegex = /wakeword/;
@@ -167,7 +168,7 @@ describe('ChannelLimitedBot', () => {
 	});
 
 	it('ignores messages without user', async () => {
-		const onWakeWord = vi.fn<Promise<string | null>, [GenericMessageEvent, string]>();
+		const onWakeWord = vi.fn<(message: GenericMessageEvent, channel: string) => Promise<string | null>>();
 
 		class TestBot extends ChannelLimitedBot {
 			protected override wakeWordRegex = /wakeword/;
@@ -187,7 +188,7 @@ describe('ChannelLimitedBot', () => {
 	});
 
 	it('ignores messages without text', async () => {
-		const onWakeWord = vi.fn<Promise<string | null>, [GenericMessageEvent, string]>();
+		const onWakeWord = vi.fn<(message: GenericMessageEvent, channel: string) => Promise<string | null>>();
 
 		class TestBot extends ChannelLimitedBot {
 			protected override wakeWordRegex = /wakeword/;

lib/download.test.ts

@@ -2,6 +2,7 @@ import axios from 'axios';
 import fs from 'node:fs';
 import { PassThrough } from 'stream';
 import { download } from './download';
+import type { Mock } from 'vitest';
 
 vi.mock('axios');
 vi.mock('node:fs', () => {
@@ -21,7 +22,7 @@ const fakePath = '~/fake/path';
 const fakeUrl = 'https://www.example.com';
 
 beforeAll(() => {
-    (<vi.Mock> axios.get).mockImplementation(() => {
+    (<Mock> axios.get).mockImplementation(() => {
         const stream = new PassThrough();
         process.nextTick(() => {
             stream.end(fakeData);
@@ -35,12 +36,12 @@ beforeEach(() => {
 });
 
 it('downloads fetched data to path', async () => {
-    (<vi.Mock> (fs.access as any)).mockImplementation((_, __, callback) => {
+    (<Mock> (fs.access as any)).mockImplementation((_, __, callback) => {
         callback(true);
     });
     await Promise.all([
         new Promise<void>((resolve) => {
-            (<vi.Mock> fs.createWriteStream).mockReturnValue(
+            (<Mock> fs.createWriteStream).mockReturnValue(
                 new PassThrough().on('data', (data) => {
                     expect(data).toBe(fakeData)
                     resolve();
@@ -49,17 +50,17 @@ it('downloads fetched data to path', async () => {
         }),
         download(fakePath, fakeUrl)
     ]);
-    expect((<vi.Mock> axios.get).mock.calls.length).toBe(1);
-    expect((<vi.Mock> axios.get).mock.calls[0][0]).toBe(fakeUrl);
-    expect((<vi.Mock> fs.createWriteStream).mock.calls.length).toBe(1);
-    expect((<vi.Mock> fs.createWriteStream).mock.calls[0][0]).toBe(fakePath);
+    expect((<Mock> axios.get).mock.calls.length).toBe(1);
+    expect((<Mock> axios.get).mock.calls[0][0]).toBe(fakeUrl);
+    expect((<Mock> fs.createWriteStream).mock.calls.length).toBe(1);
+    expect((<Mock> fs.createWriteStream).mock.calls[0][0]).toBe(fakePath);
 });
 
 it('does not download when file exists', async () => {
-    (<vi.Mock> (fs.access as any)).mockImplementation((_, __, callback) => {
+    (<Mock> (fs.access as any)).mockImplementation((_, __, callback) => {
         callback(false);
     });
     await download(fakePath, fakeUrl);
-    expect((<vi.Mock> axios.get).mock.calls.length).toBe(0);
-    expect((<vi.Mock> fs.createWriteStream).mock.calls.length).toBe(0);
+    expect((<Mock> axios.get).mock.calls.length).toBe(0);
+    expect((<Mock> fs.createWriteStream).mock.calls.length).toBe(0);
 });

lib/eventDeduplication.test.ts

@@ -3,11 +3,12 @@ import {
 	closeDuplicateEventChecker,
 } from './eventDeduplication';
 import { createClient } from 'redis';
+import type { Mock, Mocked } from 'vitest';
 
 const mockRedis: Pick<
-	vi.Mocked<ReturnType<typeof createClient>>,
-	'set' | 'connect' | 'quit' | 'on'
-> = {
+	Mocked<ReturnType<typeof createClient>>,
+	'set' | 'connect' | 'quit'
+> & {on: Mock<ReturnType<typeof createClient>['on']>} = {
 	set: vi.fn(),
 	connect: vi.fn(),
 	quit: vi.fn(),