aboutsummaryrefslogtreecommitdiffhomepage
path: root/server/tests/api/users/user-subscriptions.ts
diff options
context:
space:
mode:
Diffstat (limited to 'server/tests/api/users/user-subscriptions.ts')
-rw-r--r--server/tests/api/users/user-subscriptions.ts614
1 files changed, 0 insertions, 614 deletions
diff --git a/server/tests/api/users/user-subscriptions.ts b/server/tests/api/users/user-subscriptions.ts
deleted file mode 100644
index ad2b82a4a..000000000
--- a/server/tests/api/users/user-subscriptions.ts
+++ /dev/null
@@ -1,614 +0,0 @@
1/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
2
3import { expect } from 'chai'
4import { VideoPrivacy } from '@shared/models'
5import {
6 cleanupTests,
7 createMultipleServers,
8 doubleFollow,
9 PeerTubeServer,
10 setAccessTokensToServers,
11 setDefaultAccountAvatar,
12 setDefaultChannelAvatar,
13 SubscriptionsCommand,
14 waitJobs
15} from '@shared/server-commands'
16
17describe('Test users subscriptions', function () {
18 let servers: PeerTubeServer[] = []
19 const users: { accessToken: string }[] = []
20 let video3UUID: string
21
22 let command: SubscriptionsCommand
23
24 before(async function () {
25 this.timeout(240000)
26
27 servers = await createMultipleServers(3)
28
29 // Get the access tokens
30 await setAccessTokensToServers(servers)
31 await setDefaultChannelAvatar(servers)
32 await setDefaultAccountAvatar(servers)
33
34 // Server 1 and server 2 follow each other
35 await doubleFollow(servers[0], servers[1])
36
37 for (const server of servers) {
38 const user = { username: 'user' + server.serverNumber, password: 'password' }
39 await server.users.create({ username: user.username, password: user.password })
40
41 const accessToken = await server.login.getAccessToken(user)
42 users.push({ accessToken })
43
44 const videoName1 = 'video 1-' + server.serverNumber
45 await server.videos.upload({ token: accessToken, attributes: { name: videoName1 } })
46
47 const videoName2 = 'video 2-' + server.serverNumber
48 await server.videos.upload({ token: accessToken, attributes: { name: videoName2 } })
49 }
50
51 await waitJobs(servers)
52
53 command = servers[0].subscriptions
54 })
55
56 describe('Destinction between server videos and user videos', function () {
57 it('Should display videos of server 2 on server 1', async function () {
58 const { total } = await servers[0].videos.list()
59
60 expect(total).to.equal(4)
61 })
62
63 it('User of server 1 should follow user of server 3 and root of server 1', async function () {
64 this.timeout(60000)
65
66 await command.add({ token: users[0].accessToken, targetUri: 'user3_channel@' + servers[2].host })
67 await command.add({ token: users[0].accessToken, targetUri: 'root_channel@' + servers[0].host })
68
69 await waitJobs(servers)
70
71 const attributes = { name: 'video server 3 added after follow' }
72 const { uuid } = await servers[2].videos.upload({ token: users[2].accessToken, attributes })
73 video3UUID = uuid
74
75 await waitJobs(servers)
76 })
77
78 it('Should not display videos of server 3 on server 1', async function () {
79 const { total, data } = await servers[0].videos.list()
80 expect(total).to.equal(4)
81
82 for (const video of data) {
83 expect(video.name).to.not.contain('1-3')
84 expect(video.name).to.not.contain('2-3')
85 expect(video.name).to.not.contain('video server 3 added after follow')
86 }
87 })
88 })
89
90 describe('Subscription endpoints', function () {
91
92 it('Should list subscriptions', async function () {
93 {
94 const body = await command.list()
95 expect(body.total).to.equal(0)
96 expect(body.data).to.be.an('array')
97 expect(body.data).to.have.lengthOf(0)
98 }
99
100 {
101 const body = await command.list({ token: users[0].accessToken, sort: 'createdAt' })
102 expect(body.total).to.equal(2)
103
104 const subscriptions = body.data
105 expect(subscriptions).to.be.an('array')
106 expect(subscriptions).to.have.lengthOf(2)
107
108 expect(subscriptions[0].name).to.equal('user3_channel')
109 expect(subscriptions[1].name).to.equal('root_channel')
110 }
111 })
112
113 it('Should get subscription', async function () {
114 {
115 const videoChannel = await command.get({ token: users[0].accessToken, uri: 'user3_channel@' + servers[2].host })
116
117 expect(videoChannel.name).to.equal('user3_channel')
118 expect(videoChannel.host).to.equal(servers[2].host)
119 expect(videoChannel.displayName).to.equal('Main user3 channel')
120 expect(videoChannel.followingCount).to.equal(0)
121 expect(videoChannel.followersCount).to.equal(1)
122 }
123
124 {
125 const videoChannel = await command.get({ token: users[0].accessToken, uri: 'root_channel@' + servers[0].host })
126
127 expect(videoChannel.name).to.equal('root_channel')
128 expect(videoChannel.host).to.equal(servers[0].host)
129 expect(videoChannel.displayName).to.equal('Main root channel')
130 expect(videoChannel.followingCount).to.equal(0)
131 expect(videoChannel.followersCount).to.equal(1)
132 }
133 })
134
135 it('Should return the existing subscriptions', async function () {
136 const uris = [
137 'user3_channel@' + servers[2].host,
138 'root2_channel@' + servers[0].host,
139 'root_channel@' + servers[0].host,
140 'user3_channel@' + servers[0].host
141 ]
142
143 const body = await command.exist({ token: users[0].accessToken, uris })
144
145 expect(body['user3_channel@' + servers[2].host]).to.be.true
146 expect(body['root2_channel@' + servers[0].host]).to.be.false
147 expect(body['root_channel@' + servers[0].host]).to.be.true
148 expect(body['user3_channel@' + servers[0].host]).to.be.false
149 })
150
151 it('Should search among subscriptions', async function () {
152 {
153 const body = await command.list({ token: users[0].accessToken, sort: '-createdAt', search: 'user3_channel' })
154 expect(body.total).to.equal(1)
155 expect(body.data).to.have.lengthOf(1)
156 }
157
158 {
159 const body = await command.list({ token: users[0].accessToken, sort: '-createdAt', search: 'toto' })
160 expect(body.total).to.equal(0)
161 expect(body.data).to.have.lengthOf(0)
162 }
163 })
164 })
165
166 describe('Subscription videos', function () {
167
168 it('Should list subscription videos', async function () {
169 {
170 const body = await servers[0].videos.listMySubscriptionVideos()
171 expect(body.total).to.equal(0)
172 expect(body.data).to.be.an('array')
173 expect(body.data).to.have.lengthOf(0)
174 }
175
176 {
177 const body = await servers[0].videos.listMySubscriptionVideos({ token: users[0].accessToken, sort: 'createdAt' })
178 expect(body.total).to.equal(3)
179
180 const videos = body.data
181 expect(videos).to.be.an('array')
182 expect(videos).to.have.lengthOf(3)
183
184 expect(videos[0].name).to.equal('video 1-3')
185 expect(videos[1].name).to.equal('video 2-3')
186 expect(videos[2].name).to.equal('video server 3 added after follow')
187 }
188
189 {
190 const body = await servers[0].videos.listMySubscriptionVideos({ token: users[0].accessToken, count: 1, start: 1 })
191 expect(body.total).to.equal(3)
192
193 const videos = body.data
194 expect(videos).to.be.an('array')
195 expect(videos).to.have.lengthOf(1)
196
197 expect(videos[0].name).to.equal('video 2-3')
198 }
199 })
200
201 it('Should upload a video by root on server 1 and see it in the subscription videos', async function () {
202 this.timeout(60000)
203
204 const videoName = 'video server 1 added after follow'
205 await servers[0].videos.upload({ attributes: { name: videoName } })
206
207 await waitJobs(servers)
208
209 {
210 const body = await servers[0].videos.listMySubscriptionVideos()
211 expect(body.total).to.equal(0)
212 expect(body.data).to.be.an('array')
213 expect(body.data).to.have.lengthOf(0)
214 }
215
216 {
217 const body = await servers[0].videos.listMySubscriptionVideos({ token: users[0].accessToken, sort: 'createdAt' })
218 expect(body.total).to.equal(4)
219
220 const videos = body.data
221 expect(videos).to.be.an('array')
222 expect(videos).to.have.lengthOf(4)
223
224 expect(videos[0].name).to.equal('video 1-3')
225 expect(videos[1].name).to.equal('video 2-3')
226 expect(videos[2].name).to.equal('video server 3 added after follow')
227 expect(videos[3].name).to.equal('video server 1 added after follow')
228 }
229
230 {
231 const { data, total } = await servers[0].videos.list()
232 expect(total).to.equal(5)
233
234 for (const video of data) {
235 expect(video.name).to.not.contain('1-3')
236 expect(video.name).to.not.contain('2-3')
237 expect(video.name).to.not.contain('video server 3 added after follow')
238 }
239 }
240 })
241
242 it('Should have server 1 following server 3 and display server 3 videos', async function () {
243 this.timeout(60000)
244
245 await servers[0].follows.follow({ hosts: [ servers[2].url ] })
246
247 await waitJobs(servers)
248
249 const { data, total } = await servers[0].videos.list()
250 expect(total).to.equal(8)
251
252 const names = [ '1-3', '2-3', 'video server 3 added after follow' ]
253 for (const name of names) {
254 const video = data.find(v => v.name.includes(name))
255 expect(video).to.not.be.undefined
256 }
257 })
258
259 it('Should remove follow server 1 -> server 3 and hide server 3 videos', async function () {
260 this.timeout(60000)
261
262 await servers[0].follows.unfollow({ target: servers[2] })
263
264 await waitJobs(servers)
265
266 const { total, data } = await servers[0].videos.list()
267 expect(total).to.equal(5)
268
269 for (const video of data) {
270 expect(video.name).to.not.contain('1-3')
271 expect(video.name).to.not.contain('2-3')
272 expect(video.name).to.not.contain('video server 3 added after follow')
273 }
274 })
275
276 it('Should still list subscription videos', async function () {
277 {
278 const body = await servers[0].videos.listMySubscriptionVideos()
279 expect(body.total).to.equal(0)
280 expect(body.data).to.be.an('array')
281 expect(body.data).to.have.lengthOf(0)
282 }
283
284 {
285 const body = await servers[0].videos.listMySubscriptionVideos({ token: users[0].accessToken, sort: 'createdAt' })
286 expect(body.total).to.equal(4)
287
288 const videos = body.data
289 expect(videos).to.be.an('array')
290 expect(videos).to.have.lengthOf(4)
291
292 expect(videos[0].name).to.equal('video 1-3')
293 expect(videos[1].name).to.equal('video 2-3')
294 expect(videos[2].name).to.equal('video server 3 added after follow')
295 expect(videos[3].name).to.equal('video server 1 added after follow')
296 }
297 })
298 })
299
300 describe('Existing subscription video update', function () {
301
302 it('Should update a video of server 3 and see the updated video on server 1', async function () {
303 this.timeout(30000)
304
305 await servers[2].videos.update({ id: video3UUID, attributes: { name: 'video server 3 added after follow updated' } })
306
307 await waitJobs(servers)
308
309 const body = await servers[0].videos.listMySubscriptionVideos({ token: users[0].accessToken, sort: 'createdAt' })
310 expect(body.data[2].name).to.equal('video server 3 added after follow updated')
311 })
312 })
313
314 describe('Subscription removal', function () {
315
316 it('Should remove user of server 3 subscription', async function () {
317 this.timeout(30000)
318
319 await command.remove({ token: users[0].accessToken, uri: 'user3_channel@' + servers[2].host })
320
321 await waitJobs(servers)
322 })
323
324 it('Should not display its videos anymore', async function () {
325 const body = await servers[0].videos.listMySubscriptionVideos({ token: users[0].accessToken, sort: 'createdAt' })
326 expect(body.total).to.equal(1)
327
328 const videos = body.data
329 expect(videos).to.be.an('array')
330 expect(videos).to.have.lengthOf(1)
331
332 expect(videos[0].name).to.equal('video server 1 added after follow')
333 })
334
335 it('Should remove the root subscription and not display the videos anymore', async function () {
336 this.timeout(30000)
337
338 await command.remove({ token: users[0].accessToken, uri: 'root_channel@' + servers[0].host })
339
340 await waitJobs(servers)
341
342 {
343 const body = await command.list({ token: users[0].accessToken, sort: 'createdAt' })
344 expect(body.total).to.equal(0)
345
346 const videos = body.data
347 expect(videos).to.be.an('array')
348 expect(videos).to.have.lengthOf(0)
349 }
350 })
351
352 it('Should correctly display public videos on server 1', async function () {
353 const { total, data } = await servers[0].videos.list()
354 expect(total).to.equal(5)
355
356 for (const video of data) {
357 expect(video.name).to.not.contain('1-3')
358 expect(video.name).to.not.contain('2-3')
359 expect(video.name).to.not.contain('video server 3 added after follow updated')
360 }
361 })
362 })
363
364 describe('Re-follow', function () {
365
366 it('Should follow user of server 3 again', async function () {
367 this.timeout(60000)
368
369 await command.add({ token: users[0].accessToken, targetUri: 'user3_channel@' + servers[2].host })
370
371 await waitJobs(servers)
372
373 {
374 const body = await servers[0].videos.listMySubscriptionVideos({ token: users[0].accessToken, sort: 'createdAt' })
375 expect(body.total).to.equal(3)
376
377 const videos = body.data
378 expect(videos).to.be.an('array')
379 expect(videos).to.have.lengthOf(3)
380
381 expect(videos[0].name).to.equal('video 1-3')
382 expect(videos[1].name).to.equal('video 2-3')
383 expect(videos[2].name).to.equal('video server 3 added after follow updated')
384 }
385
386 {
387 const { total, data } = await servers[0].videos.list()
388 expect(total).to.equal(5)
389
390 for (const video of data) {
391 expect(video.name).to.not.contain('1-3')
392 expect(video.name).to.not.contain('2-3')
393 expect(video.name).to.not.contain('video server 3 added after follow updated')
394 }
395 }
396 })
397
398 it('Should follow user channels of server 3 by root of server 3', async function () {
399 this.timeout(60000)
400
401 await servers[2].channels.create({ token: users[2].accessToken, attributes: { name: 'user3_channel2' } })
402
403 await servers[2].subscriptions.add({ token: servers[2].accessToken, targetUri: 'user3_channel@' + servers[2].host })
404 await servers[2].subscriptions.add({ token: servers[2].accessToken, targetUri: 'user3_channel2@' + servers[2].host })
405
406 await waitJobs(servers)
407 })
408 })
409
410 describe('Followers listing', function () {
411
412 it('Should list user 3 followers', async function () {
413 {
414 const { total, data } = await servers[2].accounts.listFollowers({
415 token: users[2].accessToken,
416 accountName: 'user3',
417 start: 0,
418 count: 5,
419 sort: 'createdAt'
420 })
421
422 expect(total).to.equal(3)
423 expect(data).to.have.lengthOf(3)
424
425 expect(data[0].following.host).to.equal(servers[2].host)
426 expect(data[0].following.name).to.equal('user3_channel')
427 expect(data[0].follower.host).to.equal(servers[0].host)
428 expect(data[0].follower.name).to.equal('user1')
429
430 expect(data[1].following.host).to.equal(servers[2].host)
431 expect(data[1].following.name).to.equal('user3_channel')
432 expect(data[1].follower.host).to.equal(servers[2].host)
433 expect(data[1].follower.name).to.equal('root')
434
435 expect(data[2].following.host).to.equal(servers[2].host)
436 expect(data[2].following.name).to.equal('user3_channel2')
437 expect(data[2].follower.host).to.equal(servers[2].host)
438 expect(data[2].follower.name).to.equal('root')
439 }
440
441 {
442 const { total, data } = await servers[2].accounts.listFollowers({
443 token: users[2].accessToken,
444 accountName: 'user3',
445 start: 0,
446 count: 1,
447 sort: '-createdAt'
448 })
449
450 expect(total).to.equal(3)
451 expect(data).to.have.lengthOf(1)
452
453 expect(data[0].following.host).to.equal(servers[2].host)
454 expect(data[0].following.name).to.equal('user3_channel2')
455 expect(data[0].follower.host).to.equal(servers[2].host)
456 expect(data[0].follower.name).to.equal('root')
457 }
458
459 {
460 const { total, data } = await servers[2].accounts.listFollowers({
461 token: users[2].accessToken,
462 accountName: 'user3',
463 start: 1,
464 count: 1,
465 sort: '-createdAt'
466 })
467
468 expect(total).to.equal(3)
469 expect(data).to.have.lengthOf(1)
470
471 expect(data[0].following.host).to.equal(servers[2].host)
472 expect(data[0].following.name).to.equal('user3_channel')
473 expect(data[0].follower.host).to.equal(servers[2].host)
474 expect(data[0].follower.name).to.equal('root')
475 }
476
477 {
478 const { total, data } = await servers[2].accounts.listFollowers({
479 token: users[2].accessToken,
480 accountName: 'user3',
481 search: 'user1',
482 sort: '-createdAt'
483 })
484
485 expect(total).to.equal(1)
486 expect(data).to.have.lengthOf(1)
487
488 expect(data[0].following.host).to.equal(servers[2].host)
489 expect(data[0].following.name).to.equal('user3_channel')
490 expect(data[0].follower.host).to.equal(servers[0].host)
491 expect(data[0].follower.name).to.equal('user1')
492 }
493 })
494
495 it('Should list user3_channel followers', async function () {
496 {
497 const { total, data } = await servers[2].channels.listFollowers({
498 token: users[2].accessToken,
499 channelName: 'user3_channel',
500 start: 0,
501 count: 5,
502 sort: 'createdAt'
503 })
504
505 expect(total).to.equal(2)
506 expect(data).to.have.lengthOf(2)
507
508 expect(data[0].following.host).to.equal(servers[2].host)
509 expect(data[0].following.name).to.equal('user3_channel')
510 expect(data[0].follower.host).to.equal(servers[0].host)
511 expect(data[0].follower.name).to.equal('user1')
512
513 expect(data[1].following.host).to.equal(servers[2].host)
514 expect(data[1].following.name).to.equal('user3_channel')
515 expect(data[1].follower.host).to.equal(servers[2].host)
516 expect(data[1].follower.name).to.equal('root')
517 }
518
519 {
520 const { total, data } = await servers[2].channels.listFollowers({
521 token: users[2].accessToken,
522 channelName: 'user3_channel',
523 start: 0,
524 count: 1,
525 sort: '-createdAt'
526 })
527
528 expect(total).to.equal(2)
529 expect(data).to.have.lengthOf(1)
530
531 expect(data[0].following.host).to.equal(servers[2].host)
532 expect(data[0].following.name).to.equal('user3_channel')
533 expect(data[0].follower.host).to.equal(servers[2].host)
534 expect(data[0].follower.name).to.equal('root')
535 }
536
537 {
538 const { total, data } = await servers[2].channels.listFollowers({
539 token: users[2].accessToken,
540 channelName: 'user3_channel',
541 start: 1,
542 count: 1,
543 sort: '-createdAt'
544 })
545
546 expect(total).to.equal(2)
547 expect(data).to.have.lengthOf(1)
548
549 expect(data[0].following.host).to.equal(servers[2].host)
550 expect(data[0].following.name).to.equal('user3_channel')
551 expect(data[0].follower.host).to.equal(servers[0].host)
552 expect(data[0].follower.name).to.equal('user1')
553 }
554
555 {
556 const { total, data } = await servers[2].channels.listFollowers({
557 token: users[2].accessToken,
558 channelName: 'user3_channel',
559 search: 'user1',
560 sort: '-createdAt'
561 })
562
563 expect(total).to.equal(1)
564 expect(data).to.have.lengthOf(1)
565
566 expect(data[0].following.host).to.equal(servers[2].host)
567 expect(data[0].following.name).to.equal('user3_channel')
568 expect(data[0].follower.host).to.equal(servers[0].host)
569 expect(data[0].follower.name).to.equal('user1')
570 }
571 })
572 })
573
574 describe('Subscription videos privacy', function () {
575
576 it('Should update video as internal and not see from remote server', async function () {
577 this.timeout(30000)
578
579 await servers[2].videos.update({ id: video3UUID, attributes: { name: 'internal', privacy: VideoPrivacy.INTERNAL } })
580 await waitJobs(servers)
581
582 {
583 const { data } = await servers[0].videos.listMySubscriptionVideos({ token: users[0].accessToken })
584 expect(data.find(v => v.name === 'internal')).to.not.exist
585 }
586 })
587
588 it('Should see internal from local user', async function () {
589 const { data } = await servers[2].videos.listMySubscriptionVideos({ token: servers[2].accessToken })
590 expect(data.find(v => v.name === 'internal')).to.exist
591 })
592
593 it('Should update video as private and not see from anyone server', async function () {
594 this.timeout(30000)
595
596 await servers[2].videos.update({ id: video3UUID, attributes: { name: 'private', privacy: VideoPrivacy.PRIVATE } })
597 await waitJobs(servers)
598
599 {
600 const { data } = await servers[0].videos.listMySubscriptionVideos({ token: users[0].accessToken })
601 expect(data.find(v => v.name === 'private')).to.not.exist
602 }
603
604 {
605 const { data } = await servers[2].videos.listMySubscriptionVideos({ token: servers[2].accessToken })
606 expect(data.find(v => v.name === 'private')).to.not.exist
607 }
608 })
609 })
610
611 after(async function () {
612 await cleanupTests(servers)
613 })
614})
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-16 20:01:36 +0000