1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
4 import * as chai from 'chai'
5 import request from 'supertest'
8 checkVideoFilesWereRemoved,
13 } from '@server/tests/shared'
14 import { buildAbsoluteFixturePath, wait } from '@shared/core-utils'
15 import { HttpStatusCode, VideoCommentThreadTree, VideoPrivacy } from '@shared/models'
18 createMultipleServers,
22 setAccessTokensToServers,
23 setDefaultAccountAvatar,
24 setDefaultChannelAvatar,
27 } from '@shared/server-commands'
29 const expect = chai.expect
31 describe('Test multiple servers', function () {
32 let servers: PeerTubeServer[] = []
35 let videoChannelId: number
37 before(async function () {
40 servers = await createMultipleServers(3)
42 // Get the access tokens
43 await setAccessTokensToServers(servers)
46 const videoChannel = {
47 name: 'super_channel_name',
48 displayName: 'my channel',
49 description: 'super channel'
51 await servers[0].channels.create({ attributes: videoChannel })
52 await setDefaultChannelAvatar(servers[0], videoChannel.name)
53 await setDefaultAccountAvatar(servers)
55 const { data } = await servers[0].channels.list({ start: 0, count: 1 })
56 videoChannelId = data[0].id
59 // Server 1 and server 2 follow each other
60 await doubleFollow(servers[0], servers[1])
61 // Server 1 and server 3 follow each other
62 await doubleFollow(servers[0], servers[2])
63 // Server 2 and server 3 follow each other
64 await doubleFollow(servers[1], servers[2])
67 it('Should not have videos for all servers', async function () {
68 for (const server of servers) {
69 const { data } = await server.videos.list()
70 expect(data).to.be.an('array')
71 expect(data.length).to.equal(0)
75 describe('Should upload the video and propagate on each server', function () {
76 it('Should upload the video on server 1 and propagate on each server', async function () {
80 name: 'my super name for server 1',
85 description: 'my super description for server 1',
86 support: 'my super support text for server 1',
87 originallyPublishedAt: '2019-02-10T13:38:14.449Z',
88 tags: [ 'tag1p1', 'tag2p1' ],
89 channelId: videoChannelId,
90 fixture: 'video_short1.webm'
92 await servers[0].videos.upload({ attributes })
94 await waitJobs(servers)
96 // All servers should have this video
97 let publishedAt: string = null
98 for (const server of servers) {
99 const isLocal = server.port === servers[0].port
100 const checkAttributes = {
101 name: 'my super name for server 1',
106 description: 'my super description for server 1',
107 support: 'my super support text for server 1',
108 originallyPublishedAt: '2019-02-10T13:38:14.449Z',
111 host: 'localhost:' + servers[0].port
116 tags: [ 'tag1p1', 'tag2p1' ],
117 privacy: VideoPrivacy.PUBLIC,
118 commentsEnabled: true,
119 downloadEnabled: true,
121 displayName: 'my channel',
122 name: 'super_channel_name',
123 description: 'super channel',
126 fixture: 'video_short1.webm',
135 const { data } = await server.videos.list()
136 expect(data).to.be.an('array')
137 expect(data.length).to.equal(1)
138 const video = data[0]
140 await completeVideoCheck(server, video, checkAttributes)
141 publishedAt = video.publishedAt as string
143 expect(video.channel.avatars).to.have.lengthOf(2)
144 expect(video.account.avatars).to.have.lengthOf(2)
146 for (const image of [ ...video.channel.avatars, ...video.account.avatars ]) {
147 expect(image.createdAt).to.exist
148 expect(image.updatedAt).to.exist
149 expect(image.width).to.be.above(20).and.below(1000)
150 expect(image.path).to.exist
152 await makeGetRequest({
155 expectedStatus: HttpStatusCode.OK_200
161 it('Should upload the video on server 2 and propagate on each server', async function () {
166 password: 'super_password'
168 await servers[1].users.create({ username: user.username, password: user.password })
169 const userAccessToken = await servers[1].login.getAccessToken(user)
172 name: 'my super name for server 2',
177 description: 'my super description for server 2',
178 support: 'my super support text for server 2',
179 tags: [ 'tag1p2', 'tag2p2', 'tag3p2' ],
180 fixture: 'video_short2.webm',
181 thumbnailfile: 'thumbnail.jpg',
182 previewfile: 'preview.jpg'
184 await servers[1].videos.upload({ token: userAccessToken, attributes, mode: 'resumable' })
187 await waitJobs(servers)
189 // All servers should have this video
190 for (const server of servers) {
191 const isLocal = server.url === 'http://localhost:' + servers[1].port
192 const checkAttributes = {
193 name: 'my super name for server 2',
198 description: 'my super description for server 2',
199 support: 'my super support text for server 2',
202 host: 'localhost:' + servers[1].port
205 commentsEnabled: true,
206 downloadEnabled: true,
208 tags: [ 'tag1p2', 'tag2p2', 'tag3p2' ],
209 privacy: VideoPrivacy.PUBLIC,
211 displayName: 'Main user1 channel',
212 name: 'user1_channel',
213 description: 'super channel',
216 fixture: 'video_short2.webm',
235 thumbnailfile: 'thumbnail',
236 previewfile: 'preview'
239 const { data } = await server.videos.list()
240 expect(data).to.be.an('array')
241 expect(data.length).to.equal(2)
242 const video = data[1]
244 await completeVideoCheck(server, video, checkAttributes)
248 it('Should upload two videos on server 3 and propagate on each server', async function () {
253 name: 'my super name for server 3',
258 description: 'my super description for server 3',
259 support: 'my super support text for server 3',
261 fixture: 'video_short3.webm'
263 await servers[2].videos.upload({ attributes })
268 name: 'my super name for server 3-2',
273 description: 'my super description for server 3-2',
274 support: 'my super support text for server 3-2',
275 tags: [ 'tag2p3', 'tag3p3', 'tag4p3' ],
276 fixture: 'video_short.webm'
278 await servers[2].videos.upload({ attributes })
281 await waitJobs(servers)
283 // All servers should have this video
284 for (const server of servers) {
285 const isLocal = server.url === 'http://localhost:' + servers[2].port
286 const { data } = await server.videos.list()
288 expect(data).to.be.an('array')
289 expect(data.length).to.equal(4)
291 // We not sure about the order of the two last uploads
294 if (data[2].name === 'my super name for server 3') {
302 const checkAttributesVideo1 = {
303 name: 'my super name for server 3',
308 description: 'my super description for server 3',
309 support: 'my super support text for server 3',
312 host: 'localhost:' + servers[2].port
316 commentsEnabled: true,
317 downloadEnabled: true,
319 privacy: VideoPrivacy.PUBLIC,
321 displayName: 'Main root channel',
322 name: 'root_channel',
326 fixture: 'video_short3.webm',
334 await completeVideoCheck(server, video1, checkAttributesVideo1)
336 const checkAttributesVideo2 = {
337 name: 'my super name for server 3-2',
342 description: 'my super description for server 3-2',
343 support: 'my super support text for server 3-2',
346 host: 'localhost:' + servers[2].port
348 commentsEnabled: true,
349 downloadEnabled: true,
352 tags: [ 'tag2p3', 'tag3p3', 'tag4p3' ],
353 privacy: VideoPrivacy.PUBLIC,
355 displayName: 'Main root channel',
356 name: 'root_channel',
360 fixture: 'video_short.webm',
368 await completeVideoCheck(server, video2, checkAttributesVideo2)
373 describe('It should list local videos', function () {
374 it('Should list only local videos on server 1', async function () {
375 const { data, total } = await servers[0].videos.list({ isLocal: true })
377 expect(total).to.equal(1)
378 expect(data).to.be.an('array')
379 expect(data.length).to.equal(1)
380 expect(data[0].name).to.equal('my super name for server 1')
383 it('Should list only local videos on server 2', async function () {
384 const { data, total } = await servers[1].videos.list({ isLocal: true })
386 expect(total).to.equal(1)
387 expect(data).to.be.an('array')
388 expect(data.length).to.equal(1)
389 expect(data[0].name).to.equal('my super name for server 2')
392 it('Should list only local videos on server 3', async function () {
393 const { data, total } = await servers[2].videos.list({ isLocal: true })
395 expect(total).to.equal(2)
396 expect(data).to.be.an('array')
397 expect(data.length).to.equal(2)
398 expect(data[0].name).to.equal('my super name for server 3')
399 expect(data[1].name).to.equal('my super name for server 3-2')
403 describe('Should seed the uploaded video', function () {
404 it('Should add the file 1 by asking server 3', async function () {
407 const { data } = await servers[2].videos.list()
409 const video = data[0]
410 toRemove.push(data[2])
411 toRemove.push(data[3])
413 const videoDetails = await servers[2].videos.get({ id: video.id })
414 const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri, true)
415 expect(torrent.files).to.be.an('array')
416 expect(torrent.files.length).to.equal(1)
417 expect(torrent.files[0].path).to.exist.and.to.not.equal('')
420 it('Should add the file 2 by asking server 1', async function () {
423 const { data } = await servers[0].videos.list()
425 const video = data[1]
426 const videoDetails = await servers[0].videos.get({ id: video.id })
428 const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri, true)
429 expect(torrent.files).to.be.an('array')
430 expect(torrent.files.length).to.equal(1)
431 expect(torrent.files[0].path).to.exist.and.to.not.equal('')
434 it('Should add the file 3 by asking server 2', async function () {
437 const { data } = await servers[1].videos.list()
439 const video = data[2]
440 const videoDetails = await servers[1].videos.get({ id: video.id })
442 const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri, true)
443 expect(torrent.files).to.be.an('array')
444 expect(torrent.files.length).to.equal(1)
445 expect(torrent.files[0].path).to.exist.and.to.not.equal('')
448 it('Should add the file 3-2 by asking server 1', async function () {
451 const { data } = await servers[0].videos.list()
453 const video = data[3]
454 const videoDetails = await servers[0].videos.get({ id: video.id })
456 const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri)
457 expect(torrent.files).to.be.an('array')
458 expect(torrent.files.length).to.equal(1)
459 expect(torrent.files[0].path).to.exist.and.to.not.equal('')
462 it('Should add the file 2 in 360p by asking server 1', async function () {
465 const { data } = await servers[0].videos.list()
467 const video = data.find(v => v.name === 'my super name for server 2')
468 const videoDetails = await servers[0].videos.get({ id: video.id })
470 const file = videoDetails.files.find(f => f.resolution.id === 360)
471 expect(file).not.to.be.undefined
473 const torrent = await webtorrentAdd(file.magnetUri)
474 expect(torrent.files).to.be.an('array')
475 expect(torrent.files.length).to.equal(1)
476 expect(torrent.files[0].path).to.exist.and.to.not.equal('')
480 describe('Should update video views, likes and dislikes', function () {
481 let localVideosServer3 = []
482 let remoteVideosServer1 = []
483 let remoteVideosServer2 = []
484 let remoteVideosServer3 = []
486 before(async function () {
488 const { data } = await servers[0].videos.list()
489 remoteVideosServer1 = data.filter(video => video.isLocal === false).map(video => video.uuid)
493 const { data } = await servers[1].videos.list()
494 remoteVideosServer2 = data.filter(video => video.isLocal === false).map(video => video.uuid)
498 const { data } = await servers[2].videos.list()
499 localVideosServer3 = data.filter(video => video.isLocal === true).map(video => video.uuid)
500 remoteVideosServer3 = data.filter(video => video.isLocal === false).map(video => video.uuid)
504 it('Should view multiple videos on owned servers', async function () {
507 await servers[2].videos.view({ id: localVideosServer3[0] })
510 await servers[2].videos.view({ id: localVideosServer3[0] })
511 await servers[2].videos.view({ id: localVideosServer3[1] })
515 await servers[2].videos.view({ id: localVideosServer3[0] })
516 await servers[2].videos.view({ id: localVideosServer3[0] })
518 await waitJobs(servers)
520 // Wait the repeatable job
523 await waitJobs(servers)
525 for (const server of servers) {
526 const { data } = await server.videos.list()
528 const video0 = data.find(v => v.uuid === localVideosServer3[0])
529 const video1 = data.find(v => v.uuid === localVideosServer3[1])
531 expect(video0.views).to.equal(3)
532 expect(video1.views).to.equal(1)
536 it('Should view multiple videos on each servers', async function () {
539 const tasks: Promise<any>[] = []
540 tasks.push(servers[0].videos.view({ id: remoteVideosServer1[0] }))
541 tasks.push(servers[1].videos.view({ id: remoteVideosServer2[0] }))
542 tasks.push(servers[1].videos.view({ id: remoteVideosServer2[0] }))
543 tasks.push(servers[2].videos.view({ id: remoteVideosServer3[0] }))
544 tasks.push(servers[2].videos.view({ id: remoteVideosServer3[1] }))
545 tasks.push(servers[2].videos.view({ id: remoteVideosServer3[1] }))
546 tasks.push(servers[2].videos.view({ id: remoteVideosServer3[1] }))
547 tasks.push(servers[2].videos.view({ id: localVideosServer3[1] }))
548 tasks.push(servers[2].videos.view({ id: localVideosServer3[1] }))
549 tasks.push(servers[2].videos.view({ id: localVideosServer3[1] }))
551 await Promise.all(tasks)
553 await waitJobs(servers)
555 // Wait the repeatable job
558 await waitJobs(servers)
560 let baseVideos = null
562 for (const server of servers) {
563 const { data } = await server.videos.list()
565 // Initialize base videos for future comparisons
566 if (baseVideos === null) {
571 for (const baseVideo of baseVideos) {
572 const sameVideo = data.find(video => video.name === baseVideo.name)
573 expect(baseVideo.views).to.equal(sameVideo.views)
578 it('Should like and dislikes videos on different services', async function () {
581 await servers[0].videos.rate({ id: remoteVideosServer1[0], rating: 'like' })
583 await servers[0].videos.rate({ id: remoteVideosServer1[0], rating: 'dislike' })
585 await servers[0].videos.rate({ id: remoteVideosServer1[0], rating: 'like' })
586 await servers[2].videos.rate({ id: localVideosServer3[1], rating: 'like' })
588 await servers[2].videos.rate({ id: localVideosServer3[1], rating: 'dislike' })
589 await servers[2].videos.rate({ id: remoteVideosServer3[1], rating: 'dislike' })
591 await servers[2].videos.rate({ id: remoteVideosServer3[0], rating: 'like' })
593 await waitJobs(servers)
595 await waitJobs(servers)
597 let baseVideos = null
598 for (const server of servers) {
599 const { data } = await server.videos.list()
601 // Initialize base videos for future comparisons
602 if (baseVideos === null) {
607 for (const baseVideo of baseVideos) {
608 const sameVideo = data.find(video => video.name === baseVideo.name)
609 expect(baseVideo.likes).to.equal(sameVideo.likes, `Likes of ${sameVideo.uuid} do not correspond`)
610 expect(baseVideo.dislikes).to.equal(sameVideo.dislikes, `Dislikes of ${sameVideo.uuid} do not correspond`)
616 describe('Should manipulate these videos', function () {
617 let updatedAtMin: Date
619 it('Should update video 3', async function () {
623 name: 'my super video updated',
628 description: 'my super description updated',
629 support: 'my super support text updated',
630 tags: [ 'tag_up_1', 'tag_up_2' ],
631 thumbnailfile: 'thumbnail.jpg',
632 originallyPublishedAt: '2019-02-11T13:38:14.449Z',
633 previewfile: 'preview.jpg'
636 updatedAtMin = new Date()
637 await servers[2].videos.update({ id: toRemove[0].id, attributes })
639 await waitJobs(servers)
642 it('Should have the video 3 updated on each server', async function () {
645 for (const server of servers) {
646 const { data } = await server.videos.list()
648 const videoUpdated = data.find(video => video.name === 'my super video updated')
649 expect(!!videoUpdated).to.be.true
651 expect(new Date(videoUpdated.updatedAt)).to.be.greaterThan(updatedAtMin)
653 const isLocal = server.url === 'http://localhost:' + servers[2].port
654 const checkAttributes = {
655 name: 'my super video updated',
660 description: 'my super description updated',
661 support: 'my super support text updated',
662 originallyPublishedAt: '2019-02-11T13:38:14.449Z',
665 host: 'localhost:' + servers[2].port
669 commentsEnabled: true,
670 downloadEnabled: true,
671 tags: [ 'tag_up_1', 'tag_up_2' ],
672 privacy: VideoPrivacy.PUBLIC,
674 displayName: 'Main root channel',
675 name: 'root_channel',
679 fixture: 'video_short3.webm',
686 thumbnailfile: 'thumbnail',
687 previewfile: 'preview'
689 await completeVideoCheck(server, videoUpdated, checkAttributes)
693 it('Should only update thumbnail and update updatedAt attribute', async function () {
697 thumbnailfile: 'thumbnail.jpg'
700 updatedAtMin = new Date()
701 await servers[2].videos.update({ id: toRemove[0].id, attributes })
703 await waitJobs(servers)
705 for (const server of servers) {
706 const { data } = await server.videos.list()
708 const videoUpdated = data.find(video => video.name === 'my super video updated')
709 expect(new Date(videoUpdated.updatedAt)).to.be.greaterThan(updatedAtMin)
713 it('Should remove the videos 3 and 3-2 by asking server 3 and correctly delete files', async function () {
716 for (const id of [ toRemove[0].id, toRemove[1].id ]) {
717 await saveVideoInServers(servers, id)
719 await servers[2].videos.remove({ id })
721 await waitJobs(servers)
723 for (const server of servers) {
724 await checkVideoFilesWereRemoved({ server, video: server.store.videoDetails })
729 it('Should have videos 1 and 3 on each server', async function () {
730 for (const server of servers) {
731 const { data } = await server.videos.list()
733 expect(data).to.be.an('array')
734 expect(data.length).to.equal(2)
735 expect(data[0].name).not.to.equal(data[1].name)
736 expect(data[0].name).not.to.equal(toRemove[0].name)
737 expect(data[1].name).not.to.equal(toRemove[0].name)
738 expect(data[0].name).not.to.equal(toRemove[1].name)
739 expect(data[1].name).not.to.equal(toRemove[1].name)
741 videoUUID = data.find(video => video.name === 'my super name for server 1').uuid
745 it('Should get the same video by UUID on each server', async function () {
747 for (const server of servers) {
748 const video = await server.videos.get({ id: videoUUID })
750 if (baseVideo === null) {
755 expect(baseVideo.name).to.equal(video.name)
756 expect(baseVideo.uuid).to.equal(video.uuid)
757 expect(baseVideo.category.id).to.equal(video.category.id)
758 expect(baseVideo.language.id).to.equal(video.language.id)
759 expect(baseVideo.licence.id).to.equal(video.licence.id)
760 expect(baseVideo.nsfw).to.equal(video.nsfw)
761 expect(baseVideo.account.name).to.equal(video.account.name)
762 expect(baseVideo.account.displayName).to.equal(video.account.displayName)
763 expect(baseVideo.account.url).to.equal(video.account.url)
764 expect(baseVideo.account.host).to.equal(video.account.host)
765 expect(baseVideo.tags).to.deep.equal(video.tags)
769 it('Should get the preview from each server', async function () {
770 for (const server of servers) {
771 const video = await server.videos.get({ id: videoUUID })
773 await testImage(server.url, 'video_short1-preview.webm', video.previewPath)
778 describe('Should comment these videos', function () {
779 let childOfFirstChild: VideoCommentThreadTree
781 it('Should add comment (threads and replies)', async function () {
785 const text = 'my super first comment'
786 await servers[0].comments.createThread({ videoId: videoUUID, text })
790 const text = 'my super second comment'
791 await servers[2].comments.createThread({ videoId: videoUUID, text })
794 await waitJobs(servers)
797 const threadId = await servers[1].comments.findCommentId({ videoId: videoUUID, text: 'my super first comment' })
799 const text = 'my super answer to thread 1'
800 await servers[1].comments.addReply({ videoId: videoUUID, toCommentId: threadId, text })
803 await waitJobs(servers)
806 const threadId = await servers[2].comments.findCommentId({ videoId: videoUUID, text: 'my super first comment' })
808 const body = await servers[2].comments.getThread({ videoId: videoUUID, threadId })
809 const childCommentId = body.children[0].comment.id
811 const text3 = 'my second answer to thread 1'
812 await servers[2].comments.addReply({ videoId: videoUUID, toCommentId: threadId, text: text3 })
814 const text2 = 'my super answer to answer of thread 1'
815 await servers[2].comments.addReply({ videoId: videoUUID, toCommentId: childCommentId, text: text2 })
818 await waitJobs(servers)
821 it('Should have these threads', async function () {
822 for (const server of servers) {
823 const body = await server.comments.listThreads({ videoId: videoUUID })
825 expect(body.total).to.equal(2)
826 expect(body.data).to.be.an('array')
827 expect(body.data).to.have.lengthOf(2)
830 const comment = body.data.find(c => c.text === 'my super first comment')
831 expect(comment).to.not.be.undefined
832 expect(comment.inReplyToCommentId).to.be.null
833 expect(comment.account.name).to.equal('root')
834 expect(comment.account.host).to.equal('localhost:' + servers[0].port)
835 expect(comment.totalReplies).to.equal(3)
836 expect(dateIsValid(comment.createdAt as string)).to.be.true
837 expect(dateIsValid(comment.updatedAt as string)).to.be.true
841 const comment = body.data.find(c => c.text === 'my super second comment')
842 expect(comment).to.not.be.undefined
843 expect(comment.inReplyToCommentId).to.be.null
844 expect(comment.account.name).to.equal('root')
845 expect(comment.account.host).to.equal('localhost:' + servers[2].port)
846 expect(comment.totalReplies).to.equal(0)
847 expect(dateIsValid(comment.createdAt as string)).to.be.true
848 expect(dateIsValid(comment.updatedAt as string)).to.be.true
853 it('Should have these comments', async function () {
854 for (const server of servers) {
855 const body = await server.comments.listThreads({ videoId: videoUUID })
856 const threadId = body.data.find(c => c.text === 'my super first comment').id
858 const tree = await server.comments.getThread({ videoId: videoUUID, threadId })
860 expect(tree.comment.text).equal('my super first comment')
861 expect(tree.comment.account.name).equal('root')
862 expect(tree.comment.account.host).equal('localhost:' + servers[0].port)
863 expect(tree.children).to.have.lengthOf(2)
865 const firstChild = tree.children[0]
866 expect(firstChild.comment.text).to.equal('my super answer to thread 1')
867 expect(firstChild.comment.account.name).equal('root')
868 expect(firstChild.comment.account.host).equal('localhost:' + servers[1].port)
869 expect(firstChild.children).to.have.lengthOf(1)
871 childOfFirstChild = firstChild.children[0]
872 expect(childOfFirstChild.comment.text).to.equal('my super answer to answer of thread 1')
873 expect(childOfFirstChild.comment.account.name).equal('root')
874 expect(childOfFirstChild.comment.account.host).equal('localhost:' + servers[2].port)
875 expect(childOfFirstChild.children).to.have.lengthOf(0)
877 const secondChild = tree.children[1]
878 expect(secondChild.comment.text).to.equal('my second answer to thread 1')
879 expect(secondChild.comment.account.name).equal('root')
880 expect(secondChild.comment.account.host).equal('localhost:' + servers[2].port)
881 expect(secondChild.children).to.have.lengthOf(0)
885 it('Should delete a reply', async function () {
888 await servers[2].comments.delete({ videoId: videoUUID, commentId: childOfFirstChild.comment.id })
890 await waitJobs(servers)
893 it('Should have this comment marked as deleted', async function () {
894 for (const server of servers) {
895 const { data } = await server.comments.listThreads({ videoId: videoUUID })
896 const threadId = data.find(c => c.text === 'my super first comment').id
898 const tree = await server.comments.getThread({ videoId: videoUUID, threadId })
899 expect(tree.comment.text).equal('my super first comment')
901 const firstChild = tree.children[0]
902 expect(firstChild.comment.text).to.equal('my super answer to thread 1')
903 expect(firstChild.children).to.have.lengthOf(1)
905 const deletedComment = firstChild.children[0].comment
906 expect(deletedComment.isDeleted).to.be.true
907 expect(deletedComment.deletedAt).to.not.be.null
908 expect(deletedComment.account).to.be.null
909 expect(deletedComment.text).to.equal('')
911 const secondChild = tree.children[1]
912 expect(secondChild.comment.text).to.equal('my second answer to thread 1')
916 it('Should delete the thread comments', async function () {
919 const { data } = await servers[0].comments.listThreads({ videoId: videoUUID })
920 const commentId = data.find(c => c.text === 'my super first comment').id
921 await servers[0].comments.delete({ videoId: videoUUID, commentId })
923 await waitJobs(servers)
926 it('Should have the threads marked as deleted on other servers too', async function () {
927 for (const server of servers) {
928 const body = await server.comments.listThreads({ videoId: videoUUID })
930 expect(body.total).to.equal(2)
931 expect(body.data).to.be.an('array')
932 expect(body.data).to.have.lengthOf(2)
935 const comment = body.data[0]
936 expect(comment).to.not.be.undefined
937 expect(comment.inReplyToCommentId).to.be.null
938 expect(comment.account.name).to.equal('root')
939 expect(comment.account.host).to.equal('localhost:' + servers[2].port)
940 expect(comment.totalReplies).to.equal(0)
941 expect(dateIsValid(comment.createdAt as string)).to.be.true
942 expect(dateIsValid(comment.updatedAt as string)).to.be.true
946 const deletedComment = body.data[1]
947 expect(deletedComment).to.not.be.undefined
948 expect(deletedComment.isDeleted).to.be.true
949 expect(deletedComment.deletedAt).to.not.be.null
950 expect(deletedComment.text).to.equal('')
951 expect(deletedComment.inReplyToCommentId).to.be.null
952 expect(deletedComment.account).to.be.null
953 expect(deletedComment.totalReplies).to.equal(2)
954 expect(dateIsValid(deletedComment.createdAt as string)).to.be.true
955 expect(dateIsValid(deletedComment.updatedAt as string)).to.be.true
956 expect(dateIsValid(deletedComment.deletedAt as string)).to.be.true
961 it('Should delete a remote thread by the origin server', async function () {
964 const { data } = await servers[0].comments.listThreads({ videoId: videoUUID })
965 const commentId = data.find(c => c.text === 'my super second comment').id
966 await servers[0].comments.delete({ videoId: videoUUID, commentId })
968 await waitJobs(servers)
971 it('Should have the threads marked as deleted on other servers too', async function () {
972 for (const server of servers) {
973 const body = await server.comments.listThreads({ videoId: videoUUID })
975 expect(body.total).to.equal(2)
976 expect(body.data).to.have.lengthOf(2)
979 const comment = body.data[0]
980 expect(comment.text).to.equal('')
981 expect(comment.isDeleted).to.be.true
982 expect(comment.createdAt).to.not.be.null
983 expect(comment.deletedAt).to.not.be.null
984 expect(comment.account).to.be.null
985 expect(comment.totalReplies).to.equal(0)
989 const comment = body.data[1]
990 expect(comment.text).to.equal('')
991 expect(comment.isDeleted).to.be.true
992 expect(comment.createdAt).to.not.be.null
993 expect(comment.deletedAt).to.not.be.null
994 expect(comment.account).to.be.null
995 expect(comment.totalReplies).to.equal(2)
1000 it('Should disable comments and download', async function () {
1003 const attributes = {
1004 commentsEnabled: false,
1005 downloadEnabled: false
1008 await servers[0].videos.update({ id: videoUUID, attributes })
1010 await waitJobs(servers)
1012 for (const server of servers) {
1013 const video = await server.videos.get({ id: videoUUID })
1014 expect(video.commentsEnabled).to.be.false
1015 expect(video.downloadEnabled).to.be.false
1017 const text = 'my super forbidden comment'
1018 await server.comments.createThread({ videoId: videoUUID, text, expectedStatus: HttpStatusCode.CONFLICT_409 })
1023 describe('With minimum parameters', function () {
1024 it('Should upload and propagate the video', async function () {
1027 const path = '/api/v1/videos/upload'
1029 const req = request(servers[1].url)
1031 .set('Accept', 'application/json')
1032 .set('Authorization', 'Bearer ' + servers[1].accessToken)
1033 .field('name', 'minimum parameters')
1034 .field('privacy', '1')
1035 .field('channelId', '1')
1037 await req.attach('videofile', buildAbsoluteFixturePath('video_short.webm'))
1038 .expect(HttpStatusCode.OK_200)
1040 await waitJobs(servers)
1042 for (const server of servers) {
1043 const { data } = await server.videos.list()
1044 const video = data.find(v => v.name === 'minimum parameters')
1046 const isLocal = server.url === 'http://localhost:' + servers[1].port
1047 const checkAttributes = {
1048 name: 'minimum parameters',
1057 host: 'localhost:' + servers[1].port
1061 commentsEnabled: true,
1062 downloadEnabled: true,
1064 privacy: VideoPrivacy.PUBLIC,
1066 displayName: 'Main root channel',
1067 name: 'root_channel',
1071 fixture: 'video_short.webm',
1091 await completeVideoCheck(server, video, checkAttributes)
1096 describe('TMP directory', function () {
1097 it('Should have an empty tmp directory', async function () {
1098 for (const server of servers) {
1099 await checkTmpIsEmpty(server)
1104 after(async function () {
1105 await cleanupTests(servers)