1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
/*
* SPDX-FileCopyrightText: syuilo and misskey-project
* SPDX-License-Identifier: AGPL-3.0-only
*/
process.env.NODE_ENV = 'test';
import { afterAll, beforeAll, describe, expect, test } from '@jest/globals';
import { Test } from '@nestjs/testing';
import type { TestingModule } from '@nestjs/testing';
import type { DriveFilesRepository, DriveFoldersRepository } from '@/models/_.js';
import { GlobalModule } from '@/GlobalModule.js';
import { CoreModule } from '@/core/CoreModule.js';
import { DriveFolderEntityService } from '@/core/entities/DriveFolderEntityService.js';
import { DI } from '@/di-symbols.js';
import { genAidx } from '@/misc/id/aidx.js';
import { secureRndstr } from '@/misc/secure-rndstr.js';
const describeBenchmark = process.env.RUN_BENCHMARKS === '1' ? describe : describe.skip;
describe('DriveFolderEntityService', () => {
let app: TestingModule;
let service: DriveFolderEntityService;
let driveFoldersRepository: DriveFoldersRepository;
let driveFilesRepository: DriveFilesRepository;
let idCounter = 0;
const nextId = () => genAidx(Date.now() + (idCounter++));
const createFolder = async (name: string, parentId: string | null) => {
const id = nextId();
await driveFoldersRepository.insert({
id,
name,
userId: null,
parentId,
});
return driveFoldersRepository.findOneByOrFail({ id });
};
const createFile = async (folderId: string | null) => {
const id = nextId();
await driveFilesRepository.insert({
id,
userId: null,
userHost: null,
md5: secureRndstr(32),
name: `file-${id}`,
type: 'text/plain',
size: 1,
comment: null,
blurhash: null,
properties: {},
storedInternal: true,
url: `https://example.com/${id}`,
thumbnailUrl: null,
webpublicUrl: null,
webpublicType: null,
accessKey: null,
thumbnailAccessKey: null,
webpublicAccessKey: null,
uri: null,
src: null,
folderId,
isSensitive: false,
maybeSensitive: false,
maybePorn: false,
isLink: false,
requestHeaders: null,
requestIp: null,
});
};
beforeAll(async () => {
app = await Test.createTestingModule({
imports: [GlobalModule, CoreModule],
}).compile();
await app.init();
app.enableShutdownHooks();
service = app.get<DriveFolderEntityService>(DriveFolderEntityService);
driveFoldersRepository = app.get<DriveFoldersRepository>(DI.driveFoldersRepository);
driveFilesRepository = app.get<DriveFilesRepository>(DI.driveFilesRepository);
});
afterAll(async () => {
await app.close();
});
describe('pack', () => {
test('detail: false', async () => {
const root = await createFolder('root', null);
const child = await createFolder('child', root.id);
const packed = await service.pack(child, { detail: false }) as any;
expect(packed.id).toBe(child.id);
expect(packed.parentId).toBe(root.id);
expect(packed.parent).toBeUndefined();
expect(packed.foldersCount).toBeUndefined();
expect(packed.filesCount).toBeUndefined();
});
test('detail: true', async () => {
const root = await createFolder('root-detail', null);
const child = await createFolder('child-detail', root.id);
await createFolder('grandchild-detail', child.id);
await createFile(child.id);
await createFile(child.id);
const packed = await service.pack(child, { detail: true }) as any;
expect(packed.id).toBe(child.id);
expect(packed.foldersCount).toBe(1);
expect(packed.filesCount).toBe(2);
expect(packed.parent?.id).toBe(root.id);
expect(packed.parent?.parent).toBeUndefined();
});
test('detail: true reaches root for deep hierarchy', async () => {
const root = await createFolder('root-deep', null);
const level1 = await createFolder('level-1', root.id);
const level2 = await createFolder('level-2', level1.id);
const level3 = await createFolder('level-3', level2.id);
const level4 = await createFolder('level-4', level3.id);
const level5 = await createFolder('level-5', level4.id);
const packed = await service.pack(level5, { detail: true }) as any;
expect(packed.id).toBe(level5.id);
expect(packed.parent?.id).toBe(level4.id);
expect(packed.parent?.parent?.id).toBe(level3.id);
expect(packed.parent?.parent?.parent?.id).toBe(level2.id);
expect(packed.parent?.parent?.parent?.parent?.id).toBe(level1.id);
expect(packed.parent?.parent?.parent?.parent?.parent?.id).toBe(root.id);
expect(packed.parent?.parent?.parent?.parent?.parent?.parent).toBeUndefined();
});
});
describe('packMany', () => {
test('preserves order and packs parents', async () => {
const root = await createFolder('root-many', null);
const childA = await createFolder('child-a', root.id);
const childB = await createFolder('child-b', root.id);
await createFolder('child-a-sub', childA.id);
await createFile(childA.id);
const packed = await service.packMany([childB, childA], { detail: true }) as any;
expect(packed[0].id).toBe(childB.id);
expect(packed[1].id).toBe(childA.id);
expect(packed[0].parent?.id).toBe(root.id);
expect(packed[1].parent?.id).toBe(root.id);
expect(packed[0].filesCount).toBe(0);
expect(packed[1].filesCount).toBe(1);
expect(packed[0].foldersCount).toBe(0);
expect(packed[1].foldersCount).toBe(1);
});
});
describeBenchmark('benchmark', () => {
test('packMany', async () => {
const root = await createFolder('bench-root', null);
const folders = [];
for (let i = 0; i < 200; i++) {
folders.push(await createFolder(`bench-${i}`, root.id));
}
const start = Date.now();
await service.packMany(folders, { detail: true });
const elapsed = Date.now() - start;
console.log(`DriveFolderEntityService.packMany benchmark: ${elapsed}ms`);
});
});
});
|
