diff options
Diffstat (limited to 'server/tests/plugins/plugin-helpers.ts')
-rw-r--r-- | server/tests/plugins/plugin-helpers.ts | 383 |
1 files changed, 0 insertions, 383 deletions
diff --git a/server/tests/plugins/plugin-helpers.ts b/server/tests/plugins/plugin-helpers.ts deleted file mode 100644 index f5a0cbe85..000000000 --- a/server/tests/plugins/plugin-helpers.ts +++ /dev/null | |||
@@ -1,383 +0,0 @@ | |||
1 | /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */ | ||
2 | |||
3 | import { expect } from 'chai' | ||
4 | import { pathExists } from 'fs-extra' | ||
5 | import { HttpStatusCode, ThumbnailType } from '@shared/models' | ||
6 | import { | ||
7 | cleanupTests, | ||
8 | createMultipleServers, | ||
9 | doubleFollow, | ||
10 | makeGetRequest, | ||
11 | makePostBodyRequest, | ||
12 | makeRawRequest, | ||
13 | PeerTubeServer, | ||
14 | PluginsCommand, | ||
15 | setAccessTokensToServers, | ||
16 | waitJobs | ||
17 | } from '@shared/server-commands' | ||
18 | import { checkVideoFilesWereRemoved } from '../shared' | ||
19 | |||
20 | function postCommand (server: PeerTubeServer, command: string, bodyArg?: object) { | ||
21 | const body = { command } | ||
22 | if (bodyArg) Object.assign(body, bodyArg) | ||
23 | |||
24 | return makePostBodyRequest({ | ||
25 | url: server.url, | ||
26 | path: '/plugins/test-four/router/commander', | ||
27 | fields: body, | ||
28 | expectedStatus: HttpStatusCode.NO_CONTENT_204 | ||
29 | }) | ||
30 | } | ||
31 | |||
32 | describe('Test plugin helpers', function () { | ||
33 | let servers: PeerTubeServer[] | ||
34 | |||
35 | before(async function () { | ||
36 | this.timeout(60000) | ||
37 | |||
38 | servers = await createMultipleServers(2) | ||
39 | await setAccessTokensToServers(servers) | ||
40 | |||
41 | await doubleFollow(servers[0], servers[1]) | ||
42 | |||
43 | await servers[0].plugins.install({ path: PluginsCommand.getPluginTestPath('-four') }) | ||
44 | }) | ||
45 | |||
46 | describe('Logger', function () { | ||
47 | |||
48 | it('Should have logged things', async function () { | ||
49 | await servers[0].servers.waitUntilLog(servers[0].host + ' peertube-plugin-test-four', 1, false) | ||
50 | await servers[0].servers.waitUntilLog('Hello world from plugin four', 1) | ||
51 | }) | ||
52 | }) | ||
53 | |||
54 | describe('Database', function () { | ||
55 | |||
56 | it('Should have made a query', async function () { | ||
57 | await servers[0].servers.waitUntilLog(`root email is admin${servers[0].internalServerNumber}@example.com`) | ||
58 | }) | ||
59 | }) | ||
60 | |||
61 | describe('Config', function () { | ||
62 | |||
63 | it('Should have the correct webserver url', async function () { | ||
64 | await servers[0].servers.waitUntilLog(`server url is ${servers[0].url}`) | ||
65 | }) | ||
66 | |||
67 | it('Should have the correct listening config', async function () { | ||
68 | const res = await makeGetRequest({ | ||
69 | url: servers[0].url, | ||
70 | path: '/plugins/test-four/router/server-listening-config', | ||
71 | expectedStatus: HttpStatusCode.OK_200 | ||
72 | }) | ||
73 | |||
74 | expect(res.body.config).to.exist | ||
75 | expect(res.body.config.hostname).to.equal('::') | ||
76 | expect(res.body.config.port).to.equal(servers[0].port) | ||
77 | }) | ||
78 | |||
79 | it('Should have the correct config', async function () { | ||
80 | const res = await makeGetRequest({ | ||
81 | url: servers[0].url, | ||
82 | path: '/plugins/test-four/router/server-config', | ||
83 | expectedStatus: HttpStatusCode.OK_200 | ||
84 | }) | ||
85 | |||
86 | expect(res.body.serverConfig).to.exist | ||
87 | expect(res.body.serverConfig.instance.name).to.equal('PeerTube') | ||
88 | }) | ||
89 | }) | ||
90 | |||
91 | describe('Server', function () { | ||
92 | |||
93 | it('Should get the server actor', async function () { | ||
94 | await servers[0].servers.waitUntilLog('server actor name is peertube') | ||
95 | }) | ||
96 | }) | ||
97 | |||
98 | describe('Socket', function () { | ||
99 | |||
100 | it('Should sendNotification without any exceptions', async () => { | ||
101 | const user = await servers[0].users.create({ username: 'notis_redding', password: 'secret1234?' }) | ||
102 | await makePostBodyRequest({ | ||
103 | url: servers[0].url, | ||
104 | path: '/plugins/test-four/router/send-notification', | ||
105 | fields: { | ||
106 | userId: user.id | ||
107 | }, | ||
108 | expectedStatus: HttpStatusCode.CREATED_201 | ||
109 | }) | ||
110 | }) | ||
111 | |||
112 | it('Should sendVideoLiveNewState without any exceptions', async () => { | ||
113 | const res = await servers[0].videos.quickUpload({ name: 'video server 1' }) | ||
114 | |||
115 | await makePostBodyRequest({ | ||
116 | url: servers[0].url, | ||
117 | path: '/plugins/test-four/router/send-video-live-new-state/' + res.uuid, | ||
118 | expectedStatus: HttpStatusCode.CREATED_201 | ||
119 | }) | ||
120 | |||
121 | await servers[0].videos.remove({ id: res.uuid }) | ||
122 | }) | ||
123 | }) | ||
124 | |||
125 | describe('Plugin', function () { | ||
126 | |||
127 | it('Should get the base static route', async function () { | ||
128 | const res = await makeGetRequest({ | ||
129 | url: servers[0].url, | ||
130 | path: '/plugins/test-four/router/static-route', | ||
131 | expectedStatus: HttpStatusCode.OK_200 | ||
132 | }) | ||
133 | |||
134 | expect(res.body.staticRoute).to.equal('/plugins/test-four/0.0.1/static/') | ||
135 | }) | ||
136 | |||
137 | it('Should get the base static route', async function () { | ||
138 | const baseRouter = '/plugins/test-four/0.0.1/router/' | ||
139 | |||
140 | const res = await makeGetRequest({ | ||
141 | url: servers[0].url, | ||
142 | path: baseRouter + 'router-route', | ||
143 | expectedStatus: HttpStatusCode.OK_200 | ||
144 | }) | ||
145 | |||
146 | expect(res.body.routerRoute).to.equal(baseRouter) | ||
147 | }) | ||
148 | }) | ||
149 | |||
150 | describe('User', function () { | ||
151 | let rootId: number | ||
152 | |||
153 | it('Should not get a user if not authenticated', async function () { | ||
154 | await makeGetRequest({ | ||
155 | url: servers[0].url, | ||
156 | path: '/plugins/test-four/router/user', | ||
157 | expectedStatus: HttpStatusCode.NOT_FOUND_404 | ||
158 | }) | ||
159 | }) | ||
160 | |||
161 | it('Should get a user if authenticated', async function () { | ||
162 | const res = await makeGetRequest({ | ||
163 | url: servers[0].url, | ||
164 | token: servers[0].accessToken, | ||
165 | path: '/plugins/test-four/router/user', | ||
166 | expectedStatus: HttpStatusCode.OK_200 | ||
167 | }) | ||
168 | |||
169 | expect(res.body.username).to.equal('root') | ||
170 | expect(res.body.displayName).to.equal('root') | ||
171 | expect(res.body.isAdmin).to.be.true | ||
172 | expect(res.body.isModerator).to.be.false | ||
173 | expect(res.body.isUser).to.be.false | ||
174 | |||
175 | rootId = res.body.id | ||
176 | }) | ||
177 | |||
178 | it('Should load a user by id', async function () { | ||
179 | { | ||
180 | const res = await makeGetRequest({ | ||
181 | url: servers[0].url, | ||
182 | path: '/plugins/test-four/router/user/' + rootId, | ||
183 | expectedStatus: HttpStatusCode.OK_200 | ||
184 | }) | ||
185 | |||
186 | expect(res.body.username).to.equal('root') | ||
187 | } | ||
188 | |||
189 | { | ||
190 | await makeGetRequest({ | ||
191 | url: servers[0].url, | ||
192 | path: '/plugins/test-four/router/user/42', | ||
193 | expectedStatus: HttpStatusCode.NOT_FOUND_404 | ||
194 | }) | ||
195 | } | ||
196 | }) | ||
197 | }) | ||
198 | |||
199 | describe('Moderation', function () { | ||
200 | let videoUUIDServer1: string | ||
201 | |||
202 | before(async function () { | ||
203 | this.timeout(60000) | ||
204 | |||
205 | { | ||
206 | const res = await servers[0].videos.quickUpload({ name: 'video server 1' }) | ||
207 | videoUUIDServer1 = res.uuid | ||
208 | } | ||
209 | |||
210 | { | ||
211 | await servers[1].videos.quickUpload({ name: 'video server 2' }) | ||
212 | } | ||
213 | |||
214 | await waitJobs(servers) | ||
215 | |||
216 | const { data } = await servers[0].videos.list() | ||
217 | |||
218 | expect(data).to.have.lengthOf(2) | ||
219 | }) | ||
220 | |||
221 | it('Should mute server 2', async function () { | ||
222 | await postCommand(servers[0], 'blockServer', { hostToBlock: servers[1].host }) | ||
223 | |||
224 | const { data } = await servers[0].videos.list() | ||
225 | |||
226 | expect(data).to.have.lengthOf(1) | ||
227 | expect(data[0].name).to.equal('video server 1') | ||
228 | }) | ||
229 | |||
230 | it('Should unmute server 2', async function () { | ||
231 | await postCommand(servers[0], 'unblockServer', { hostToUnblock: servers[1].host }) | ||
232 | |||
233 | const { data } = await servers[0].videos.list() | ||
234 | |||
235 | expect(data).to.have.lengthOf(2) | ||
236 | }) | ||
237 | |||
238 | it('Should mute account of server 2', async function () { | ||
239 | await postCommand(servers[0], 'blockAccount', { handleToBlock: `root@${servers[1].host}` }) | ||
240 | |||
241 | const { data } = await servers[0].videos.list() | ||
242 | |||
243 | expect(data).to.have.lengthOf(1) | ||
244 | expect(data[0].name).to.equal('video server 1') | ||
245 | }) | ||
246 | |||
247 | it('Should unmute account of server 2', async function () { | ||
248 | await postCommand(servers[0], 'unblockAccount', { handleToUnblock: `root@${servers[1].host}` }) | ||
249 | |||
250 | const { data } = await servers[0].videos.list() | ||
251 | |||
252 | expect(data).to.have.lengthOf(2) | ||
253 | }) | ||
254 | |||
255 | it('Should blacklist video', async function () { | ||
256 | await postCommand(servers[0], 'blacklist', { videoUUID: videoUUIDServer1, unfederate: true }) | ||
257 | |||
258 | await waitJobs(servers) | ||
259 | |||
260 | for (const server of servers) { | ||
261 | const { data } = await server.videos.list() | ||
262 | |||
263 | expect(data).to.have.lengthOf(1) | ||
264 | expect(data[0].name).to.equal('video server 2') | ||
265 | } | ||
266 | }) | ||
267 | |||
268 | it('Should unblacklist video', async function () { | ||
269 | await postCommand(servers[0], 'unblacklist', { videoUUID: videoUUIDServer1 }) | ||
270 | |||
271 | await waitJobs(servers) | ||
272 | |||
273 | for (const server of servers) { | ||
274 | const { data } = await server.videos.list() | ||
275 | |||
276 | expect(data).to.have.lengthOf(2) | ||
277 | } | ||
278 | }) | ||
279 | }) | ||
280 | |||
281 | describe('Videos', function () { | ||
282 | let videoUUID: string | ||
283 | let videoPath: string | ||
284 | |||
285 | before(async function () { | ||
286 | this.timeout(240000) | ||
287 | |||
288 | await servers[0].config.enableTranscoding() | ||
289 | |||
290 | const res = await servers[0].videos.quickUpload({ name: 'video1' }) | ||
291 | videoUUID = res.uuid | ||
292 | |||
293 | await waitJobs(servers) | ||
294 | }) | ||
295 | |||
296 | it('Should get video files', async function () { | ||
297 | const { body } = await makeGetRequest({ | ||
298 | url: servers[0].url, | ||
299 | path: '/plugins/test-four/router/video-files/' + videoUUID, | ||
300 | expectedStatus: HttpStatusCode.OK_200 | ||
301 | }) | ||
302 | |||
303 | // Video files check | ||
304 | { | ||
305 | expect(body.webVideo.videoFiles).to.be.an('array') | ||
306 | expect(body.hls.videoFiles).to.be.an('array') | ||
307 | |||
308 | for (const resolution of [ 144, 240, 360, 480, 720 ]) { | ||
309 | for (const files of [ body.webVideo.videoFiles, body.hls.videoFiles ]) { | ||
310 | const file = files.find(f => f.resolution === resolution) | ||
311 | expect(file).to.exist | ||
312 | |||
313 | expect(file.size).to.be.a('number') | ||
314 | expect(file.fps).to.equal(25) | ||
315 | |||
316 | expect(await pathExists(file.path)).to.be.true | ||
317 | await makeRawRequest({ url: file.url, expectedStatus: HttpStatusCode.OK_200 }) | ||
318 | } | ||
319 | } | ||
320 | |||
321 | videoPath = body.webVideo.videoFiles[0].path | ||
322 | } | ||
323 | |||
324 | // Thumbnails check | ||
325 | { | ||
326 | expect(body.thumbnails).to.be.an('array') | ||
327 | |||
328 | const miniature = body.thumbnails.find(t => t.type === ThumbnailType.MINIATURE) | ||
329 | expect(miniature).to.exist | ||
330 | expect(await pathExists(miniature.path)).to.be.true | ||
331 | await makeRawRequest({ url: miniature.url, expectedStatus: HttpStatusCode.OK_200 }) | ||
332 | |||
333 | const preview = body.thumbnails.find(t => t.type === ThumbnailType.PREVIEW) | ||
334 | expect(preview).to.exist | ||
335 | expect(await pathExists(preview.path)).to.be.true | ||
336 | await makeRawRequest({ url: preview.url, expectedStatus: HttpStatusCode.OK_200 }) | ||
337 | } | ||
338 | }) | ||
339 | |||
340 | it('Should probe a file', async function () { | ||
341 | const { body } = await makeGetRequest({ | ||
342 | url: servers[0].url, | ||
343 | path: '/plugins/test-four/router/ffprobe', | ||
344 | query: { | ||
345 | path: videoPath | ||
346 | }, | ||
347 | expectedStatus: HttpStatusCode.OK_200 | ||
348 | }) | ||
349 | |||
350 | expect(body.streams).to.be.an('array') | ||
351 | expect(body.streams).to.have.lengthOf(2) | ||
352 | }) | ||
353 | |||
354 | it('Should remove a video after a view', async function () { | ||
355 | this.timeout(40000) | ||
356 | |||
357 | // Should not throw -> video exists | ||
358 | const video = await servers[0].videos.get({ id: videoUUID }) | ||
359 | // Should delete the video | ||
360 | await servers[0].views.simulateView({ id: videoUUID }) | ||
361 | |||
362 | await servers[0].servers.waitUntilLog('Video deleted by plugin four.') | ||
363 | |||
364 | try { | ||
365 | // Should throw because the video should have been deleted | ||
366 | await servers[0].videos.get({ id: videoUUID }) | ||
367 | throw new Error('Video exists') | ||
368 | } catch (err) { | ||
369 | if (err.message.includes('exists')) throw err | ||
370 | } | ||
371 | |||
372 | await checkVideoFilesWereRemoved({ server: servers[0], video }) | ||
373 | }) | ||
374 | |||
375 | it('Should have fetched the video by URL', async function () { | ||
376 | await servers[0].servers.waitUntilLog(`video from DB uuid is ${videoUUID}`) | ||
377 | }) | ||
378 | }) | ||
379 | |||
380 | after(async function () { | ||
381 | await cleanupTests(servers) | ||
382 | }) | ||
383 | }) | ||