Scrapbox: 指定したページが更新されても通知が来ないようにする

.env.example

@@ -7,13 +7,15 @@ SWARM_TOKEN=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 CHANNEL_SANDBOX=CXXXXXXXX
 CHANNEL_ESOLANG=CXXXXXXXX
 CHANNEL_PROCON=CXXXXXXXX
+CHANNEL_SCRAPBOX=CXXXXXXXX
 CHANNEL_RANDOM=CXXXXXXXX
 USER_TSGBOT=UXXXXXXXX
 GITHUB_TOKEN=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 GOOGLE_APPLICATION_CREDENTIALS=google_application_credentials.json
 FIREBASE_ENDPOINT=https://hakata-shi.firebaseio.com
 ACCUWEATHER_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 SCRAPBOX_SID=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+SCRAPBOX_PROJECT_NAME=xxxxxxxxx
 GITHUB_WEBHOOK_SECRET=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 SIGNING_SECRET=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 PORT=21864

index.js

@@ -31,6 +31,7 @@ const allBots = [
 	// ...(word2vecInstalled ? ['vocabwar'] : []),
 	'ricochet-robots',
 	'scrapbox',
+	'scrapbox/mute',
 	'slack-log',
 	'welcome',
 	'deploy',

lib/fastify.test.ts

@@ -0,0 +1,24 @@
+import plugin from 'fastify-plugin';
+import { fastifyDevConstructor } from './fastify';
+import { FastifyInstance } from 'fastify';
+
+describe('fastifyDevConstructor', () => {
+    it('throws error when error occures during request', () => {
+        const fastify: FastifyInstance = fastifyDevConstructor();
+        const msg = 'Dummy error.';
+        const path = '/path/to/somewhere';
+        fastify.register(plugin((fastify, opts, next) => {
+            fastify.get(path, (req) => {
+                throw Error(msg);
+            })
+            next();
+        }))
+        expect(
+            fastify.inject({
+                method: 'GET',
+                url: path,
+                payload: {something: 'hoge'},
+            })
+        ).rejects.toThrow(msg);
+    })
+});

lib/fastify.ts

@@ -0,0 +1,34 @@
+import fastifyConstructor, { FastifyInstance } from 'fastify';
+
+/**
+ * 単体テストに適した設定がなされたfastifyインスタンスを生成する
+ * 
+ * @param opts fastifyConstructor に渡す引数
+ * @example
+ * import slack from '../lib/slackMock.js';
+ * import {fastifyDevConstructor} from '../lib/fastify';
+ * import {server} from './index';
+ * 
+ * const fastify = fastifyDevConstructor();
+ * fastify.register(server(slack));
+ */
+
+export const fastifyDevConstructor = (opts?: Parameters<typeof fastifyConstructor>[0]): FastifyInstance => {
+    // TODO: support generics of fastifyConstructor
+    /*
+     * Setting the return type to ReturnType<fastifyConstructor> causes typeerror
+     * because type Server is not compatible with type Http2SecureServer
+     * Maybe because of not handling the generics of fastifyConstructor
+     */
+
+    const fastify = fastifyConstructor({ logger: true , ...opts });
+
+    /**
+     * デフォルトのエラーハンドラはエラーをログに出力して握り潰すため，
+     * 単体テストでexpectの失敗などによる例外をJestが検知することができない
+     * 発生した例外は全て再送出するように設定
+     */
+    fastify.setErrorHandler((err) => { throw err; });
+
+    return fastify;
+};

lib/scrapbox.test.ts

@@ -0,0 +1,184 @@
+const defaultProjectName = 'default_proj';
+process.env.SCRAPBOX_PROJECT_NAME = defaultProjectName;
+const defaultToken = 'default_token';
+process.env.SCRAPBOX_SID = defaultToken;
+
+jest.mock('axios');
+import _axios from 'axios';
+const axios = _axios as jest.Mocked<typeof _axios>;
+
+import { isPageOfProject, fetchScrapboxUrl, Page, pageUrlRegExp } from './scrapbox';
+
+beforeEach(() => {
+    axios.get.mockReset();
+})
+
+describe('fetchScrapboxUrl', () => {
+    const data = {dummy: 'data'};
+    const url = 'dummy_url';
+    const token = 'dummy_token';
+
+    beforeEach(() => {
+        axios.get.mockResolvedValueOnce({ data });
+    });
+
+    it('fetches given URL with given token', async () => {
+        const res = await fetchScrapboxUrl({ url, token });
+        expect(res).toEqual(data);
+        expect(axios.get.mock.calls.length).toBe(1);
+        expect(axios.get.mock.calls[0][0]).toBe(url);
+        expect(axios.get.mock.calls[0][1]!.headers.Cookie).toContain(token);
+    });
+
+    it('uses default token if not specified', async () => {
+        await fetchScrapboxUrl({ url });
+        expect(axios.get.mock.calls[0][1]!.headers.Cookie).toContain(defaultToken);
+    });
+});
+
+describe('pageUrlRegExp', () => {
+    const projectName = 'proj';
+    const titleLc = 'タイトル';
+    const hash = 'hash';
+
+    it('parses URL without hash', () => {
+        const match = `https://scrapbox.io/${projectName}/${titleLc}`.match(pageUrlRegExp);
+        expect(match).not.toBeNull();
+        expect(match!.groups).toMatchObject({ projectName, titleLc });
+    });
+
+    it('parses URL with hash', () => {
+        const match = `https://scrapbox.io/${projectName}/${titleLc}#${hash}`.match(pageUrlRegExp);
+        expect(match).not.toBeNull();
+        expect(match!.groups).toMatchObject({ projectName, titleLc, hash });
+    });
+});
+
+describe('isPageOfProject', () => {
+    const projectName = 'proj';
+    const projectName2 = 'proj2';
+    const titleLc = 'タイトル';
+
+    it('returns true for Scrapbox URL of specified project', () => {
+        const url = `https://scrapbox.io/${projectName}/${titleLc}`;
+        expect(isPageOfProject({ url, projectName })).toBe(true);
+    });
+
+    it('returns false for Scrapbox URL of specified project', () => {
+        const url = `https://scrapbox.io/${projectName2}/${titleLc}`;
+        expect(isPageOfProject({ url, projectName })).toBe(false);
+    });
+
+    it('returns false for strings not Scrapbox URL', () => {
+        const url = 'hoge';
+        expect(isPageOfProject({ url, projectName })).toBe(false);
+    });
+
+    test.each([
+        {projectName: defaultProjectName, expected: true},
+        {projectName: projectName, expected: false}
+    ])('uses projectName specified in envvar when not specified #%#', ({ projectName, expected }) => {
+        const url = `https://scrapbox.io/${projectName}/${titleLc}`;
+        expect(isPageOfProject({ url })).toBe(expected);
+    });
+});
+
+describe('Page', () => {
+    const projectName = 'proj';
+    const titleLc = 'タイトル';
+    const encodedTitleLc = encodeURIComponent(titleLc);
+    const hash = 'hash';
+    const token = 'token';
+
+    describe('constructor', () => {
+        const assertProperties = (page: Page): void => {
+            expect(page.token).toBe(token);
+            expect(page.projectName).toBe(projectName);
+            expect(page.titleLc).toBe(titleLc);
+            expect(page.encodedTitleLc).toBe(encodedTitleLc);
+            expect(page.hash).toBe(hash);
+        };
+
+        const generateURL = ({ projectName, titleLc, hash }: { projectName: string; titleLc: string; hash: string }) => 
+            `https://scrapbox.io/${projectName}/${titleLc}#${hash}`;
+
+        it('handles unencoded titleLc', () => {
+            assertProperties(new Page({ titleLc, projectName, hash, isEncoded: false, token }));
+        });
+
+        it('handles encoded titleLc', () => {
+            assertProperties(new Page({ titleLc: encodedTitleLc, projectName, hash, isEncoded: true, token }));
+        });
+
+        it('assumes unencoded titleLc to be unencoded', () => {
+            assertProperties(new Page({ titleLc, projectName, hash, isEncoded: undefined, token }));
+        });
+
+        it('assumes encoded titleLc to be encoded', () => {
+            assertProperties(new Page({ titleLc: encodedTitleLc, projectName, hash, isEncoded: undefined, token }));
+        });
+
+
+        it('handles unencoded URL', () => {
+            const url = generateURL({ projectName, titleLc, hash });
+            assertProperties(new Page({ url, isEncoded: false, token }));
+        });
+
+        it('handles encoded URL', () => {
+            const url = generateURL({ projectName, titleLc: encodedTitleLc, hash });
+            assertProperties(new Page({ url, isEncoded: true, token }));
+        });
+
+        it('assumes unencoded URL to be unencoded', () => {
+            const url = generateURL({ projectName, titleLc, hash });
+            assertProperties(new Page({ url, isEncoded: undefined, token }));
+        });
+
+        it('assumes encoded URL to be encoded', () => {
+            const url = generateURL({ projectName, titleLc: encodedTitleLc, hash });
+            assertProperties(new Page({ url, isEncoded: undefined, token }));
+        });
+        it('handles encoded URL', () => {
+            const url = generateURL({ projectName, titleLc: encodedTitleLc, hash });
+            assertProperties(new Page({ url, isEncoded: undefined, token }));
+        });
+
+        it('handles missing parameters when specified titleLc', () => {
+            const page = new Page({ titleLc });
+            expect(page.projectName).toBe(defaultProjectName);
+            expect(page.token).toBe(defaultToken);
+            expect(page.hash).toBeUndefined();
+        });
+
+        it('handles missing parameters when specified URL', () => {
+            const page = new Page({ titleLc });
+            expect(page.token).toBe(defaultToken);
+        });
+
+        it('throws error on invalid URL', () => {
+            expect(() => new Page({ url: 'hoge' })).toThrow();
+        })
+    });
+
+    describe('methods', () => {
+        let page: Page | null = null;
+        beforeEach(() => {
+            page = new Page({ titleLc, projectName, hash, token });
+        });
+
+        test('.url is correct', () => {
+            expect(page!.url).toBe(`https://scrapbox.io/${projectName}/${encodedTitleLc}#${hash}`);
+        });
+
+        test('.infoUrl is correct', () => {
+            expect(page!.infoUrl).toBe(`https://scrapbox.io/api/pages/${projectName}/${encodedTitleLc}`);
+        });
+
+        test('.fetchInfo() fetches from correct URL', async () => {
+            axios.get.mockResolvedValueOnce({ data: {} });
+            await page!.fetchInfo();
+            expect(axios.get.mock.calls.length).toBe(1);
+            expect(axios.get.mock.calls[0][0]/* url of 0th call */).toBe(page!.infoUrl);
+        });
+    });
+});