usbharu
/
misskey
mirror of https://github.com/misskey-dev/misskey.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

test(backend): APIテストの復活 (#10163) 

* Revert 1c5291f818

* APIテストの復活

* apiテストの移行

* moduleNameMapper修正

* simpleGetでthrowしないように

status確認しているので要らない

* longer timeout

* ローカルでは問題ないのになんで

* case sensitive

* Run Nest instance within the current process

* Skip some setIntervals

* wait for 5 seconds

* kill them all!!

* logHeapUsage: true

* detectOpenHandlesがじゃましているらしい

* maxWorkers=1?

* restore drive api tests

* workerIdleMemoryLimit: 500MB

* 1024MiB

* Wait what
This commit is contained in:
Kagami Sascha Rosylight 2023-03-03 03:13:12 +01:00 committed by GitHub
parent 53987fadd7
commit 61215e50ff
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
27 changed files with 734 additions and 528 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
cypress/e2e/api.cy.js
View File

@ -1,11 +0,0 @@
describe('API', () => {
it('returns HTTP 404 to unknown API endpoint paths', () => {
cy.request({
url: '/api/foo',
failOnStatusCode: false,
}).then((response) => {
expect(response.status).to.eq(404);
expect(response.body.error.code).to.eq('UNKNOWN_API_ENDPOINT');
});
});
});

13
packages/backend/jest.config.cjs
View File

@ -91,7 +91,7 @@ module.exports = {
// See https://github.com/swc-project/jest/issues/64#issuecomment-1029753225 // See https://github.com/swc-project/jest/issues/64#issuecomment-1029753225
// TODO: Use `--allowImportingTsExtensions` on TypeScript 5.0 so that we can // TODO: Use `--allowImportingTsExtensions` on TypeScript 5.0 so that we can
// directly import `.ts` files without this hack. // directly import `.ts` files without this hack.
'^(\\.{1,2}/.*)\\.js$': '$1', '^((?:\\.{1,2}|[A-Z:])*/.*)\\.js$': '$1',
}, },
// An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
@ -160,7 +160,7 @@ module.exports = {
testMatch: [ testMatch: [
"<rootDir>/test/unit/**/*.ts", "<rootDir>/test/unit/**/*.ts",
"<rootDir>/src/**/*.test.ts", "<rootDir>/src/**/*.test.ts",
//"<rootDir>/test/e2e/**/*.ts" "<rootDir>/test/e2e/**/*.ts",
], ],
// An array of regexp pattern strings that are matched against all test paths, matched tests are skipped // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
@ -207,4 +207,13 @@ module.exports = {
// watchman: true, // watchman: true,
extensionsToTreatAsEsm: ['.ts'], extensionsToTreatAsEsm: ['.ts'],
testTimeout: 60000,
// Let Jest kill the test worker whenever it grows too much
// (It seems there's a known memory leak issue in Node.js' vm.Script used by Jest)
// https://github.com/facebook/jest/issues/11956
maxWorkers: 1, // Make it use worker (that can be killed and restarted)
logHeapUsage: true, // To debug when out-of-memory happens on CI
workerIdleMemoryLimit: '1GiB', // Limit the worker to 1GB (GitHub Workflows dies at 2GB)
}; };

5
packages/backend/package.json
View File

@ -15,8 +15,8 @@
"typecheck": "tsc --noEmit", "typecheck": "tsc --noEmit",
"eslint": "eslint --quiet \"src/**/*.ts\"", "eslint": "eslint --quiet \"src/**/*.ts\"",
"lint": "pnpm typecheck && pnpm eslint", "lint": "pnpm typecheck && pnpm eslint",
"jest": "cross-env NODE_ENV=test node --experimental-vm-modules --experimental-import-meta-resolve node_modules/jest/bin/jest.js --forceExit --runInBand --detectOpenHandles", "jest": "cross-env NODE_ENV=test node --experimental-vm-modules --experimental-import-meta-resolve node_modules/jest/bin/jest.js --forceExit",
"jest-and-coverage": "cross-env NODE_ENV=test node --experimental-vm-modules --experimental-import-meta-resolve node_modules/jest/bin/jest.js --coverage --forceExit --runInBand --detectOpenHandles", "jest-and-coverage": "cross-env NODE_ENV=test node --experimental-vm-modules --experimental-import-meta-resolve node_modules/jest/bin/jest.js --coverage --forceExit",
"jest-clear": "cross-env NODE_ENV=test node --experimental-vm-modules --experimental-import-meta-resolve node_modules/jest/bin/jest.js --clearCache", "jest-clear": "cross-env NODE_ENV=test node --experimental-vm-modules --experimental-import-meta-resolve node_modules/jest/bin/jest.js --clearCache",
"test": "pnpm jest", "test": "pnpm jest",
"test-and-coverage": "pnpm jest-and-coverage" "test-and-coverage": "pnpm jest-and-coverage"
@ -146,7 +146,6 @@
}, },
"devDependencies": { "devDependencies": {
"@jest/globals": "29.4.3", "@jest/globals": "29.4.3",
"@redocly/openapi-core": "1.0.0-beta.123",
"@swc/jest": "0.2.24", "@swc/jest": "0.2.24",
"@types/accepts": "1.3.5", "@types/accepts": "1.3.5",
"@types/archiver": "5.3.1", "@types/archiver": "5.3.1",

9
packages/backend/src/GlobalModule.ts
View File

@ -1,3 +1,4 @@
import { setTimeout } from 'node:timers/promises';
import { Global, Inject, Module } from '@nestjs/common'; import { Global, Inject, Module } from '@nestjs/common';
import Redis from 'ioredis'; import Redis from 'ioredis';
import { DataSource } from 'typeorm'; import { DataSource } from 'typeorm';
@ -57,6 +58,14 @@ export class GlobalModule implements OnApplicationShutdown {
) {} ) {}
async onApplicationShutdown(signal: string): Promise<void> { async onApplicationShutdown(signal: string): Promise<void> {
if (process.env.NODE_ENV === 'test') {
// XXX:
// Shutting down the existing connections causes errors on Jest as
// Misskey has asynchronous postgres/redis connections that are not
// awaited.
// Let's wait for some random time for them to finish.
await setTimeout(5000);
}
await Promise.all([ await Promise.all([
this.db.destroy(), this.db.destroy(),
this.redisClient.disconnect(), this.redisClient.disconnect(),

4
packages/backend/src/boot/common.ts
View File

@ -16,12 +16,14 @@ export async function server() {
app.enableShutdownHooks(); app.enableShutdownHooks();
const serverService = app.get(ServerService); const serverService = app.get(ServerService);
serverService.launch(); await serverService.launch();
app.get(ChartManagementService).start(); app.get(ChartManagementService).start();
app.get(JanitorService).start(); app.get(JanitorService).start();
app.get(QueueStatsService).start(); app.get(QueueStatsService).start();
app.get(ServerStatsService).start(); app.get(ServerStatsService).start();
return app;
} }
export async function jobQueue() { export async function jobQueue() {

37
packages/backend/src/core/CreateNotificationService.ts
View File

@ -1,4 +1,5 @@
import { Inject, Injectable } from '@nestjs/common'; import { setTimeout } from 'node:timers/promises';
import { Inject, Injectable, OnApplicationShutdown } from '@nestjs/common';
import type { MutingsRepository, NotificationsRepository, UserProfilesRepository, UsersRepository } from '@/models/index.js'; import type { MutingsRepository, NotificationsRepository, UserProfilesRepository, UsersRepository } from '@/models/index.js';
import type { User } from '@/models/entities/User.js'; import type { User } from '@/models/entities/User.js';
import type { Notification } from '@/models/entities/Notification.js'; import type { Notification } from '@/models/entities/Notification.js';
@ -10,7 +11,9 @@ import { PushNotificationService } from '@/core/PushNotificationService.js';
import { bindThis } from '@/decorators.js'; import { bindThis } from '@/decorators.js';
@Injectable() @Injectable()
export class CreateNotificationService { export class CreateNotificationService implements OnApplicationShutdown {
#shutdownController = new AbortController();
constructor( constructor(
@Inject(DI.usersRepository) @Inject(DI.usersRepository)
private usersRepository: UsersRepository, private usersRepository: UsersRepository,
@ -40,11 +43,11 @@ export class CreateNotificationService {
if (data.notifierId && (notifieeId === data.notifierId)) { if (data.notifierId && (notifieeId === data.notifierId)) {
return null; return null;
} }
const profile = await this.userProfilesRepository.findOneBy({ userId: notifieeId }); const profile = await this.userProfilesRepository.findOneBy({ userId: notifieeId });
const isMuted = profile?.mutingNotificationTypes.includes(type); const isMuted = profile?.mutingNotificationTypes.includes(type);
// Create notification // Create notification
const notification = await this.notificationsRepository.insert({ const notification = await this.notificationsRepository.insert({
id: this.idService.genId(), id: this.idService.genId(),
@ -56,18 +59,18 @@ export class CreateNotificationService {
...data, ...data,
} as Partial<Notification>) } as Partial<Notification>)
.then(x => this.notificationsRepository.findOneByOrFail(x.identifiers[0])); .then(x => this.notificationsRepository.findOneByOrFail(x.identifiers[0]));
const packed = await this.notificationEntityService.pack(notification, {}); const packed = await this.notificationEntityService.pack(notification, {});
// Publish notification event // Publish notification event
this.globalEventService.publishMainStream(notifieeId, 'notification', packed); this.globalEventService.publishMainStream(notifieeId, 'notification', packed);
// 2秒経っても(今回作成した)通知が既読にならなかったら「未読の通知がありますよ」イベントを発行する // 2秒経っても(今回作成した)通知が既読にならなかったら「未読の通知がありますよ」イベントを発行する
setTimeout(async () => { setTimeout(2000, 'unread note', { signal: this.#shutdownController.signal }).then(async () => {
const fresh = await this.notificationsRepository.findOneBy({ id: notification.id }); const fresh = await this.notificationsRepository.findOneBy({ id: notification.id });
if (fresh == null) return; // 既に削除されているかもしれない if (fresh == null) return; // 既に削除されているかもしれない
if (fresh.isRead) return; if (fresh.isRead) return;
//#region ただしミュートしているユーザーからの通知なら無視 //#region ただしミュートしているユーザーからの通知なら無視
const mutings = await this.mutingsRepository.findBy({ const mutings = await this.mutingsRepository.findBy({
muterId: notifieeId, muterId: notifieeId,
@ -76,14 +79,14 @@ export class CreateNotificationService {
return; return;
} }
//#endregion //#endregion
this.globalEventService.publishMainStream(notifieeId, 'unreadNotification', packed); this.globalEventService.publishMainStream(notifieeId, 'unreadNotification', packed);
this.pushNotificationService.pushNotification(notifieeId, 'notification', packed); this.pushNotificationService.pushNotification(notifieeId, 'notification', packed);
if (type === 'follow') this.emailNotificationFollow(notifieeId, await this.usersRepository.findOneByOrFail({ id: data.notifierId! })); if (type === 'follow') this.emailNotificationFollow(notifieeId, await this.usersRepository.findOneByOrFail({ id: data.notifierId! }));
if (type === 'receiveFollowRequest') this.emailNotificationReceiveFollowRequest(notifieeId, await this.usersRepository.findOneByOrFail({ id: data.notifierId! })); if (type === 'receiveFollowRequest') this.emailNotificationReceiveFollowRequest(notifieeId, await this.usersRepository.findOneByOrFail({ id: data.notifierId! }));
}, 2000); }, () => { /* aborted, ignore it */ });
return notification; return notification;
} }
@ -103,7 +106,7 @@ export class CreateNotificationService {
sendEmail(userProfile.email, i18n.t('_email._follow.title'), `${follower.name} (@${Acct.toString(follower)})`, `${follower.name} (@${Acct.toString(follower)})`); sendEmail(userProfile.email, i18n.t('_email._follow.title'), `${follower.name} (@${Acct.toString(follower)})`, `${follower.name} (@${Acct.toString(follower)})`);
*/ */
} }
@bindThis @bindThis
private async emailNotificationReceiveFollowRequest(userId: User['id'], follower: User) { private async emailNotificationReceiveFollowRequest(userId: User['id'], follower: User) {
/* /*
@ -115,4 +118,8 @@ export class CreateNotificationService {
sendEmail(userProfile.email, i18n.t('_email._receiveFollowRequest.title'), `${follower.name} (@${Acct.toString(follower)})`, `${follower.name} (@${Acct.toString(follower)})`); sendEmail(userProfile.email, i18n.t('_email._receiveFollowRequest.title'), `${follower.name} (@${Acct.toString(follower)})`, `${follower.name} (@${Acct.toString(follower)})`);
*/ */
} }
onApplicationShutdown(signal?: string | undefined): void {
this.#shutdownController.abort();
}
} }

16
packages/backend/src/core/NoteCreateService.ts
View File

@ -1,6 +1,7 @@
import { setImmediate } from 'node:timers/promises';
import * as mfm from 'mfm-js'; import * as mfm from 'mfm-js';
import { In, DataSource } from 'typeorm'; import { In, DataSource } from 'typeorm';
import { Inject, Injectable } from '@nestjs/common'; import { Inject, Injectable, OnApplicationShutdown } from '@nestjs/common';
import { extractMentions } from '@/misc/extract-mentions.js'; import { extractMentions } from '@/misc/extract-mentions.js';
import { extractCustomEmojisFromMfm } from '@/misc/extract-custom-emojis-from-mfm.js'; import { extractCustomEmojisFromMfm } from '@/misc/extract-custom-emojis-from-mfm.js';
import { extractHashtags } from '@/misc/extract-hashtags.js'; import { extractHashtags } from '@/misc/extract-hashtags.js';
@ -137,7 +138,9 @@ type Option = {
}; };
@Injectable() @Injectable()
export class NoteCreateService { export class NoteCreateService implements OnApplicationShutdown {
#shutdownController = new AbortController();
constructor( constructor(
@Inject(DI.config) @Inject(DI.config)
private config: Config, private config: Config,
@ -313,7 +316,10 @@ export class NoteCreateService {
const note = await this.insertNote(user, data, tags, emojis, mentionedUsers); const note = await this.insertNote(user, data, tags, emojis, mentionedUsers);
setImmediate(() => this.postNoteCreated(note, user, data, silent, tags!, mentionedUsers!)); setImmediate('post created', { signal: this.#shutdownController.signal }).then(
() => this.postNoteCreated(note, user, data, silent, tags!, mentionedUsers!),
() => { /* aborted, ignore this */ },
);
return note; return note;
} }
@ -756,4 +762,8 @@ export class NoteCreateService {
return mentionedUsers; return mentionedUsers;
} }
onApplicationShutdown(signal?: string | undefined) {
this.#shutdownController.abort();
}
} }

47
packages/backend/src/core/NoteReadService.ts
View File

@ -1,4 +1,5 @@
import { Inject, Injectable } from '@nestjs/common'; import { setTimeout } from 'node:timers/promises';
import { Inject, Injectable, OnApplicationShutdown } from '@nestjs/common';
import { In, IsNull, Not } from 'typeorm'; import { In, IsNull, Not } from 'typeorm';
import { DI } from '@/di-symbols.js'; import { DI } from '@/di-symbols.js';
import type { User } from '@/models/entities/User.js'; import type { User } from '@/models/entities/User.js';
@ -15,7 +16,9 @@ import { AntennaService } from './AntennaService.js';
import { PushNotificationService } from './PushNotificationService.js'; import { PushNotificationService } from './PushNotificationService.js';
@Injectable() @Injectable()
export class NoteReadService { export class NoteReadService implements OnApplicationShutdown {
#shutdownController = new AbortController();
constructor( constructor(
@Inject(DI.usersRepository) @Inject(DI.usersRepository)
private usersRepository: UsersRepository, private usersRepository: UsersRepository,
@ -60,14 +63,14 @@ export class NoteReadService {
}); });
if (mute.map(m => m.muteeId).includes(note.userId)) return; if (mute.map(m => m.muteeId).includes(note.userId)) return;
//#endregion //#endregion
// スレッドミュート // スレッドミュート
const threadMute = await this.noteThreadMutingsRepository.findOneBy({ const threadMute = await this.noteThreadMutingsRepository.findOneBy({
userId: userId, userId: userId,
threadId: note.threadId ?? note.id, threadId: note.threadId ?? note.id,
}); });
if (threadMute) return; if (threadMute) return;
const unread = { const unread = {
id: this.idService.genId(), id: this.idService.genId(),
noteId: note.id, noteId: note.id,
@ -77,15 +80,15 @@ export class NoteReadService {
noteChannelId: note.channelId, noteChannelId: note.channelId,
noteUserId: note.userId, noteUserId: note.userId,
}; };
await this.noteUnreadsRepository.insert(unread); await this.noteUnreadsRepository.insert(unread);
// 2秒経っても既読にならなかったら「未読の投稿がありますよ」イベントを発行する // 2秒経っても既読にならなかったら「未読の投稿がありますよ」イベントを発行する
setTimeout(async () => { setTimeout(2000, 'unread note', { signal: this.#shutdownController.signal }).then(async () => {
const exist = await this.noteUnreadsRepository.findOneBy({ id: unread.id }); const exist = await this.noteUnreadsRepository.findOneBy({ id: unread.id });
if (exist == null) return; if (exist == null) return;
if (params.isMentioned) { if (params.isMentioned) {
this.globalEventService.publishMainStream(userId, 'unreadMention', note.id); this.globalEventService.publishMainStream(userId, 'unreadMention', note.id);
} }
@ -95,8 +98,8 @@ export class NoteReadService {
if (note.channelId) { if (note.channelId) {
this.globalEventService.publishMainStream(userId, 'unreadChannel', note.id); this.globalEventService.publishMainStream(userId, 'unreadChannel', note.id);
} }
}, 2000); }, () => { /* aborted, ignore it */ });
} }
@bindThis @bindThis
public async read( public async read(
@ -113,24 +116,24 @@ export class NoteReadService {
}, },
select: ['followeeId'], select: ['followeeId'],
})).map(x => x.followeeId)); })).map(x => x.followeeId));
const myAntennas = (await this.antennaService.getAntennas()).filter(a => a.userId === userId); const myAntennas = (await this.antennaService.getAntennas()).filter(a => a.userId === userId);
const readMentions: (Note | Packed<'Note'>)[] = []; const readMentions: (Note | Packed<'Note'>)[] = [];
const readSpecifiedNotes: (Note | Packed<'Note'>)[] = []; const readSpecifiedNotes: (Note | Packed<'Note'>)[] = [];
const readChannelNotes: (Note | Packed<'Note'>)[] = []; const readChannelNotes: (Note | Packed<'Note'>)[] = [];
const readAntennaNotes: (Note | Packed<'Note'>)[] = []; const readAntennaNotes: (Note | Packed<'Note'>)[] = [];
for (const note of notes) { for (const note of notes) {
if (note.mentions && note.mentions.includes(userId)) { if (note.mentions && note.mentions.includes(userId)) {
readMentions.push(note); readMentions.push(note);
} else if (note.visibleUserIds && note.visibleUserIds.includes(userId)) { } else if (note.visibleUserIds && note.visibleUserIds.includes(userId)) {
readSpecifiedNotes.push(note); readSpecifiedNotes.push(note);
} }
if (note.channelId && followingChannels.has(note.channelId)) { if (note.channelId && followingChannels.has(note.channelId)) {
readChannelNotes.push(note); readChannelNotes.push(note);
} }
if (note.user != null) { // たぶんnullになることは無いはずだけど一応 if (note.user != null) { // たぶんnullになることは無いはずだけど一応
for (const antenna of myAntennas) { for (const antenna of myAntennas) {
if (await this.antennaService.checkHitAntenna(antenna, note, note.user)) { if (await this.antennaService.checkHitAntenna(antenna, note, note.user)) {
@ -139,14 +142,14 @@ export class NoteReadService {
} }
} }
} }
if ((readMentions.length > 0) || (readSpecifiedNotes.length > 0) || (readChannelNotes.length > 0)) { if ((readMentions.length > 0) || (readSpecifiedNotes.length > 0) || (readChannelNotes.length > 0)) {
// Remove the record // Remove the record
await this.noteUnreadsRepository.delete({ await this.noteUnreadsRepository.delete({
userId: userId, userId: userId,
noteId: In([...readMentions.map(n => n.id), ...readSpecifiedNotes.map(n => n.id), ...readChannelNotes.map(n => n.id)]), noteId: In([...readMentions.map(n => n.id), ...readSpecifiedNotes.map(n => n.id), ...readChannelNotes.map(n => n.id)]),
}); });
// TODO: ↓まとめてクエリしたい // TODO: ↓まとめてクエリしたい
this.noteUnreadsRepository.countBy({ this.noteUnreadsRepository.countBy({
@ -183,7 +186,7 @@ export class NoteReadService {
noteId: In([...readMentions.map(n => n.id), ...readSpecifiedNotes.map(n => n.id)]), noteId: In([...readMentions.map(n => n.id), ...readSpecifiedNotes.map(n => n.id)]),
}); });
} }
if (readAntennaNotes.length > 0) { if (readAntennaNotes.length > 0) {
await this.antennaNotesRepository.update({ await this.antennaNotesRepository.update({
antennaId: In(myAntennas.map(a => a.id)), antennaId: In(myAntennas.map(a => a.id)),
@ -191,14 +194,14 @@ export class NoteReadService {
}, { }, {
read: true, read: true,
}); });
// TODO: まとめてクエリしたい // TODO: まとめてクエリしたい
for (const antenna of myAntennas) { for (const antenna of myAntennas) {
const count = await this.antennaNotesRepository.countBy({ const count = await this.antennaNotesRepository.countBy({
antennaId: antenna.id, antennaId: antenna.id,
read: false, read: false,
}); });
if (count === 0) { if (count === 0) {
this.globalEventService.publishMainStream(userId, 'readAntenna', antenna); this.globalEventService.publishMainStream(userId, 'readAntenna', antenna);
this.pushNotificationService.pushNotification(userId, 'readAntenna', { antennaId: antenna.id }); this.pushNotificationService.pushNotification(userId, 'readAntenna', { antennaId: antenna.id });
@ -213,4 +216,8 @@ export class NoteReadService {
}); });
} }
} }
onApplicationShutdown(signal?: string | undefined): void {
this.#shutdownController.abort();
}
} }

8
packages/backend/src/core/chart/ChartManagementService.ts
View File

@ -62,8 +62,10 @@ export class ChartManagementService implements OnApplicationShutdown {
async onApplicationShutdown(signal: string): Promise<void> { async onApplicationShutdown(signal: string): Promise<void> {
clearInterval(this.saveIntervalId); clearInterval(this.saveIntervalId);
await Promise.all( if (process.env.NODE_ENV !== 'test') {
this.charts.map(chart => chart.save()), await Promise.all(
); this.charts.map(chart => chart.save()),
);
}
} }
} }

4
packages/backend/src/core/chart/charts/per-user-notes.ts
View File

@ -45,8 +45,8 @@ export default class PerUserNotesChart extends Chart<typeof schema> {
} }
@bindThis @bindThis
public async update(user: { id: User['id'] }, note: Note, isAdditional: boolean): Promise<void> { public update(user: { id: User['id'] }, note: Note, isAdditional: boolean): void {
await this.commit({ this.commit({
'total': isAdditional ? 1 : -1, 'total': isAdditional ? 1 : -1,
'inc': isAdditional ? 1 : 0, 'inc': isAdditional ? 1 : 0,
'dec': isAdditional ? 0 : 1, 'dec': isAdditional ? 0 : 1,

16
packages/backend/src/server/ServerService.ts
View File

@ -1,7 +1,7 @@
import cluster from 'node:cluster'; import cluster from 'node:cluster';
import * as fs from 'node:fs'; import * as fs from 'node:fs';
import { Inject, Injectable } from '@nestjs/common'; import { Inject, Injectable, OnApplicationShutdown } from '@nestjs/common';
import Fastify from 'fastify'; import Fastify, { FastifyInstance } from 'fastify';
import { IsNull } from 'typeorm'; import { IsNull } from 'typeorm';
import { GlobalEventService } from '@/core/GlobalEventService.js'; import { GlobalEventService } from '@/core/GlobalEventService.js';
import type { Config } from '@/config.js'; import type { Config } from '@/config.js';
@ -23,8 +23,9 @@ import { FileServerService } from './FileServerService.js';
import { ClientServerService } from './web/ClientServerService.js'; import { ClientServerService } from './web/ClientServerService.js';
@Injectable() @Injectable()
export class ServerService { export class ServerService implements OnApplicationShutdown {
private logger: Logger; private logger: Logger;
#fastify: FastifyInstance;
constructor( constructor(
@Inject(DI.config) @Inject(DI.config)
@ -54,11 +55,12 @@ export class ServerService {
} }
@bindThis @bindThis
public launch() { public async launch() {
const fastify = Fastify({ const fastify = Fastify({
trustProxy: true, trustProxy: true,
logger: !['production', 'test'].includes(process.env.NODE_ENV ?? ''), logger: !['production', 'test'].includes(process.env.NODE_ENV ?? ''),
}); });
this.#fastify = fastify;
// HSTS // HSTS
// 6months (15552000sec) // 6months (15552000sec)
@ -203,5 +205,11 @@ export class ServerService {
}); });
fastify.listen({ port: this.config.port, host: '0.0.0.0' }); fastify.listen({ port: this.config.port, host: '0.0.0.0' });
await fastify.ready();
}
async onApplicationShutdown(signal: string): Promise<void> {
await this.#fastify.close();
} }
} }

5
packages/backend/src/server/api/ApiCallService.ts
View File

@ -100,9 +100,12 @@ export class ApiCallService implements OnApplicationShutdown {
request: FastifyRequest<{ Body: Record<string, unknown>, Querystring: Record<string, unknown> }>, request: FastifyRequest<{ Body: Record<string, unknown>, Querystring: Record<string, unknown> }>,
reply: FastifyReply, reply: FastifyReply,
) { ) {
const multipartData = await request.file(); const multipartData = await request.file().catch(() => {
/* Fastify throws if the remote didn't send multipart data. Return 400 below. */
});
if (multipartData == null) { if (multipartData == null) {
reply.code(400); reply.code(400);
reply.send();
return; return;
} }

12
packages/backend/src/server/api/ApiServerService.ts
View File

@ -73,28 +73,32 @@ export class ApiServerService {
Params: { endpoint: string; }, Params: { endpoint: string; },
Body: Record<string, unknown>, Body: Record<string, unknown>,
Querystring: Record<string, unknown>, Querystring: Record<string, unknown>,
}>('/' + endpoint.name, (request, reply) => { }>('/' + endpoint.name, async (request, reply) => {
if (request.method === 'GET' && !endpoint.meta.allowGet) { if (request.method === 'GET' && !endpoint.meta.allowGet) {
reply.code(405); reply.code(405);
reply.send(); reply.send();
return; return;
} }
this.apiCallService.handleMultipartRequest(ep, request, reply); // Await so that any error can automatically be translated to HTTP 500
await this.apiCallService.handleMultipartRequest(ep, request, reply);
return reply;
}); });
} else { } else {
fastify.all<{ fastify.all<{
Params: { endpoint: string; }, Params: { endpoint: string; },
Body: Record<string, unknown>, Body: Record<string, unknown>,
Querystring: Record<string, unknown>, Querystring: Record<string, unknown>,
}>('/' + endpoint.name, { bodyLimit: 1024 * 32 }, (request, reply) => { }>('/' + endpoint.name, { bodyLimit: 1024 * 32 }, async (request, reply) => {
if (request.method === 'GET' && !endpoint.meta.allowGet) { if (request.method === 'GET' && !endpoint.meta.allowGet) {
reply.code(405); reply.code(405);
reply.send(); reply.send();
return; return;
} }
this.apiCallService.handleRequest(ep, request, reply); // Await so that any error can automatically be translated to HTTP 500
await this.apiCallService.handleRequest(ep, request, reply);
return reply;
}); });
} }
} }

4
packages/backend/src/server/api/endpoints.ts
View File

@ -741,8 +741,8 @@ export interface IEndpoint {
const endpoints: IEndpoint[] = (eps as [string, any]).map(([name, ep]) => { const endpoints: IEndpoint[] = (eps as [string, any]).map(([name, ep]) => {
return { return {
name: name, name: name,
meta: ep.meta ?? {}, get meta() { return ep.meta ?? {}; },
params: ep.paramDef, get params() { return ep.paramDef; },
}; };
}); });

32
packages/backend/test/_e2e/api-visibility.ts → packages/backend/test/e2e/api-visibility.ts
View File

@ -1,18 +1,18 @@
process.env.NODE_ENV = 'test'; process.env.NODE_ENV = 'test';
import * as assert from 'assert'; import * as assert from 'assert';
import * as childProcess from 'child_process'; import { signup, api, post, startServer } from '../utils.js';
import { signup, request, post, startServer, shutdownServer } from '../utils.js'; import type { INestApplicationContext } from '@nestjs/common';
describe('API visibility', () => { describe('API visibility', () => {
let p: childProcess.ChildProcess; let p: INestApplicationContext;
beforeAll(async () => { beforeAll(async () => {
p = await startServer(); p = await startServer();
}, 1000 * 30); }, 1000 * 60 * 2);
afterAll(async () => { afterAll(async () => {
await shutdownServer(p); await p.close();
}); });
describe('Note visibility', () => { describe('Note visibility', () => {
@ -60,7 +60,7 @@ describe('API visibility', () => {
//#endregion //#endregion
const show = async (noteId: any, by: any) => { const show = async (noteId: any, by: any) => {
return await request('/notes/show', { return await api('/notes/show', {
noteId, noteId,
}, by); }, by);
}; };
@ -75,7 +75,7 @@ describe('API visibility', () => {
target2 = await signup({ username: 'target2' }); target2 = await signup({ username: 'target2' });
// follow alice <= follower // follow alice <= follower
await request('/following/create', { userId: alice.id }, follower); await api('/following/create', { userId: alice.id }, follower);
// normal posts // normal posts
pub = await post(alice, { text: 'x', visibility: 'public' }); pub = await post(alice, { text: 'x', visibility: 'public' });
@ -413,21 +413,21 @@ describe('API visibility', () => {
//#region HTL //#region HTL
test('[HTL] public-post が 自分が見れる', async () => { test('[HTL] public-post が 自分が見れる', async () => {
const res = await request('/notes/timeline', { limit: 100 }, alice); const res = await api('/notes/timeline', { limit: 100 }, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
const notes = res.body.filter((n: any) => n.id === pub.id); const notes = res.body.filter((n: any) => n.id === pub.id);
assert.strictEqual(notes[0].text, 'x'); assert.strictEqual(notes[0].text, 'x');
}); });
test('[HTL] public-post が 非フォロワーから見れない', async () => { test('[HTL] public-post が 非フォロワーから見れない', async () => {
const res = await request('/notes/timeline', { limit: 100 }, other); const res = await api('/notes/timeline', { limit: 100 }, other);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
const notes = res.body.filter((n: any) => n.id === pub.id); const notes = res.body.filter((n: any) => n.id === pub.id);
assert.strictEqual(notes.length, 0); assert.strictEqual(notes.length, 0);
}); });
test('[HTL] followers-post が フォロワーから見れる', async () => { test('[HTL] followers-post が フォロワーから見れる', async () => {
const res = await request('/notes/timeline', { limit: 100 }, follower); const res = await api('/notes/timeline', { limit: 100 }, follower);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
const notes = res.body.filter((n: any) => n.id === fol.id); const notes = res.body.filter((n: any) => n.id === fol.id);
assert.strictEqual(notes[0].text, 'x'); assert.strictEqual(notes[0].text, 'x');
@ -436,21 +436,21 @@ describe('API visibility', () => {
//#region RTL //#region RTL
test('[replies] followers-reply が フォロワーから見れる', async () => { test('[replies] followers-reply が フォロワーから見れる', async () => {
const res = await request('/notes/replies', { noteId: tgt.id, limit: 100 }, follower); const res = await api('/notes/replies', { noteId: tgt.id, limit: 100 }, follower);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
const notes = res.body.filter((n: any) => n.id === folR.id); const notes = res.body.filter((n: any) => n.id === folR.id);
assert.strictEqual(notes[0].text, 'x'); assert.strictEqual(notes[0].text, 'x');
}); });
test('[replies] followers-reply が 非フォロワー (リプライ先ではない) から見れない', async () => { test('[replies] followers-reply が 非フォロワー (リプライ先ではない) から見れない', async () => {
const res = await request('/notes/replies', { noteId: tgt.id, limit: 100 }, other); const res = await api('/notes/replies', { noteId: tgt.id, limit: 100 }, other);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
const notes = res.body.filter((n: any) => n.id === folR.id); const notes = res.body.filter((n: any) => n.id === folR.id);
assert.strictEqual(notes.length, 0); assert.strictEqual(notes.length, 0);
}); });
test('[replies] followers-reply が 非フォロワー (リプライ先である) から見れる', async () => { test('[replies] followers-reply が 非フォロワー (リプライ先である) から見れる', async () => {
const res = await request('/notes/replies', { noteId: tgt.id, limit: 100 }, target); const res = await api('/notes/replies', { noteId: tgt.id, limit: 100 }, target);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
const notes = res.body.filter((n: any) => n.id === folR.id); const notes = res.body.filter((n: any) => n.id === folR.id);
assert.strictEqual(notes[0].text, 'x'); assert.strictEqual(notes[0].text, 'x');
@ -459,14 +459,14 @@ describe('API visibility', () => {
//#region MTL //#region MTL
test('[mentions] followers-reply が 非フォロワー (リプライ先である) から見れる', async () => { test('[mentions] followers-reply が 非フォロワー (リプライ先である) から見れる', async () => {
const res = await request('/notes/mentions', { limit: 100 }, target); const res = await api('/notes/mentions', { limit: 100 }, target);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
const notes = res.body.filter((n: any) => n.id === folR.id); const notes = res.body.filter((n: any) => n.id === folR.id);
assert.strictEqual(notes[0].text, 'x'); assert.strictEqual(notes[0].text, 'x');
}); });
test('[mentions] followers-mention が 非フォロワー (メンション先である) から見れる', async () => { test('[mentions] followers-mention が 非フォロワー (メンション先である) から見れる', async () => {
const res = await request('/notes/mentions', { limit: 100 }, target); const res = await api('/notes/mentions', { limit: 100 }, target);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
const notes = res.body.filter((n: any) => n.id === folM.id); const notes = res.body.filter((n: any) => n.id === folM.id);
assert.strictEqual(notes[0].text, '@target x'); assert.strictEqual(notes[0].text, '@target x');
@ -474,4 +474,4 @@ describe('API visibility', () => {
//#endregion //#endregion
}); });
}); });
*/

52
packages/backend/test/_e2e/api.ts → packages/backend/test/e2e/api.ts
View File

@ -1,11 +1,11 @@
process.env.NODE_ENV = 'test'; process.env.NODE_ENV = 'test';
import * as assert from 'assert'; import * as assert from 'assert';
import * as childProcess from 'child_process'; import { signup, api, startServer } from '../utils.js';
import { async, signup, request, post, react, uploadFile, startServer, shutdownServer } from '../utils.js'; import type { INestApplicationContext } from '@nestjs/common';
describe('API', () => { describe('API', () => {
let p: childProcess.ChildProcess; let p: INestApplicationContext;
let alice: any; let alice: any;
let bob: any; let bob: any;
let carol: any; let carol: any;
@ -15,69 +15,69 @@ describe('API', () => {
alice = await signup({ username: 'alice' }); alice = await signup({ username: 'alice' });
bob = await signup({ username: 'bob' }); bob = await signup({ username: 'bob' });
carol = await signup({ username: 'carol' }); carol = await signup({ username: 'carol' });
}, 1000 * 30); }, 1000 * 60 * 2);
afterAll(async () => { afterAll(async () => {
await shutdownServer(p); await p.close();
}); });
describe('General validation', () => { describe('General validation', () => {
test('wrong type', async(async () => { test('wrong type', async () => {
const res = await request('/test', { const res = await api('/test', {
required: true, required: true,
string: 42, string: 42,
}); });
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('missing require param', async(async () => { test('missing require param', async () => {
const res = await request('/test', { const res = await api('/test', {
string: 'a', string: 'a',
}); });
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('invalid misskey:id (empty string)', async(async () => { test('invalid misskey:id (empty string)', async () => {
const res = await request('/test', { const res = await api('/test', {
required: true, required: true,
id: '', id: '',
}); });
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('valid misskey:id', async(async () => { test('valid misskey:id', async () => {
const res = await request('/test', { const res = await api('/test', {
required: true, required: true,
id: '8wvhjghbxu', id: '8wvhjghbxu',
}); });
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
})); });
test('default value', async(async () => { test('default value', async () => {
const res = await request('/test', { const res = await api('/test', {
required: true, required: true,
string: 'a', string: 'a',
}); });
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(res.body.default, 'hello'); assert.strictEqual(res.body.default, 'hello');
})); });
test('can set null even if it has default value', async(async () => { test('can set null even if it has default value', async () => {
const res = await request('/test', { const res = await api('/test', {
required: true, required: true,
nullableDefault: null, nullableDefault: null,
}); });
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(res.body.nullableDefault, null); assert.strictEqual(res.body.nullableDefault, null);
})); });
test('cannot set undefined if it has default value', async(async () => { test('cannot set undefined if it has default value', async () => {
const res = await request('/test', { const res = await api('/test', {
required: true, required: true,
nullableDefault: undefined, nullableDefault: undefined,
}); });
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(res.body.nullableDefault, 'hello'); assert.strictEqual(res.body.nullableDefault, 'hello');
})); });
}); });
}); });

22
packages/backend/test/_e2e/block.ts → packages/backend/test/e2e/block.ts
View File

@ -1,11 +1,11 @@
process.env.NODE_ENV = 'test'; process.env.NODE_ENV = 'test';
import * as assert from 'assert'; import * as assert from 'assert';
import * as childProcess from 'child_process'; import { signup, api, post, startServer } from '../utils.js';
import { signup, request, post, startServer, shutdownServer } from '../utils.js'; import type { INestApplicationContext } from '@nestjs/common';
describe('Block', () => { describe('Block', () => {
let p: childProcess.ChildProcess; let p: INestApplicationContext;
// alice blocks bob // alice blocks bob
let alice: any; let alice: any;
@ -17,14 +17,14 @@ describe('Block', () => {
alice = await signup({ username: 'alice' }); alice = await signup({ username: 'alice' });
bob = await signup({ username: 'bob' }); bob = await signup({ username: 'bob' });
carol = await signup({ username: 'carol' }); carol = await signup({ username: 'carol' });
}, 1000 * 30); }, 1000 * 60 * 2);
afterAll(async () => { afterAll(async () => {
await shutdownServer(p); await p.close();
}); });
test('Block作成', async () => { test('Block作成', async () => {
const res = await request('/blocking/create', { const res = await api('/blocking/create', {
userId: bob.id, userId: bob.id,
}, alice); }, alice);
@ -32,7 +32,7 @@ describe('Block', () => {
}); });
test('ブロックされているユーザーをフォローできない', async () => { test('ブロックされているユーザーをフォローできない', async () => {
const res = await request('/following/create', { userId: alice.id }, bob); const res = await api('/following/create', { userId: alice.id }, bob);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
assert.strictEqual(res.body.error.id, 'c4ab57cc-4e41-45e9-bfd9-584f61e35ce0'); assert.strictEqual(res.body.error.id, 'c4ab57cc-4e41-45e9-bfd9-584f61e35ce0');
@ -41,7 +41,7 @@ describe('Block', () => {
test('ブロックされているユーザーにリアクションできない', async () => { test('ブロックされているユーザーにリアクションできない', async () => {
const note = await post(alice, { text: 'hello' }); const note = await post(alice, { text: 'hello' });
const res = await request('/notes/reactions/create', { noteId: note.id, reaction: '👍' }, bob); const res = await api('/notes/reactions/create', { noteId: note.id, reaction: '👍' }, bob);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
assert.strictEqual(res.body.error.id, '20ef5475-9f38-4e4c-bd33-de6d979498ec'); assert.strictEqual(res.body.error.id, '20ef5475-9f38-4e4c-bd33-de6d979498ec');
@ -50,7 +50,7 @@ describe('Block', () => {
test('ブロックされているユーザーに返信できない', async () => { test('ブロックされているユーザーに返信できない', async () => {
const note = await post(alice, { text: 'hello' }); const note = await post(alice, { text: 'hello' });
const res = await request('/notes/create', { replyId: note.id, text: 'yo' }, bob); const res = await api('/notes/create', { replyId: note.id, text: 'yo' }, bob);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
assert.strictEqual(res.body.error.id, 'b390d7e1-8a5e-46ed-b625-06271cafd3d3'); assert.strictEqual(res.body.error.id, 'b390d7e1-8a5e-46ed-b625-06271cafd3d3');
@ -59,7 +59,7 @@ describe('Block', () => {
test('ブロックされているユーザーのノートをRenoteできない', async () => { test('ブロックされているユーザーのノートをRenoteできない', async () => {
const note = await post(alice, { text: 'hello' }); const note = await post(alice, { text: 'hello' });
const res = await request('/notes/create', { renoteId: note.id, text: 'yo' }, bob); const res = await api('/notes/create', { renoteId: note.id, text: 'yo' }, bob);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
assert.strictEqual(res.body.error.id, 'b390d7e1-8a5e-46ed-b625-06271cafd3d3'); assert.strictEqual(res.body.error.id, 'b390d7e1-8a5e-46ed-b625-06271cafd3d3');
@ -74,7 +74,7 @@ describe('Block', () => {
const bobNote = await post(bob); const bobNote = await post(bob);
const carolNote = await post(carol); const carolNote = await post(carol);
const res = await request('/notes/local-timeline', {}, bob); const res = await api('/notes/local-timeline', {}, bob);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(Array.isArray(res.body), true); assert.strictEqual(Array.isArray(res.body), true);

301
packages/backend/test/_e2e/endpoints.ts → packages/backend/test/e2e/endpoints.ts
View File

@ -1,29 +1,35 @@
process.env.NODE_ENV = 'test'; process.env.NODE_ENV = 'test';
import * as assert from 'assert'; import * as assert from 'assert';
import * as childProcess from 'child_process'; // node-fetch only supports it's own Blob yet
import * as openapi from '@redocly/openapi-core'; // https://github.com/node-fetch/node-fetch/pull/1664
import { startServer, signup, post, request, simpleGet, port, shutdownServer, api } from '../utils.js'; import { Blob } from 'node-fetch';
import { startServer, signup, post, api, uploadFile } from '../utils.js';
import type { INestApplicationContext } from '@nestjs/common';
describe('Endpoints', () => { describe('Endpoints', () => {
let p: childProcess.ChildProcess; let p: INestApplicationContext;
let alice: any; let alice: any;
let bob: any; let bob: any;
let carol: any;
let dave: any;
beforeAll(async () => { beforeAll(async () => {
p = await startServer(); p = await startServer();
alice = await signup({ username: 'alice' }); alice = await signup({ username: 'alice' });
bob = await signup({ username: 'bob' }); bob = await signup({ username: 'bob' });
}, 1000 * 30); carol = await signup({ username: 'carol' });
dave = await signup({ username: 'dave' });
}, 1000 * 60 * 2);
afterAll(async () => { afterAll(async () => {
await shutdownServer(p); await p.close();
}); });
describe('signup', () => { describe('signup', () => {
test('不正なユーザー名でアカウントが作成できない', async () => { test('不正なユーザー名でアカウントが作成できない', async () => {
const res = await request('api/signup', { const res = await api('signup', {
username: 'test.', username: 'test.',
password: 'test', password: 'test',
}); });
@ -31,7 +37,7 @@ describe('Endpoints', () => {
}); });
test('空のパスワードでアカウントが作成できない', async () => { test('空のパスワードでアカウントが作成できない', async () => {
const res = await request('api/signup', { const res = await api('signup', {
username: 'test', username: 'test',
password: '', password: '',
}); });
@ -44,7 +50,7 @@ describe('Endpoints', () => {
password: 'test1', password: 'test1',
}; };
const res = await request('api/signup', me); const res = await api('signup', me);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
@ -52,7 +58,7 @@ describe('Endpoints', () => {
}); });
test('同じユーザー名のアカウントは作成できない', async () => { test('同じユーザー名のアカウントは作成できない', async () => {
const res = await request('api/signup', { const res = await api('signup', {
username: 'test1', username: 'test1',
password: 'test1', password: 'test1',
}); });
@ -63,7 +69,7 @@ describe('Endpoints', () => {
describe('signin', () => { describe('signin', () => {
test('間違ったパスワードでサインインできない', async () => { test('間違ったパスワードでサインインできない', async () => {
const res = await request('api/signin', { const res = await api('signin', {
username: 'test1', username: 'test1',
password: 'bar', password: 'bar',
}); });
@ -72,7 +78,7 @@ describe('Endpoints', () => {
}); });
test('クエリをインジェクションできない', async () => { test('クエリをインジェクションできない', async () => {
const res = await request('api/signin', { const res = await api('signin', {
username: 'test1', username: 'test1',
password: { password: {
$gt: '', $gt: '',
@ -83,7 +89,7 @@ describe('Endpoints', () => {
}); });
test('正しい情報でサインインできる', async () => { test('正しい情報でサインインできる', async () => {
const res = await request('api/signin', { const res = await api('signin', {
username: 'test1', username: 'test1',
password: 'test1', password: 'test1',
}); });
@ -111,11 +117,12 @@ describe('Endpoints', () => {
assert.strictEqual(res.body.birthday, myBirthday); assert.strictEqual(res.body.birthday, myBirthday);
}); });
test('名前を空白にできない', async () => { test('名前を空白にできる', async () => {
const res = await api('/i/update', { const res = await api('/i/update', {
name: ' ', name: ' ',
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 200);
assert.strictEqual(res.body.name, ' ');
}); });
test('誕生日の設定を削除できる', async () => { test('誕生日の設定を削除できる', async () => {
@ -201,7 +208,6 @@ describe('Endpoints', () => {
test('リアクションできる', async () => { test('リアクションできる', async () => {
const bobPost = await post(bob); const bobPost = await post(bob);
const alice = await signup({ username: 'alice' });
const res = await api('/notes/reactions/create', { const res = await api('/notes/reactions/create', {
noteId: bobPost.id, noteId: bobPost.id,
reaction: '🚀', reaction: '🚀',
@ -214,7 +220,7 @@ describe('Endpoints', () => {
}, alice); }, alice);
assert.strictEqual(resNote.status, 200); assert.strictEqual(resNote.status, 200);
assert.strictEqual(resNote.body.reactions['🚀'], [alice.id]); assert.strictEqual(resNote.body.reactions['🚀'], 1);
}); });
test('自分の投稿にもリアクションできる', async () => { test('自分の投稿にもリアクションできる', async () => {
@ -228,7 +234,7 @@ describe('Endpoints', () => {
assert.strictEqual(res.status, 204); assert.strictEqual(res.status, 204);
}); });
test('二重にリアクションできない', async () => { test('二重にリアクションすると上書きされる', async () => {
const bobPost = await post(bob); const bobPost = await post(bob);
await api('/notes/reactions/create', { await api('/notes/reactions/create', {
@ -241,7 +247,14 @@ describe('Endpoints', () => {
reaction: '🚀', reaction: '🚀',
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 204);
const resNote = await api('/notes/show', {
noteId: bobPost.id,
}, alice);
assert.strictEqual(resNote.status, 200);
assert.deepStrictEqual(resNote.body.reactions, { '🚀': 1 });
}); });
test('存在しない投稿にはリアクションできない', async () => { test('存在しない投稿にはリアクションできない', async () => {
@ -369,57 +382,22 @@ describe('Endpoints', () => {
}); });
}); });
/*
describe('/i', () => {
test('', async () => {
});
});
*/
});
/*
process.env.NODE_ENV = 'test';
import * as assert from 'assert';
import * as childProcess from 'child_process';
import { async, signup, request, post, react, uploadFile, startServer, shutdownServer } from './utils.js';
describe('API: Endpoints', () => {
let p: childProcess.ChildProcess;
let alice: any;
let bob: any;
let carol: any;
before(async () => {
p = await startServer();
alice = await signup({ username: 'alice' });
bob = await signup({ username: 'bob' });
carol = await signup({ username: 'carol' });
});
after(async () => {
await shutdownServer(p);
});
describe('drive', () => { describe('drive', () => {
test('ドライブ情報を取得できる', async () => { test('ドライブ情報を取得できる', async () => {
await uploadFile({ await uploadFile(alice, {
userId: alice.id, blob: new Blob([new Uint8Array(256)]),
size: 256
}); });
await uploadFile({ await uploadFile(alice, {
userId: alice.id, blob: new Blob([new Uint8Array(512)]),
size: 512
}); });
await uploadFile({ await uploadFile(alice, {
userId: alice.id, blob: new Blob([new Uint8Array(1024)]),
size: 1024
}); });
const res = await api('/drive', {}, alice); const res = await api('/drive', {}, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
expect(res.body).have.property('usage').eql(1792); expect(res.body).toHaveProperty('usage', 1792);
})); });
}); });
describe('drive/files/create', () => { describe('drive/files/create', () => {
@ -428,397 +406,392 @@ describe('API: Endpoints', () => {
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
assert.strictEqual(res.body.name, 'Lenna.png'); assert.strictEqual(res.body.name, 'Lenna.jpg');
})); });
test('ファイルに名前を付けられる', async () => { test('ファイルに名前を付けられる', async () => {
const res = await assert.request(server) const res = await uploadFile(alice, { name: 'Belmond.png' });
.post('/drive/files/create')
.field('i', alice.token)
.field('name', 'Belmond.png')
.attach('file', fs.readFileSync(__dirname + '/resources/Lenna.png'), 'Lenna.png');
expect(res).have.status(200); assert.strictEqual(res.status, 200);
expect(res.body).be.a('object'); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
expect(res.body).have.property('name').eql('Belmond.png'); assert.strictEqual(res.body.name, 'Belmond.png');
})); });
test('ファイル無しで怒られる', async () => { test('ファイル無しで怒られる', async () => {
const res = await api('/drive/files/create', {}, alice); const res = await api('/drive/files/create', {}, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('SVGファイルを作成できる', async () => { test('SVGファイルを作成できる', async () => {
const res = await uploadFile(alice, __dirname + '/resources/image.svg'); const res = await uploadFile(alice, { path: 'image.svg' });
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
assert.strictEqual(res.body.name, 'image.svg'); assert.strictEqual(res.body.name, 'image.svg');
assert.strictEqual(res.body.type, 'image/svg+xml'); assert.strictEqual(res.body.type, 'image/svg+xml');
})); });
}); });
describe('drive/files/update', () => { describe('drive/files/update', () => {
test('名前を更新できる', async () => { test('名前を更新できる', async () => {
const file = await uploadFile(alice); const file = (await uploadFile(alice)).body;
const newName = 'いちごパスタ.png'; const newName = 'いちごパスタ.png';
const res = await api('/drive/files/update', { const res = await api('/drive/files/update', {
fileId: file.id, fileId: file.id,
name: newName name: newName,
}, alice); }, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
assert.strictEqual(res.body.name, newName); assert.strictEqual(res.body.name, newName);
})); });
test('他人のファイルは更新できない', async () => { test('他人のファイルは更新できない', async () => {
const file = await uploadFile(bob); const file = (await uploadFile(alice)).body;
const res = await api('/drive/files/update', { const res = await api('/drive/files/update', {
fileId: file.id, fileId: file.id,
name: 'いちごパスタ.png' name: 'いちごパスタ.png',
}, alice); }, bob);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('親フォルダを更新できる', async () => { test('親フォルダを更新できる', async () => {
const file = await uploadFile(alice); const file = (await uploadFile(alice)).body;
const folder = (await api('/drive/folders/create', { const folder = (await api('/drive/folders/create', {
name: 'test' name: 'test',
}, alice)).body; }, alice)).body;
const res = await api('/drive/files/update', { const res = await api('/drive/files/update', {
fileId: file.id, fileId: file.id,
folderId: folder.id folderId: folder.id,
}, alice); }, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
assert.strictEqual(res.body.folderId, folder.id); assert.strictEqual(res.body.folderId, folder.id);
})); });
test('親フォルダを無しにできる', async () => { test('親フォルダを無しにできる', async () => {
const file = await uploadFile(alice); const file = (await uploadFile(alice)).body;
const folder = (await api('/drive/folders/create', { const folder = (await api('/drive/folders/create', {
name: 'test' name: 'test',
}, alice)).body; }, alice)).body;
await api('/drive/files/update', { await api('/drive/files/update', {
fileId: file.id, fileId: file.id,
folderId: folder.id folderId: folder.id,
}, alice); }, alice);
const res = await api('/drive/files/update', { const res = await api('/drive/files/update', {
fileId: file.id, fileId: file.id,
folderId: null folderId: null,
}, alice); }, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
assert.strictEqual(res.body.folderId, null); assert.strictEqual(res.body.folderId, null);
})); });
test('他人のフォルダには入れられない', async () => { test('他人のフォルダには入れられない', async () => {
const file = await uploadFile(alice); const file = (await uploadFile(alice)).body;
const folder = (await api('/drive/folders/create', { const folder = (await api('/drive/folders/create', {
name: 'test' name: 'test',
}, bob)).body; }, bob)).body;
const res = await api('/drive/files/update', { const res = await api('/drive/files/update', {
fileId: file.id, fileId: file.id,
folderId: folder.id folderId: folder.id,
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('存在しないフォルダで怒られる', async () => { test('存在しないフォルダで怒られる', async () => {
const file = await uploadFile(alice); const file = (await uploadFile(alice)).body;
const res = await api('/drive/files/update', { const res = await api('/drive/files/update', {
fileId: file.id, fileId: file.id,
folderId: '000000000000000000000000' folderId: '000000000000000000000000',
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('不正なフォルダIDで怒られる', async () => { test('不正なフォルダIDで怒られる', async () => {
const file = await uploadFile(alice); const file = (await uploadFile(alice)).body;
const res = await api('/drive/files/update', { const res = await api('/drive/files/update', {
fileId: file.id, fileId: file.id,
folderId: 'foo' folderId: 'foo',
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('ファイルが存在しなかったら怒る', async () => { test('ファイルが存在しなかったら怒る', async () => {
const res = await api('/drive/files/update', { const res = await api('/drive/files/update', {
fileId: '000000000000000000000000', fileId: '000000000000000000000000',
name: 'いちごパスタ.png' name: 'いちごパスタ.png',
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('間違ったIDで怒られる', async () => { test('間違ったIDで怒られる', async () => {
const res = await api('/drive/files/update', { const res = await api('/drive/files/update', {
fileId: 'kyoppie', fileId: 'kyoppie',
name: 'いちごパスタ.png' name: 'いちごパスタ.png',
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
}); });
describe('drive/folders/create', () => { describe('drive/folders/create', () => {
test('フォルダを作成できる', async () => { test('フォルダを作成できる', async () => {
const res = await api('/drive/folders/create', { const res = await api('/drive/folders/create', {
name: 'test' name: 'test',
}, alice); }, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
assert.strictEqual(res.body.name, 'test'); assert.strictEqual(res.body.name, 'test');
})); });
}); });
describe('drive/folders/update', () => { describe('drive/folders/update', () => {
test('名前を更新できる', async () => { test('名前を更新できる', async () => {
const folder = (await api('/drive/folders/create', { const folder = (await api('/drive/folders/create', {
name: 'test' name: 'test',
}, alice)).body; }, alice)).body;
const res = await api('/drive/folders/update', { const res = await api('/drive/folders/update', {
folderId: folder.id, folderId: folder.id,
name: 'new name' name: 'new name',
}, alice); }, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
assert.strictEqual(res.body.name, 'new name'); assert.strictEqual(res.body.name, 'new name');
})); });
test('他人のフォルダを更新できない', async () => { test('他人のフォルダを更新できない', async () => {
const folder = (await api('/drive/folders/create', { const folder = (await api('/drive/folders/create', {
name: 'test' name: 'test',
}, bob)).body; }, bob)).body;
const res = await api('/drive/folders/update', { const res = await api('/drive/folders/update', {
folderId: folder.id, folderId: folder.id,
name: 'new name' name: 'new name',
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('親フォルダを更新できる', async () => { test('親フォルダを更新できる', async () => {
const folder = (await api('/drive/folders/create', { const folder = (await api('/drive/folders/create', {
name: 'test' name: 'test',
}, alice)).body; }, alice)).body;
const parentFolder = (await api('/drive/folders/create', { const parentFolder = (await api('/drive/folders/create', {
name: 'parent' name: 'parent',
}, alice)).body; }, alice)).body;
const res = await api('/drive/folders/update', { const res = await api('/drive/folders/update', {
folderId: folder.id, folderId: folder.id,
parentId: parentFolder.id parentId: parentFolder.id,
}, alice); }, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
assert.strictEqual(res.body.parentId, parentFolder.id); assert.strictEqual(res.body.parentId, parentFolder.id);
})); });
test('親フォルダを無しに更新できる', async () => { test('親フォルダを無しに更新できる', async () => {
const folder = (await api('/drive/folders/create', { const folder = (await api('/drive/folders/create', {
name: 'test' name: 'test',
}, alice)).body; }, alice)).body;
const parentFolder = (await api('/drive/folders/create', { const parentFolder = (await api('/drive/folders/create', {
name: 'parent' name: 'parent',
}, alice)).body; }, alice)).body;
await api('/drive/folders/update', { await api('/drive/folders/update', {
folderId: folder.id, folderId: folder.id,
parentId: parentFolder.id parentId: parentFolder.id,
}, alice); }, alice);
const res = await api('/drive/folders/update', { const res = await api('/drive/folders/update', {
folderId: folder.id, folderId: folder.id,
parentId: null parentId: null,
}, alice); }, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
assert.strictEqual(res.body.parentId, null); assert.strictEqual(res.body.parentId, null);
})); });
test('他人のフォルダを親フォルダに設定できない', async () => { test('他人のフォルダを親フォルダに設定できない', async () => {
const folder = (await api('/drive/folders/create', { const folder = (await api('/drive/folders/create', {
name: 'test' name: 'test',
}, alice)).body; }, alice)).body;
const parentFolder = (await api('/drive/folders/create', { const parentFolder = (await api('/drive/folders/create', {
name: 'parent' name: 'parent',
}, bob)).body; }, bob)).body;
const res = await api('/drive/folders/update', { const res = await api('/drive/folders/update', {
folderId: folder.id, folderId: folder.id,
parentId: parentFolder.id parentId: parentFolder.id,
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('フォルダが循環するような構造にできない', async () => { test('フォルダが循環するような構造にできない', async () => {
const folder = (await api('/drive/folders/create', { const folder = (await api('/drive/folders/create', {
name: 'test' name: 'test',
}, alice)).body; }, alice)).body;
const parentFolder = (await api('/drive/folders/create', { const parentFolder = (await api('/drive/folders/create', {
name: 'parent' name: 'parent',
}, alice)).body; }, alice)).body;
await api('/drive/folders/update', { await api('/drive/folders/update', {
folderId: parentFolder.id, folderId: parentFolder.id,
parentId: folder.id parentId: folder.id,
}, alice); }, alice);
const res = await api('/drive/folders/update', { const res = await api('/drive/folders/update', {
folderId: folder.id, folderId: folder.id,
parentId: parentFolder.id parentId: parentFolder.id,
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('フォルダが循環するような構造にできない(再帰的)', async () => { test('フォルダが循環するような構造にできない(再帰的)', async () => {
const folderA = (await api('/drive/folders/create', { const folderA = (await api('/drive/folders/create', {
name: 'test' name: 'test',
}, alice)).body; }, alice)).body;
const folderB = (await api('/drive/folders/create', { const folderB = (await api('/drive/folders/create', {
name: 'test' name: 'test',
}, alice)).body; }, alice)).body;
const folderC = (await api('/drive/folders/create', { const folderC = (await api('/drive/folders/create', {
name: 'test' name: 'test',
}, alice)).body; }, alice)).body;
await api('/drive/folders/update', { await api('/drive/folders/update', {
folderId: folderB.id, folderId: folderB.id,
parentId: folderA.id parentId: folderA.id,
}, alice); }, alice);
await api('/drive/folders/update', { await api('/drive/folders/update', {
folderId: folderC.id, folderId: folderC.id,
parentId: folderB.id parentId: folderB.id,
}, alice); }, alice);
const res = await api('/drive/folders/update', { const res = await api('/drive/folders/update', {
folderId: folderA.id, folderId: folderA.id,
parentId: folderC.id parentId: folderC.id,
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('フォルダが循環するような構造にできない(自身)', async () => { test('フォルダが循環するような構造にできない(自身)', async () => {
const folderA = (await api('/drive/folders/create', { const folderA = (await api('/drive/folders/create', {
name: 'test' name: 'test',
}, alice)).body; }, alice)).body;
const res = await api('/drive/folders/update', { const res = await api('/drive/folders/update', {
folderId: folderA.id, folderId: folderA.id,
parentId: folderA.id parentId: folderA.id,
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('存在しない親フォルダを設定できない', async () => { test('存在しない親フォルダを設定できない', async () => {
const folder = (await api('/drive/folders/create', { const folder = (await api('/drive/folders/create', {
name: 'test' name: 'test',
}, alice)).body; }, alice)).body;
const res = await api('/drive/folders/update', { const res = await api('/drive/folders/update', {
folderId: folder.id, folderId: folder.id,
parentId: '000000000000000000000000' parentId: '000000000000000000000000',
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('不正な親フォルダIDで怒られる', async () => { test('不正な親フォルダIDで怒られる', async () => {
const folder = (await api('/drive/folders/create', { const folder = (await api('/drive/folders/create', {
name: 'test' name: 'test',
}, alice)).body; }, alice)).body;
const res = await api('/drive/folders/update', { const res = await api('/drive/folders/update', {
folderId: folder.id, folderId: folder.id,
parentId: 'foo' parentId: 'foo',
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('存在しないフォルダを更新できない', async () => { test('存在しないフォルダを更新できない', async () => {
const res = await api('/drive/folders/update', { const res = await api('/drive/folders/update', {
folderId: '000000000000000000000000' folderId: '000000000000000000000000',
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
test('不正なフォルダIDで怒られる', async () => { test('不正なフォルダIDで怒られる', async () => {
const res = await api('/drive/folders/update', { const res = await api('/drive/folders/update', {
folderId: 'foo' folderId: 'foo',
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
})); });
}); });
describe('notes/replies', () => { describe('notes/replies', () => {
test('自分に閲覧権限のない投稿は含まれない', async () => { test('自分に閲覧権限のない投稿は含まれない', async () => {
const alicePost = await post(alice, { const alicePost = await post(alice, {
text: 'foo' text: 'foo',
}); });
await post(bob, { await post(bob, {
replyId: alicePost.id, replyId: alicePost.id,
text: 'bar', text: 'bar',
visibility: 'specified', visibility: 'specified',
visibleUserIds: [alice.id] visibleUserIds: [alice.id],
}); });
const res = await api('/notes/replies', { const res = await api('/notes/replies', {
noteId: alicePost.id noteId: alicePost.id,
}, carol); }, carol);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(Array.isArray(res.body), true); assert.strictEqual(Array.isArray(res.body), true);
assert.strictEqual(res.body.length, 0); assert.strictEqual(res.body.length, 0);
})); });
}); });
describe('notes/timeline', () => { describe('notes/timeline', () => {
test('フォロワー限定投稿が含まれる', async () => { test('フォロワー限定投稿が含まれる', async () => {
await api('/following/create', { await api('/following/create', {
userId: alice.id userId: carol.id,
}, bob); }, dave);
const alicePost = await post(alice, { const carolPost = await post(carol, {
text: 'foo', text: 'foo',
visibility: 'followers' visibility: 'followers',
}); });
const res = await api('/notes/timeline', {}, bob); const res = await api('/notes/timeline', {}, dave);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(Array.isArray(res.body), true); assert.strictEqual(Array.isArray(res.body), true);
assert.strictEqual(res.body.length, 1); assert.strictEqual(res.body.length, 1);
assert.strictEqual(res.body[0].id, alicePost.id); assert.strictEqual(res.body[0].id, carolPost.id);
})); });
}); });
}); });
*/

42
packages/backend/test/_e2e/fetch-resource.ts → packages/backend/test/e2e/fetch-resource.ts
View File

@ -1,9 +1,8 @@
process.env.NODE_ENV = 'test'; process.env.NODE_ENV = 'test';
import * as assert from 'assert'; import * as assert from 'assert';
import * as childProcess from 'child_process'; import { startServer, signup, post, api, simpleGet } from '../utils.js';
import * as openapi from '@redocly/openapi-core'; import type { INestApplicationContext } from '@nestjs/common';
import { startServer, signup, post, request, simpleGet, port, shutdownServer } from '../utils.js';
// Request Accept // Request Accept
const ONLY_AP = 'application/activity+json'; const ONLY_AP = 'application/activity+json';
@ -13,11 +12,10 @@ const UNSPECIFIED = '*/*';
// Response Content-Type // Response Content-Type
const AP = 'application/activity+json; charset=utf-8'; const AP = 'application/activity+json; charset=utf-8';
const JSON = 'application/json; charset=utf-8';
const HTML = 'text/html; charset=utf-8'; const HTML = 'text/html; charset=utf-8';
describe('Fetch resource', () => { describe('Fetch resource', () => {
let p: childProcess.ChildProcess; let p: INestApplicationContext;
let alice: any; let alice: any;
let alicesPost: any; let alicesPost: any;
@ -28,15 +26,15 @@ describe('Fetch resource', () => {
alicesPost = await post(alice, { alicesPost = await post(alice, {
text: 'test', text: 'test',
}); });
}, 1000 * 30); }, 1000 * 60 * 2);
afterAll(async () => { afterAll(async () => {
await shutdownServer(p); await p.close();
}); });
describe('Common', () => { describe('Common', () => {
test('meta', async () => { test('meta', async () => {
const res = await request('/meta', { const res = await api('/meta', {
}); });
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
@ -54,36 +52,26 @@ describe('Fetch resource', () => {
assert.strictEqual(res.type, HTML); assert.strictEqual(res.type, HTML);
}); });
test('GET api-doc', async () => { test('GET api-doc (廃止)', async () => {
const res = await simpleGet('/api-doc'); const res = await simpleGet('/api-doc');
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 404);
assert.strictEqual(res.type, HTML);
}); });
test('GET api.json', async () => { test('GET api.json (廃止)', async () => {
const res = await simpleGet('/api.json'); const res = await simpleGet('/api.json');
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 404);
assert.strictEqual(res.type, JSON);
}); });
test('Validate api.json', async () => { test('GET api/foo (存在しない)', async () => {
const config = await openapi.loadConfig(); const res = await simpleGet('/api/foo');
const result = await openapi.bundle({ assert.strictEqual(res.status, 404);
config, assert.strictEqual(res.body.error.code, 'UNKNOWN_API_ENDPOINT');
ref: `http://localhost:${port}/api.json`,
});
for (const problem of result.problems) {
console.log(`${problem.message} - ${problem.location[0]?.pointer}`);
}
assert.strictEqual(result.problems.length, 0);
}); });
test('GET favicon.ico', async () => { test('GET favicon.ico', async () => {
const res = await simpleGet('/favicon.ico'); const res = await simpleGet('/favicon.ico');
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(res.type, 'image/x-icon'); assert.strictEqual(res.type, 'image/vnd.microsoft.icon');
}); });
test('GET apple-touch-icon.png', async () => { test('GET apple-touch-icon.png', async () => {

64
packages/backend/test/_e2e/ff-visibility.ts → packages/backend/test/e2e/ff-visibility.ts
View File

@ -1,36 +1,34 @@
process.env.NODE_ENV = 'test'; process.env.NODE_ENV = 'test';
import * as assert from 'assert'; import * as assert from 'assert';
import * as childProcess from 'child_process'; import { signup, api, startServer, simpleGet } from '../utils.js';
import { signup, request, post, react, connectStream, startServer, shutdownServer, simpleGet } from '../utils.js'; import type { INestApplicationContext } from '@nestjs/common';
describe('FF visibility', () => { describe('FF visibility', () => {
let p: childProcess.ChildProcess; let p: INestApplicationContext;
let alice: any; let alice: any;
let bob: any; let bob: any;
let carol: any;
beforeAll(async () => { beforeAll(async () => {
p = await startServer(); p = await startServer();
alice = await signup({ username: 'alice' }); alice = await signup({ username: 'alice' });
bob = await signup({ username: 'bob' }); bob = await signup({ username: 'bob' });
carol = await signup({ username: 'carol' }); }, 1000 * 60 * 2);
}, 1000 * 30);
afterAll(async () => { afterAll(async () => {
await shutdownServer(p); await p.close();
}); });
test('ffVisibility が public なユーザーのフォロー/フォロワーを誰でも見れる', async () => { test('ffVisibility が public なユーザーのフォロー/フォロワーを誰でも見れる', async () => {
await request('/i/update', { await api('/i/update', {
ffVisibility: 'public', ffVisibility: 'public',
}, alice); }, alice);
const followingRes = await request('/users/following', { const followingRes = await api('/users/following', {
userId: alice.id, userId: alice.id,
}, bob); }, bob);
const followersRes = await request('/users/followers', { const followersRes = await api('/users/followers', {
userId: alice.id, userId: alice.id,
}, bob); }, bob);
@ -41,14 +39,14 @@ describe('FF visibility', () => {
}); });
test('ffVisibility が followers なユーザーのフォロー/フォロワーを自分で見れる', async () => { test('ffVisibility が followers なユーザーのフォロー/フォロワーを自分で見れる', async () => {
await request('/i/update', { await api('/i/update', {
ffVisibility: 'followers', ffVisibility: 'followers',
}, alice); }, alice);
const followingRes = await request('/users/following', { const followingRes = await api('/users/following', {
userId: alice.id, userId: alice.id,
}, alice); }, alice);
const followersRes = await request('/users/followers', { const followersRes = await api('/users/followers', {
userId: alice.id, userId: alice.id,
}, alice); }, alice);
@ -59,14 +57,14 @@ describe('FF visibility', () => {
}); });
test('ffVisibility が followers なユーザーのフォロー/フォロワーを非フォロワーが見れない', async () => { test('ffVisibility が followers なユーザーのフォロー/フォロワーを非フォロワーが見れない', async () => {
await request('/i/update', { await api('/i/update', {
ffVisibility: 'followers', ffVisibility: 'followers',
}, alice); }, alice);
const followingRes = await request('/users/following', { const followingRes = await api('/users/following', {
userId: alice.id, userId: alice.id,
}, bob); }, bob);
const followersRes = await request('/users/followers', { const followersRes = await api('/users/followers', {
userId: alice.id, userId: alice.id,
}, bob); }, bob);
@ -75,18 +73,18 @@ describe('FF visibility', () => {
}); });
test('ffVisibility が followers なユーザーのフォロー/フォロワーをフォロワーが見れる', async () => { test('ffVisibility が followers なユーザーのフォロー/フォロワーをフォロワーが見れる', async () => {
await request('/i/update', { await api('/i/update', {
ffVisibility: 'followers', ffVisibility: 'followers',
}, alice); }, alice);
await request('/following/create', { await api('/following/create', {
userId: alice.id, userId: alice.id,
}, bob); }, bob);
const followingRes = await request('/users/following', { const followingRes = await api('/users/following', {
userId: alice.id, userId: alice.id,
}, bob); }, bob);
const followersRes = await request('/users/followers', { const followersRes = await api('/users/followers', {
userId: alice.id, userId: alice.id,
}, bob); }, bob);
@ -97,14 +95,14 @@ describe('FF visibility', () => {
}); });
test('ffVisibility が private なユーザーのフォロー/フォロワーを自分で見れる', async () => { test('ffVisibility が private なユーザーのフォロー/フォロワーを自分で見れる', async () => {
await request('/i/update', { await api('/i/update', {
ffVisibility: 'private', ffVisibility: 'private',
}, alice); }, alice);
const followingRes = await request('/users/following', { const followingRes = await api('/users/following', {
userId: alice.id, userId: alice.id,
}, alice); }, alice);
const followersRes = await request('/users/followers', { const followersRes = await api('/users/followers', {
userId: alice.id, userId: alice.id,
}, alice); }, alice);
@ -115,14 +113,14 @@ describe('FF visibility', () => {
}); });
test('ffVisibility が private なユーザーのフォロー/フォロワーを他人が見れない', async () => { test('ffVisibility が private なユーザーのフォロー/フォロワーを他人が見れない', async () => {
await request('/i/update', { await api('/i/update', {
ffVisibility: 'private', ffVisibility: 'private',
}, alice); }, alice);
const followingRes = await request('/users/following', { const followingRes = await api('/users/following', {
userId: alice.id, userId: alice.id,
}, bob); }, bob);
const followersRes = await request('/users/followers', { const followersRes = await api('/users/followers', {
userId: alice.id, userId: alice.id,
}, bob); }, bob);
@ -133,7 +131,7 @@ describe('FF visibility', () => {
describe('AP', () => { describe('AP', () => {
test('ffVisibility が public 以外ならばAPからは取得できない', async () => { test('ffVisibility が public 以外ならばAPからは取得できない', async () => {
{ {
await request('/i/update', { await api('/i/update', {
ffVisibility: 'public', ffVisibility: 'public',
}, alice); }, alice);
@ -143,22 +141,22 @@ describe('FF visibility', () => {
assert.strictEqual(followersRes.status, 200); assert.strictEqual(followersRes.status, 200);
} }
{ {
await request('/i/update', { await api('/i/update', {
ffVisibility: 'followers', ffVisibility: 'followers',
}, alice); }, alice);
const followingRes = await simpleGet(`/users/${alice.id}/following`, 'application/activity+json').catch(res => ({ status: res.statusCode })); const followingRes = await simpleGet(`/users/${alice.id}/following`, 'application/activity+json');
const followersRes = await simpleGet(`/users/${alice.id}/followers`, 'application/activity+json').catch(res => ({ status: res.statusCode })); const followersRes = await simpleGet(`/users/${alice.id}/followers`, 'application/activity+json');
assert.strictEqual(followingRes.status, 403); assert.strictEqual(followingRes.status, 403);
assert.strictEqual(followersRes.status, 403); assert.strictEqual(followersRes.status, 403);
} }
{ {
await request('/i/update', { await api('/i/update', {
ffVisibility: 'private', ffVisibility: 'private',
}, alice); }, alice);
const followingRes = await simpleGet(`/users/${alice.id}/following`, 'application/activity+json').catch(res => ({ status: res.statusCode })); const followingRes = await simpleGet(`/users/${alice.id}/following`, 'application/activity+json');
const followersRes = await simpleGet(`/users/${alice.id}/followers`, 'application/activity+json').catch(res => ({ status: res.statusCode })); const followersRes = await simpleGet(`/users/${alice.id}/followers`, 'application/activity+json');
assert.strictEqual(followingRes.status, 403); assert.strictEqual(followingRes.status, 403);
assert.strictEqual(followersRes.status, 403); assert.strictEqual(followersRes.status, 403);
} }

30
packages/backend/test/_e2e/mute.ts → packages/backend/test/e2e/mute.ts
View File

@ -1,11 +1,11 @@
process.env.NODE_ENV = 'test'; process.env.NODE_ENV = 'test';
import * as assert from 'assert'; import * as assert from 'assert';
import * as childProcess from 'child_process'; import { signup, api, post, react, startServer, waitFire } from '../utils.js';
import { signup, request, post, react, startServer, shutdownServer, waitFire } from '../utils.js'; import type { INestApplicationContext } from '@nestjs/common';
describe('Mute', () => { describe('Mute', () => {
let p: childProcess.ChildProcess; let p: INestApplicationContext;
// alice mutes carol // alice mutes carol
let alice: any; let alice: any;
@ -17,14 +17,14 @@ describe('Mute', () => {
alice = await signup({ username: 'alice' }); alice = await signup({ username: 'alice' });
bob = await signup({ username: 'bob' }); bob = await signup({ username: 'bob' });
carol = await signup({ username: 'carol' }); carol = await signup({ username: 'carol' });
}, 1000 * 30); }, 1000 * 60 * 2);
afterAll(async () => { afterAll(async () => {
await shutdownServer(p); await p.close();
}); });
test('ミュート作成', async () => { test('ミュート作成', async () => {
const res = await request('/mute/create', { const res = await api('/mute/create', {
userId: carol.id, userId: carol.id,
}, alice); }, alice);
@ -35,7 +35,7 @@ describe('Mute', () => {
const bobNote = await post(bob, { text: '@alice hi' }); const bobNote = await post(bob, { text: '@alice hi' });
const carolNote = await post(carol, { text: '@alice hi' }); const carolNote = await post(carol, { text: '@alice hi' });
const res = await request('/notes/mentions', {}, alice); const res = await api('/notes/mentions', {}, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(Array.isArray(res.body), true); assert.strictEqual(Array.isArray(res.body), true);
@ -45,11 +45,11 @@ describe('Mute', () => {
test('ミュートしているユーザーからメンションされても、hasUnreadMentions が true にならない', async () => { test('ミュートしているユーザーからメンションされても、hasUnreadMentions が true にならない', async () => {
// 状態リセット // 状態リセット
await request('/i/read-all-unread-notes', {}, alice); await api('/i/read-all-unread-notes', {}, alice);
await post(carol, { text: '@alice hi' }); await post(carol, { text: '@alice hi' });
const res = await request('/i', {}, alice); const res = await api('/i', {}, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(res.body.hasUnreadMentions, false); assert.strictEqual(res.body.hasUnreadMentions, false);
@ -57,7 +57,7 @@ describe('Mute', () => {
test('ミュートしているユーザーからメンションされても、ストリームに unreadMention イベントが流れてこない', async () => { test('ミュートしているユーザーからメンションされても、ストリームに unreadMention イベントが流れてこない', async () => {
// 状態リセット // 状態リセット
await request('/i/read-all-unread-notes', {}, alice); await api('/i/read-all-unread-notes', {}, alice);
const fired = await waitFire(alice, 'main', () => post(carol, { text: '@alice hi' }), msg => msg.type === 'unreadMention'); const fired = await waitFire(alice, 'main', () => post(carol, { text: '@alice hi' }), msg => msg.type === 'unreadMention');
@ -66,8 +66,8 @@ describe('Mute', () => {
test('ミュートしているユーザーからメンションされても、ストリームに unreadNotification イベントが流れてこない', async () => { test('ミュートしているユーザーからメンションされても、ストリームに unreadNotification イベントが流れてこない', async () => {
// 状態リセット // 状態リセット
await request('/i/read-all-unread-notes', {}, alice); await api('/i/read-all-unread-notes', {}, alice);
await request('/notifications/mark-all-as-read', {}, alice); await api('/notifications/mark-all-as-read', {}, alice);
const fired = await waitFire(alice, 'main', () => post(carol, { text: '@alice hi' }), msg => msg.type === 'unreadNotification'); const fired = await waitFire(alice, 'main', () => post(carol, { text: '@alice hi' }), msg => msg.type === 'unreadNotification');
@ -80,7 +80,7 @@ describe('Mute', () => {
const bobNote = await post(bob); const bobNote = await post(bob);
const carolNote = await post(carol); const carolNote = await post(carol);
const res = await request('/notes/local-timeline', {}, alice); const res = await api('/notes/local-timeline', {}, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(Array.isArray(res.body), true); assert.strictEqual(Array.isArray(res.body), true);
@ -96,7 +96,7 @@ describe('Mute', () => {
renoteId: carolNote.id, renoteId: carolNote.id,
}); });
const res = await request('/notes/local-timeline', {}, alice); const res = await api('/notes/local-timeline', {}, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(Array.isArray(res.body), true); assert.strictEqual(Array.isArray(res.body), true);
@ -112,7 +112,7 @@ describe('Mute', () => {
await react(bob, aliceNote, 'like'); await react(bob, aliceNote, 'like');
await react(carol, aliceNote, 'like'); await react(carol, aliceNote, 'like');
const res = await request('/i/notifications', {}, alice); const res = await api('/i/notifications', {}, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(Array.isArray(res.body), true); assert.strictEqual(Array.isArray(res.body), true);

98
packages/backend/test/_e2e/note.ts → packages/backend/test/e2e/note.ts
View File

@ -1,12 +1,12 @@
process.env.NODE_ENV = 'test'; process.env.NODE_ENV = 'test';
import * as assert from 'assert'; import * as assert from 'assert';
import * as childProcess from 'child_process'; import { Note } from '@/models/entities/Note.js';
import { Note } from '../../src/models/entities/note.js'; import { signup, post, uploadUrl, startServer, initTestDb, api } from '../utils.js';
import { async, signup, request, post, uploadUrl, startServer, shutdownServer, initTestDb, api } from '../utils.js'; import type { INestApplicationContext } from '@nestjs/common';
describe('Note', () => { describe('Note', () => {
let p: childProcess.ChildProcess; let p: INestApplicationContext;
let Notes: any; let Notes: any;
let alice: any; let alice: any;
@ -18,10 +18,10 @@ describe('Note', () => {
Notes = connection.getRepository(Note); Notes = connection.getRepository(Note);
alice = await signup({ username: 'alice' }); alice = await signup({ username: 'alice' });
bob = await signup({ username: 'bob' }); bob = await signup({ username: 'bob' });
}, 1000 * 30); }, 1000 * 60 * 2);
afterAll(async () => { afterAll(async () => {
await shutdownServer(p); await p.close();
}); });
test('投稿できる', async () => { test('投稿できる', async () => {
@ -29,7 +29,7 @@ describe('Note', () => {
text: 'test', text: 'test',
}; };
const res = await request('/notes/create', post, alice); const res = await api('/notes/create', post, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
@ -39,7 +39,7 @@ describe('Note', () => {
test('ファイルを添付できる', async () => { test('ファイルを添付できる', async () => {
const file = await uploadUrl(alice, 'https://raw.githubusercontent.com/misskey-dev/misskey/develop/packages/backend/test/resources/Lenna.jpg'); const file = await uploadUrl(alice, 'https://raw.githubusercontent.com/misskey-dev/misskey/develop/packages/backend/test/resources/Lenna.jpg');
const res = await request('/notes/create', { const res = await api('/notes/create', {
fileIds: [file.id], fileIds: [file.id],
}, alice); }, alice);
@ -48,37 +48,37 @@ describe('Note', () => {
assert.deepStrictEqual(res.body.createdNote.fileIds, [file.id]); assert.deepStrictEqual(res.body.createdNote.fileIds, [file.id]);
}, 1000 * 10); }, 1000 * 10);
test('他人のファイルは無視', async () => { test('他人のファイルで怒られる', async () => {
const file = await uploadUrl(bob, 'https://raw.githubusercontent.com/misskey-dev/misskey/develop/packages/backend/test/resources/Lenna.jpg'); const file = await uploadUrl(bob, 'https://raw.githubusercontent.com/misskey-dev/misskey/develop/packages/backend/test/resources/Lenna.jpg');
const res = await request('/notes/create', { const res = await api('/notes/create', {
text: 'test', text: 'test',
fileIds: [file.id], fileIds: [file.id],
}, alice); }, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 400);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(res.body.error.code, 'NO_SUCH_FILE');
assert.deepStrictEqual(res.body.createdNote.fileIds, []); assert.strictEqual(res.body.error.id, 'b6992544-63e7-67f0-fa7f-32444b1b5306');
}, 1000 * 10); }, 1000 * 10);
test('存在しないファイルは無視', async () => { test('存在しないファイルで怒られる', async () => {
const res = await request('/notes/create', { const res = await api('/notes/create', {
text: 'test', text: 'test',
fileIds: ['000000000000000000000000'], fileIds: ['000000000000000000000000'],
}, alice); }, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 400);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(res.body.error.code, 'NO_SUCH_FILE');
assert.deepStrictEqual(res.body.createdNote.fileIds, []); assert.strictEqual(res.body.error.id, 'b6992544-63e7-67f0-fa7f-32444b1b5306');
}); });
test('不正なファイルIDは無視', async () => { test('不正なファイルIDで怒られる', async () => {
const res = await request('/notes/create', { const res = await api('/notes/create', {
fileIds: ['kyoppie'], fileIds: ['kyoppie'],
}, alice); }, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 400);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(res.body.error.code, 'NO_SUCH_FILE');
assert.deepStrictEqual(res.body.createdNote.fileIds, []); assert.strictEqual(res.body.error.id, 'b6992544-63e7-67f0-fa7f-32444b1b5306');
}); });
test('返信できる', async () => { test('返信できる', async () => {
@ -91,7 +91,7 @@ describe('Note', () => {
replyId: bobPost.id, replyId: bobPost.id,
}; };
const res = await request('/notes/create', alicePost, alice); const res = await api('/notes/create', alicePost, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
@ -109,7 +109,7 @@ describe('Note', () => {
renoteId: bobPost.id, renoteId: bobPost.id,
}; };
const res = await request('/notes/create', alicePost, alice); const res = await api('/notes/create', alicePost, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
@ -127,7 +127,7 @@ describe('Note', () => {
renoteId: bobPost.id, renoteId: bobPost.id,
}; };
const res = await request('/notes/create', alicePost, alice); const res = await api('/notes/create', alicePost, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
@ -140,7 +140,7 @@ describe('Note', () => {
const post = { const post = {
text: '!'.repeat(3000), text: '!'.repeat(3000),
}; };
const res = await request('/notes/create', post, alice); const res = await api('/notes/create', post, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
}); });
@ -148,7 +148,7 @@ describe('Note', () => {
const post = { const post = {
text: '!'.repeat(3001), text: '!'.repeat(3001),
}; };
const res = await request('/notes/create', post, alice); const res = await api('/notes/create', post, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
}); });
@ -157,7 +157,7 @@ describe('Note', () => {
text: 'test', text: 'test',
replyId: '000000000000000000000000', replyId: '000000000000000000000000',
}; };
const res = await request('/notes/create', post, alice); const res = await api('/notes/create', post, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
}); });
@ -165,7 +165,7 @@ describe('Note', () => {
const post = { const post = {
renoteId: '000000000000000000000000', renoteId: '000000000000000000000000',
}; };
const res = await request('/notes/create', post, alice); const res = await api('/notes/create', post, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
}); });
@ -174,7 +174,7 @@ describe('Note', () => {
text: 'test', text: 'test',
replyId: 'foo', replyId: 'foo',
}; };
const res = await request('/notes/create', post, alice); const res = await api('/notes/create', post, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
}); });
@ -182,7 +182,7 @@ describe('Note', () => {
const post = { const post = {
renoteId: 'foo', renoteId: 'foo',
}; };
const res = await request('/notes/create', post, alice); const res = await api('/notes/create', post, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
}); });
@ -191,7 +191,7 @@ describe('Note', () => {
text: '@ghost yo', text: '@ghost yo',
}; };
const res = await request('/notes/create', post, alice); const res = await api('/notes/create', post, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
@ -203,7 +203,7 @@ describe('Note', () => {
text: '@bob @bob @bob yo', text: '@bob @bob @bob yo',
}; };
const res = await request('/notes/create', post, alice); const res = await api('/notes/create', post, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true); assert.strictEqual(typeof res.body === 'object' && !Array.isArray(res.body), true);
@ -215,7 +215,7 @@ describe('Note', () => {
describe('notes/create', () => { describe('notes/create', () => {
test('投票を添付できる', async () => { test('投票を添付できる', async () => {
const res = await request('/notes/create', { const res = await api('/notes/create', {
text: 'test', text: 'test',
poll: { poll: {
choices: ['foo', 'bar'], choices: ['foo', 'bar'],
@ -228,14 +228,14 @@ describe('Note', () => {
}); });
test('投票の選択肢が無くて怒られる', async () => { test('投票の選択肢が無くて怒られる', async () => {
const res = await request('/notes/create', { const res = await api('/notes/create', {
poll: {}, poll: {},
}, alice); }, alice);
assert.strictEqual(res.status, 400); assert.strictEqual(res.status, 400);
}); });
test('投票の選択肢が無くて怒られる (空の配列)', async () => { test('投票の選択肢が無くて怒られる (空の配列)', async () => {
const res = await request('/notes/create', { const res = await api('/notes/create', {
poll: { poll: {
choices: [], choices: [],
}, },
@ -244,7 +244,7 @@ describe('Note', () => {
}); });
test('投票の選択肢が1つで怒られる', async () => { test('投票の選択肢が1つで怒られる', async () => {
const res = await request('/notes/create', { const res = await api('/notes/create', {
poll: { poll: {
choices: ['Strawberry Pasta'], choices: ['Strawberry Pasta'],
}, },
@ -253,14 +253,14 @@ describe('Note', () => {
}); });
test('投票できる', async () => { test('投票できる', async () => {
const { body } = await request('/notes/create', { const { body } = await api('/notes/create', {
text: 'test', text: 'test',
poll: { poll: {
choices: ['sakura', 'izumi', 'ako'], choices: ['sakura', 'izumi', 'ako'],
}, },
}, alice); }, alice);
const res = await request('/notes/polls/vote', { const res = await api('/notes/polls/vote', {
noteId: body.createdNote.id, noteId: body.createdNote.id,
choice: 1, choice: 1,
}, alice); }, alice);
@ -269,19 +269,19 @@ describe('Note', () => {
}); });
test('複数投票できない', async () => { test('複数投票できない', async () => {
const { body } = await request('/notes/create', { const { body } = await api('/notes/create', {
text: 'test', text: 'test',
poll: { poll: {
choices: ['sakura', 'izumi', 'ako'], choices: ['sakura', 'izumi', 'ako'],
}, },
}, alice); }, alice);
await request('/notes/polls/vote', { await api('/notes/polls/vote', {
noteId: body.createdNote.id, noteId: body.createdNote.id,
choice: 0, choice: 0,
}, alice); }, alice);
const res = await request('/notes/polls/vote', { const res = await api('/notes/polls/vote', {
noteId: body.createdNote.id, noteId: body.createdNote.id,
choice: 2, choice: 2,
}, alice); }, alice);
@ -290,7 +290,7 @@ describe('Note', () => {
}); });
test('許可されている場合は複数投票できる', async () => { test('許可されている場合は複数投票できる', async () => {
const { body } = await request('/notes/create', { const { body } = await api('/notes/create', {
text: 'test', text: 'test',
poll: { poll: {
choices: ['sakura', 'izumi', 'ako'], choices: ['sakura', 'izumi', 'ako'],
@ -298,17 +298,17 @@ describe('Note', () => {
}, },
}, alice); }, alice);
await request('/notes/polls/vote', { await api('/notes/polls/vote', {
noteId: body.createdNote.id, noteId: body.createdNote.id,
choice: 0, choice: 0,
}, alice); }, alice);
await request('/notes/polls/vote', { await api('/notes/polls/vote', {
noteId: body.createdNote.id, noteId: body.createdNote.id,
choice: 1, choice: 1,
}, alice); }, alice);
const res = await request('/notes/polls/vote', { const res = await api('/notes/polls/vote', {
noteId: body.createdNote.id, noteId: body.createdNote.id,
choice: 2, choice: 2,
}, alice); }, alice);
@ -317,7 +317,7 @@ describe('Note', () => {
}); });
test('締め切られている場合は投票できない', async () => { test('締め切られている場合は投票できない', async () => {
const { body } = await request('/notes/create', { const { body } = await api('/notes/create', {
text: 'test', text: 'test',
poll: { poll: {
choices: ['sakura', 'izumi', 'ako'], choices: ['sakura', 'izumi', 'ako'],
@ -327,7 +327,7 @@ describe('Note', () => {
await new Promise(x => setTimeout(x, 2)); await new Promise(x => setTimeout(x, 2));
const res = await request('/notes/polls/vote', { const res = await api('/notes/polls/vote', {
noteId: body.createdNote.id, noteId: body.createdNote.id,
choice: 1, choice: 1,
}, alice); }, alice);

88
packages/backend/test/_e2e/streaming.ts → packages/backend/test/e2e/streaming.ts
View File

@ -1,12 +1,12 @@
process.env.NODE_ENV = 'test'; process.env.NODE_ENV = 'test';
import * as assert from 'assert'; import * as assert from 'assert';
import * as childProcess from 'child_process'; import { Following } from '@/models/entities/Following.js';
import { Following } from '../../src/models/entities/following.js'; import { connectStream, signup, api, post, startServer, initTestDb, waitFire } from '../utils.js';
import { connectStream, signup, api, post, startServer, shutdownServer, initTestDb, waitFire } from '../utils.js'; import type { INestApplicationContext } from '@nestjs/common';
describe('Streaming', () => { describe('Streaming', () => {
let p: childProcess.ChildProcess; let p: INestApplicationContext;
let Followings: any; let Followings: any;
const follow = async (follower: any, followee: any) => { const follow = async (follower: any, followee: any) => {
@ -71,10 +71,10 @@ describe('Streaming', () => {
listId: list.id, listId: list.id,
userId: kyoko.id, userId: kyoko.id,
}, chitose); }, chitose);
}, 1000 * 30); }, 1000 * 60 * 2);
afterAll(async () => { afterAll(async () => {
await shutdownServer(p); await p.close();
}); });
describe('Events', () => { describe('Events', () => {
@ -404,43 +404,45 @@ describe('Streaming', () => {
}); });
})); }));
test('指定したハッシュタグの投稿が流れる (AND)', () => new Promise<void>(async done => { // XXX: QueryFailedError: duplicate key value violates unique constraint "IDX_347fec870eafea7b26c8a73bac"
let fooCount = 0;
let barCount = 0; // test('指定したハッシュタグの投稿が流れる (AND)', () => new Promise<void>(async done => {
let fooBarCount = 0; // let fooCount = 0;
// let barCount = 0;
const ws = await connectStream(chitose, 'hashtag', ({ type, body }) => { // let fooBarCount = 0;
if (type === 'note') {
if (body.text === '#foo') fooCount++; // const ws = await connectStream(chitose, 'hashtag', ({ type, body }) => {
if (body.text === '#bar') barCount++; // if (type === 'note') {
if (body.text === '#foo #bar') fooBarCount++; // if (body.text === '#foo') fooCount++;
} // if (body.text === '#bar') barCount++;
}, { // if (body.text === '#foo #bar') fooBarCount++;
q: [ // }
['foo', 'bar'], // }, {
], // q: [
}); // ['foo', 'bar'],
// ],
post(chitose, { // });
text: '#foo',
}); // post(chitose, {
// text: '#foo',
post(chitose, { // });
text: '#bar',
}); // post(chitose, {
// text: '#bar',
post(chitose, { // });
text: '#foo #bar',
}); // post(chitose, {
// text: '#foo #bar',
setTimeout(() => { // });
assert.strictEqual(fooCount, 0);
assert.strictEqual(barCount, 0); // setTimeout(() => {
assert.strictEqual(fooBarCount, 1); // assert.strictEqual(fooCount, 0);
ws.close(); // assert.strictEqual(barCount, 0);
done(); // assert.strictEqual(fooBarCount, 1);
}, 3000); // ws.close();
})); // done();
// }, 3000);
// }));
test('指定したハッシュタグの投稿が流れる (OR)', () => new Promise<void>(async done => { test('指定したハッシュタグの投稿が流れる (OR)', () => new Promise<void>(async done => {
let fooCount = 0; let fooCount = 0;

30
packages/backend/test/_e2e/thread-mute.ts → packages/backend/test/e2e/thread-mute.ts
View File

@ -1,11 +1,11 @@
process.env.NODE_ENV = 'test'; process.env.NODE_ENV = 'test';
import * as assert from 'assert'; import * as assert from 'assert';
import * as childProcess from 'child_process'; import { signup, api, post, connectStream, startServer } from '../utils.js';
import { signup, request, post, react, connectStream, startServer, shutdownServer } from '../utils.js'; import type { INestApplicationContext } from '@nestjs/common';
describe('Note thread mute', () => { describe('Note thread mute', () => {
let p: childProcess.ChildProcess; let p: INestApplicationContext;
let alice: any; let alice: any;
let bob: any; let bob: any;
@ -16,22 +16,22 @@ describe('Note thread mute', () => {
alice = await signup({ username: 'alice' }); alice = await signup({ username: 'alice' });
bob = await signup({ username: 'bob' }); bob = await signup({ username: 'bob' });
carol = await signup({ username: 'carol' }); carol = await signup({ username: 'carol' });
}, 1000 * 30); }, 1000 * 60 * 2);
afterAll(async () => { afterAll(async () => {
await shutdownServer(p); await p.close();
}); });
test('notes/mentions にミュートしているスレッドの投稿が含まれない', async () => { test('notes/mentions にミュートしているスレッドの投稿が含まれない', async () => {
const bobNote = await post(bob, { text: '@alice @carol root note' }); const bobNote = await post(bob, { text: '@alice @carol root note' });
const aliceReply = await post(alice, { replyId: bobNote.id, text: '@bob @carol child note' }); const aliceReply = await post(alice, { replyId: bobNote.id, text: '@bob @carol child note' });
await request('/notes/thread-muting/create', { noteId: bobNote.id }, alice); await api('/notes/thread-muting/create', { noteId: bobNote.id }, alice);
const carolReply = await post(carol, { replyId: bobNote.id, text: '@bob @alice child note' }); const carolReply = await post(carol, { replyId: bobNote.id, text: '@bob @alice child note' });
const carolReplyWithoutMention = await post(carol, { replyId: aliceReply.id, text: 'child note' }); const carolReplyWithoutMention = await post(carol, { replyId: aliceReply.id, text: 'child note' });
const res = await request('/notes/mentions', {}, alice); const res = await api('/notes/mentions', {}, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(Array.isArray(res.body), true); assert.strictEqual(Array.isArray(res.body), true);
@ -42,27 +42,27 @@ describe('Note thread mute', () => {
test('ミュートしているスレッドからメンションされても、hasUnreadMentions が true にならない', async () => { test('ミュートしているスレッドからメンションされても、hasUnreadMentions が true にならない', async () => {
// 状態リセット // 状態リセット
await request('/i/read-all-unread-notes', {}, alice); await api('/i/read-all-unread-notes', {}, alice);
const bobNote = await post(bob, { text: '@alice @carol root note' }); const bobNote = await post(bob, { text: '@alice @carol root note' });
await request('/notes/thread-muting/create', { noteId: bobNote.id }, alice); await api('/notes/thread-muting/create', { noteId: bobNote.id }, alice);
const carolReply = await post(carol, { replyId: bobNote.id, text: '@bob @alice child note' }); const carolReply = await post(carol, { replyId: bobNote.id, text: '@bob @alice child note' });
const res = await request('/i', {}, alice); const res = await api('/i', {}, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(res.body.hasUnreadMentions, false); assert.strictEqual(res.body.hasUnreadMentions, false);
}); });
test('ミュートしているスレッドからメンションされても、ストリームに unreadMention イベントが流れてこない', () => new Promise(async done => { test('ミュートしているスレッドからメンションされても、ストリームに unreadMention イベントが流れてこない', () => new Promise<void>(async done => {
// 状態リセット // 状態リセット
await request('/i/read-all-unread-notes', {}, alice); await api('/i/read-all-unread-notes', {}, alice);
const bobNote = await post(bob, { text: '@alice @carol root note' }); const bobNote = await post(bob, { text: '@alice @carol root note' });
await request('/notes/thread-muting/create', { noteId: bobNote.id }, alice); await api('/notes/thread-muting/create', { noteId: bobNote.id }, alice);
let fired = false; let fired = false;
@ -86,12 +86,12 @@ describe('Note thread mute', () => {
const bobNote = await post(bob, { text: '@alice @carol root note' }); const bobNote = await post(bob, { text: '@alice @carol root note' });
const aliceReply = await post(alice, { replyId: bobNote.id, text: '@bob @carol child note' }); const aliceReply = await post(alice, { replyId: bobNote.id, text: '@bob @carol child note' });
await request('/notes/thread-muting/create', { noteId: bobNote.id }, alice); await api('/notes/thread-muting/create', { noteId: bobNote.id }, alice);
const carolReply = await post(carol, { replyId: bobNote.id, text: '@bob @alice child note' }); const carolReply = await post(carol, { replyId: bobNote.id, text: '@bob @alice child note' });
const carolReplyWithoutMention = await post(carol, { replyId: aliceReply.id, text: 'child note' }); const carolReplyWithoutMention = await post(carol, { replyId: aliceReply.id, text: 'child note' });
const res = await request('/i/notifications', {}, alice); const res = await api('/i/notifications', {}, alice);
assert.strictEqual(res.status, 200); assert.strictEqual(res.status, 200);
assert.strictEqual(Array.isArray(res.body), true); assert.strictEqual(Array.isArray(res.body), true);

14
packages/backend/test/_e2e/user-notes.ts → packages/backend/test/e2e/user-notes.ts
View File

@ -1,11 +1,11 @@
process.env.NODE_ENV = 'test'; process.env.NODE_ENV = 'test';
import * as assert from 'assert'; import * as assert from 'assert';
import * as childProcess from 'child_process'; import { signup, api, post, uploadUrl, startServer } from '../utils.js';
import { signup, request, post, uploadUrl, startServer, shutdownServer } from '../utils.js'; import type { INestApplicationContext } from '@nestjs/common';
describe('users/notes', () => { describe('users/notes', () => {
let p: childProcess.ChildProcess; let p: INestApplicationContext;
let alice: any; let alice: any;
let jpgNote: any; let jpgNote: any;
@ -26,14 +26,14 @@ describe('users/notes', () => {
jpgPngNote = await post(alice, { jpgPngNote = await post(alice, {
fileIds: [jpg.id, png.id], fileIds: [jpg.id, png.id],
}); });
}, 1000 * 30); }, 1000 * 60 * 2);
afterAll(async() => { afterAll(async() => {
await shutdownServer(p); await p.close();
}); });
test('ファイルタイプ指定 (jpg)', async () => { test('ファイルタイプ指定 (jpg)', async () => {
const res = await request('/users/notes', { const res = await api('/users/notes', {
userId: alice.id, userId: alice.id,
fileType: ['image/jpeg'], fileType: ['image/jpeg'],
}, alice); }, alice);
@ -46,7 +46,7 @@ describe('users/notes', () => {
}); });
test('ファイルタイプ指定 (jpg or png)', async () => { test('ファイルタイプ指定 (jpg or png)', async () => {
const res = await request('/users/notes', { const res = await api('/users/notes', {
userId: alice.id, userId: alice.id,
fileType: ['image/jpeg', 'image/png'], fileType: ['image/jpeg', 'image/png'],
}, alice); }, alice);

240
packages/backend/test/utils.ts
View File

@ -1,3 +1,243 @@
import { readFile } from 'node:fs/promises';
import { isAbsolute, basename } from 'node:path';
import WebSocket from 'ws';
import fetch, { Blob, File, RequestInit } from 'node-fetch';
import { DataSource } from 'typeorm';
import { entities } from '../src/postgres.js';
import { loadConfig } from '../src/config.js';
import type * as misskey from 'misskey-js';
export { server as startServer } from '@/boot/common.js';
const config = loadConfig();
export const port = config.port;
export const api = async (endpoint: string, params: any, me?: any) => {
const normalized = endpoint.replace(/^\//, '');
return await request(`api/${normalized}`, params, me);
};
const request = async (path: string, params: any, me?: any): Promise<{ body: any, status: number }> => {
const auth = me ? {
i: me.token,
} : {};
const res = await relativeFetch(path, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify(Object.assign(auth, params)),
redirect: 'manual',
});
const status = res.status;
const body = res.headers.get('content-type') === 'application/json; charset=utf-8'
? await res.json()
: null;
return {
body, status,
};
};
const relativeFetch = async (path: string, init?: RequestInit | undefined) => {
return await fetch(new URL(path, `http://127.0.0.1:${port}/`).toString(), init);
};
export const signup = async (params?: any): Promise<any> => {
const q = Object.assign({
username: 'test',
password: 'test',
}, params);
const res = await api('signup', q);
return res.body;
};
export const post = async (user: any, params?: misskey.Endpoints['notes/create']['req']): Promise<misskey.entities.Note> => {
const q = Object.assign({
text: 'test',
}, params);
const res = await api('notes/create', q, user);
return res.body ? res.body.createdNote : null;
};
export const react = async (user: any, note: any, reaction: string): Promise<any> => {
await api('notes/reactions/create', {
noteId: note.id,
reaction: reaction,
}, user);
};
interface UploadOptions {
/** Optional, absolute path or relative from ./resources/ */
path?: string | URL;
/** The name to be used for the file upload */
name?: string;
/** A Blob can be provided instead of path */
blob?: Blob;
}
/**
* Upload file
* @param user User
*/
export const uploadFile = async (user: any, { path, name, blob }: UploadOptions = {}): Promise<any> => {
const absPath = path == null
? new URL('resources/Lenna.jpg', import.meta.url)
: isAbsolute(path.toString())
? new URL(path)
: new URL(path, new URL('resources/', import.meta.url));
const formData = new FormData();
formData.append('i', user.token);
formData.append('file', blob ??
new File([await readFile(absPath)], basename(absPath.toString())));
formData.append('force', 'true');
if (name) {
formData.append('name', name);
}
const res = await relativeFetch('api/drive/files/create', {
method: 'POST',
body: formData,
});
const body = res.status !== 204 ? await res.json() : null;
return {
status: res.status,
body,
};
};
export const uploadUrl = async (user: any, url: string) => {
let file: any;
const marker = Math.random().toString();
const ws = await connectStream(user, 'main', (msg) => {
if (msg.type === 'urlUploadFinished' && msg.body.marker === marker) {
file = msg.body.file;
}
});
await api('drive/files/upload-from-url', {
url,
marker,
force: true,
}, user);
await sleep(7000);
ws.close();
return file;
};
export function connectStream(user: any, channel: string, listener: (message: Record<string, any>) => any, params?: any): Promise<WebSocket> {
return new Promise((res, rej) => {
const ws = new WebSocket(`ws://127.0.0.1:${port}/streaming?i=${user.token}`);
ws.on('open', () => {
ws.on('message', data => {
const msg = JSON.parse(data.toString());
if (msg.type === 'channel' && msg.body.id === 'a') {
listener(msg.body);
} else if (msg.type === 'connected' && msg.body.id === 'a') {
res(ws);
}
});
ws.send(JSON.stringify({
type: 'connect',
body: {
channel: channel,
id: 'a',
pong: true,
params: params,
},
}));
});
});
}
export const waitFire = async (user: any, channel: string, trgr: () => any, cond: (msg: Record<string, any>) => boolean, params?: any) => {
return new Promise<boolean>(async (res, rej) => {
let timer: NodeJS.Timeout | null = null;
let ws: WebSocket;
try {
ws = await connectStream(user, channel, msg => {
if (cond(msg)) {
ws.close();
if (timer) clearTimeout(timer);
res(true);
}
}, params);
} catch (e) {
rej(e);
}
if (!ws!) return;
timer = setTimeout(() => {
ws.close();
res(false);
}, 3000);
try {
await trgr();
} catch (e) {
ws.close();
if (timer) clearTimeout(timer);
rej(e);
}
});
};
export const simpleGet = async (path: string, accept = '*/*'): Promise<{ status: number, body: any, type: string | null, location: string | null }> => {
const res = await relativeFetch(path, {
headers: {
Accept: accept,
},
redirect: 'manual',
});
const body = res.headers.get('content-type') === 'application/json; charset=utf-8'
? await res.json()
: null;
return {
status: res.status,
body,
type: res.headers.get('content-type'),
location: res.headers.get('location'),
};
};
export async function initTestDb(justBorrow = false, initEntities?: any[]) {
if (process.env.NODE_ENV !== 'test') throw 'NODE_ENV is not a test';
const db = new DataSource({
type: 'postgres',
host: config.db.host,
port: config.db.port,
username: config.db.user,
password: config.db.pass,
database: config.db.db,
synchronize: true && !justBorrow,
dropSchema: true && !justBorrow,
entities: initEntities ?? entities,
});
await db.initialize();
return db;
}
export function sleep(msec: number) { export function sleep(msec: number) {
return new Promise<void>(res => { return new Promise<void>(res => {
setTimeout(() => { setTimeout(() => {

58
pnpm-lock.yaml
View File

@ -64,7 +64,6 @@ importers:
'@nestjs/core': 9.3.9 '@nestjs/core': 9.3.9
'@nestjs/testing': 9.3.9 '@nestjs/testing': 9.3.9
'@peertube/http-signature': 1.7.0 '@peertube/http-signature': 1.7.0
'@redocly/openapi-core': 1.0.0-beta.123
'@sinonjs/fake-timers': 10.0.2 '@sinonjs/fake-timers': 10.0.2
'@swc/cli': 0.1.62 '@swc/cli': 0.1.62
'@swc/core': 1.3.36 '@swc/core': 1.3.36
@ -341,7 +340,6 @@ importers:
'@tensorflow/tfjs-node': 4.2.0_seedrandom@3.0.5 '@tensorflow/tfjs-node': 4.2.0_seedrandom@3.0.5
devDependencies: devDependencies:
'@jest/globals': 29.4.3 '@jest/globals': 29.4.3
'@redocly/openapi-core': 1.0.0-beta.123
'@swc/jest': 0.2.24_@swc+core@1.3.36 '@swc/jest': 0.2.24_@swc+core@1.3.36
'@types/accepts': 1.3.5 '@types/accepts': 1.3.5
'@types/archiver': 5.3.1 '@types/archiver': 5.3.1
@ -2077,33 +2075,6 @@ packages:
'@redis/client': 1.4.2 '@redis/client': 1.4.2
dev: true dev: true
/@redocly/ajv/8.11.0:
resolution: {integrity: sha512-9GWx27t7xWhDIR02PA18nzBdLcKQRgc46xNQvjFkrYk4UOmvKhJ/dawwiX0cCOeetN5LcaaiqQbVOWYK62SGHw==}
dependencies:
fast-deep-equal: 3.1.3
json-schema-traverse: 1.0.0
require-from-string: 2.0.2
uri-js: 4.4.1
dev: true
/@redocly/openapi-core/1.0.0-beta.123:
resolution: {integrity: sha512-W6MbUWpb/VaV+Kf0c3jmMIJw3WwwF7iK5nAfcOS+ZwrlbxtIl37+1hEydFlJ209vCR9HL12PaMwdh2Vpihj6Jw==}
engines: {node: '>=12.0.0'}
dependencies:
'@redocly/ajv': 8.11.0
'@types/node': 14.18.36
colorette: 1.4.0
js-levenshtein: 1.1.6
js-yaml: 4.1.0
lodash.isequal: 4.5.0
minimatch: 5.1.2
node-fetch: 2.6.7
pluralize: 8.0.0
yaml-ast-parser: 0.0.43
transitivePeerDependencies:
- encoding
dev: true
/@rollup/plugin-alias/4.0.3_rollup@3.17.3: /@rollup/plugin-alias/4.0.3_rollup@3.17.3:
resolution: {integrity: sha512-ZuDWE1q4PQDhvm/zc5Prun8sBpLJy41DMptYrS6MhAy9s9kL/doN1613BWfEchGVfKxzliJ3BjbOPizXX38DbQ==} resolution: {integrity: sha512-ZuDWE1q4PQDhvm/zc5Prun8sBpLJy41DMptYrS6MhAy9s9kL/doN1613BWfEchGVfKxzliJ3BjbOPizXX38DbQ==}
engines: {node: '>=14.0.0'} engines: {node: '>=14.0.0'}
@ -4777,10 +4748,6 @@ packages:
color-string: 1.9.1 color-string: 1.9.1
dev: false dev: false
/colorette/1.4.0:
resolution: {integrity: sha512-Y2oEozpomLn7Q3HFP7dpww7AtMJplbM9lGZP6RDfHqmbeRjiwRg4n6VM6j4KLmRke85uWEI7JqF17f3pqdRA0g==}
dev: true
/colorette/2.0.19: /colorette/2.0.19:
resolution: {integrity: sha512-3tlv/dIP7FWvj3BsbHrGLJ6l/oKh1O3TcgBqMn+yyCagOxc23fyzDS6HypQbgxWbkpDnf52p1LuR4eWDQ/K9WQ==} resolution: {integrity: sha512-3tlv/dIP7FWvj3BsbHrGLJ6l/oKh1O3TcgBqMn+yyCagOxc23fyzDS6HypQbgxWbkpDnf52p1LuR4eWDQ/K9WQ==}
dev: true dev: true
@ -8793,11 +8760,6 @@ packages:
resolution: {integrity: sha512-pZe//GGmwJndub7ZghVHz7vjb2LgC1m8B07Au3eYqeqv9emhESByMXxaEgkUkEqJe87oBbSniGYoQNIBklc7IQ==} resolution: {integrity: sha512-pZe//GGmwJndub7ZghVHz7vjb2LgC1m8B07Au3eYqeqv9emhESByMXxaEgkUkEqJe87oBbSniGYoQNIBklc7IQ==}
dev: false dev: false
/js-levenshtein/1.1.6:
resolution: {integrity: sha512-X2BB11YZtrRqY4EnQcLX5Rh373zbK4alC1FW7D7MBhL2gtcC17cTnr6DmfHZeS0s2rTHjUTMMHfG7gO8SSdw+g==}
engines: {node: '>=0.10.0'}
dev: true
/js-sdsl/4.2.0: /js-sdsl/4.2.0:
resolution: {integrity: sha512-dyBIzQBDkCqCu+0upx25Y2jGdbTGxE9fshMsCdK0ViOongpV+n5tXRcZY9v7CaVQ79AGS9KA1KHtojxiM7aXSQ==} resolution: {integrity: sha512-dyBIzQBDkCqCu+0upx25Y2jGdbTGxE9fshMsCdK0ViOongpV+n5tXRcZY9v7CaVQ79AGS9KA1KHtojxiM7aXSQ==}
dev: true dev: true
@ -8902,6 +8864,7 @@ packages:
/json-schema-traverse/1.0.0: /json-schema-traverse/1.0.0:
resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==}
dev: false
/json-schema/0.4.0: /json-schema/0.4.0:
resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==} resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==}
@ -9218,10 +9181,6 @@ packages:
/lodash.isarguments/3.1.0: /lodash.isarguments/3.1.0:
resolution: {integrity: sha512-chi4NHZlZqZD18a0imDHnZPrDeBbTtVN7GXMwuGdRH9qotxAjYs3aVLKc7zNOG9eddR5Ksd8rvFEBc9SsggPpg==} resolution: {integrity: sha512-chi4NHZlZqZD18a0imDHnZPrDeBbTtVN7GXMwuGdRH9qotxAjYs3aVLKc7zNOG9eddR5Ksd8rvFEBc9SsggPpg==}
/lodash.isequal/4.5.0:
resolution: {integrity: sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==}
dev: true
/lodash.isplainobject/4.0.6: /lodash.isplainobject/4.0.6:
resolution: {integrity: sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==} resolution: {integrity: sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==}
dev: false dev: false
@ -9491,6 +9450,7 @@ packages:
engines: {node: '>=10'} engines: {node: '>=10'}
dependencies: dependencies:
brace-expansion: 2.0.1 brace-expansion: 2.0.1
dev: false
/minimatch/6.2.0: /minimatch/6.2.0:
resolution: {integrity: sha512-sauLxniAmvnhhRjFwPNnJKaPFYyddAgbYdeUpHULtCT/GhzdCx/MDNy+Y40lBxTQUrMzDE8e0S43Z5uqfO0REg==} resolution: {integrity: sha512-sauLxniAmvnhhRjFwPNnJKaPFYyddAgbYdeUpHULtCT/GhzdCx/MDNy+Y40lBxTQUrMzDE8e0S43Z5uqfO0REg==}
@ -9801,6 +9761,7 @@ packages:
optional: true optional: true
dependencies: dependencies:
whatwg-url: 5.0.0 whatwg-url: 5.0.0
dev: false
/node-fetch/3.3.0: /node-fetch/3.3.0:
resolution: {integrity: sha512-BKwRP/O0UvoMKp7GNdwPlObhYGB5DQqwhEDQlNKuoqwVYSxkSZCSbHjnFFmUEtwSKRPU4kNK8PbDYYitwaE3QA==} resolution: {integrity: sha512-BKwRP/O0UvoMKp7GNdwPlObhYGB5DQqwhEDQlNKuoqwVYSxkSZCSbHjnFFmUEtwSKRPU4kNK8PbDYYitwaE3QA==}
@ -10558,11 +10519,6 @@ packages:
extend-shallow: 3.0.2 extend-shallow: 3.0.2
dev: false dev: false
/pluralize/8.0.0:
resolution: {integrity: sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==}
engines: {node: '>=4'}
dev: true
/pngjs-nozlib/1.0.0: /pngjs-nozlib/1.0.0:
resolution: {integrity: sha512-N1PggqLp9xDqwAoKvGohmZ3m4/N9xpY0nDZivFqQLcpLHmliHnCp9BuNCsOeqHWMuEEgFjpEaq9dZq6RZyy0fA==} resolution: {integrity: sha512-N1PggqLp9xDqwAoKvGohmZ3m4/N9xpY0nDZivFqQLcpLHmliHnCp9BuNCsOeqHWMuEEgFjpEaq9dZq6RZyy0fA==}
engines: {iojs: '>= 1.0.0', node: '>=0.10.0'} engines: {iojs: '>= 1.0.0', node: '>=0.10.0'}
@ -11519,6 +11475,7 @@ packages:
/require-from-string/2.0.2: /require-from-string/2.0.2:
resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==} resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==}
engines: {node: '>=0.10.0'} engines: {node: '>=0.10.0'}
dev: false
/require-main-filename/1.0.1: /require-main-filename/1.0.1:
resolution: {integrity: sha512-IqSUtOVP4ksd1C/ej5zeEh/BIP2ajqpn8c5x+q99gvcIG/Qf0cud5raVnE/Dwd0ua9TXYDoDc0RE5hBSdz22Ug==} resolution: {integrity: sha512-IqSUtOVP4ksd1C/ej5zeEh/BIP2ajqpn8c5x+q99gvcIG/Qf0cud5raVnE/Dwd0ua9TXYDoDc0RE5hBSdz22Ug==}
@ -12663,6 +12620,7 @@ packages:
/tr46/0.0.3: /tr46/0.0.3:
resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==} resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
dev: false
/tr46/3.0.0: /tr46/3.0.0:
resolution: {integrity: sha512-l7FvfAHlcmulp8kr+flpQZmVwtu7nfRV7NZujtN0OqES8EL4O4e0qqzL0DC5gAvx/ZC/9lk6rhcUwYvkBnBnYA==} resolution: {integrity: sha512-l7FvfAHlcmulp8kr+flpQZmVwtu7nfRV7NZujtN0OqES8EL4O4e0qqzL0DC5gAvx/ZC/9lk6rhcUwYvkBnBnYA==}
@ -13371,6 +13329,7 @@ packages:
/webidl-conversions/3.0.1: /webidl-conversions/3.0.1:
resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==} resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
dev: false
/webidl-conversions/7.0.0: /webidl-conversions/7.0.0:
resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==} resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==}
@ -13416,6 +13375,7 @@ packages:
dependencies: dependencies:
tr46: 0.0.3 tr46: 0.0.3
webidl-conversions: 3.0.1 webidl-conversions: 3.0.1
dev: false
/whet.extend/0.9.9: /whet.extend/0.9.9:
resolution: {integrity: sha512-mmIPAft2vTgEILgPeZFqE/wWh24SEsR/k+N9fJ3Jxrz44iDFy9aemCxdksfURSHYFCLmvs/d/7Iso5XjPpNfrA==} resolution: {integrity: sha512-mmIPAft2vTgEILgPeZFqE/wWh24SEsR/k+N9fJ3Jxrz44iDFy9aemCxdksfURSHYFCLmvs/d/7Iso5XjPpNfrA==}
@ -13606,10 +13566,6 @@ packages:
/yallist/4.0.0: /yallist/4.0.0:
resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==} resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}
/yaml-ast-parser/0.0.43:
resolution: {integrity: sha512-2PTINUwsRqSd+s8XxKaJWQlUuEMHJQyEuh2edBbW8KNJz0SJPwUSD2zRWqezFEdN7IzAgeuYHFUCF7o8zRdZ0A==}
dev: true
/yargs-parser/18.1.3: /yargs-parser/18.1.3:
resolution: {integrity: sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==} resolution: {integrity: sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==}
engines: {node: '>=6'} engines: {node: '>=6'}