Merge branch 'release/v1.0.0' into develop

[github/Chocobozzz/PeerTube.git] / server / tests / api / videos / video-blacklist-management.ts

diff --git a/server/tests/api/videos/video-blacklist-management.ts b/server/tests/api/videos/video-blacklist-management.ts
index db79784c2774e4b28dd78e7ac01c2b2d2520f115..7bf39dc9962fbb838ad23cee8c4290d63485b832 100644 (file)
--- a/server/tests/api/videos/video-blacklist-management.ts
+++ b/server/tests/api/videos/video-blacklist-management.ts
@@ -1,4 +1,4 @@
-/* tslint:disable:no-unused-expressions */
+/* tslint:disable:no-unused-expression */
 
 import * as chai from 'chai'
 import * as lodash from 'lodash'
@@ -6,31 +6,34 @@ import 'mocha'
 import {
   addVideoToBlacklist,
   flushAndRunMultipleServers,
-  flushTests,
   getBlacklistedVideosList,
+  getMyVideos,
   getSortedBlacklistedVideosList,
   getVideosList,
   killallServers,
   removeVideoFromBlacklist,
   ServerInfo,
   setAccessTokensToServers,
-  uploadVideo,
-  wait
+  updateVideoBlacklist,
+  uploadVideo
 } from '../../utils/index'
 import { doubleFollow } from '../../utils/server/follows'
+import { waitJobs } from '../../utils/server/jobs'
+import { VideoAbuse } from '../../../../shared/models/videos'
 
 const expect = chai.expect
 const orderBy = lodash.orderBy
 
 describe('Test video blacklist management', function () {
   let servers: ServerInfo[] = []
+  let videoId: number
 
   async function blacklistVideosOnServer (server: ServerInfo) {
     const res = await getVideosList(server.url)
 
     const videos = res.body.data
     for (let video of videos) {
-      await addVideoToBlacklist(server.url, server.accessToken, video.id)
+      await addVideoToBlacklist(server.url, server.accessToken, video.id, 'super reason')
     }
   }
 
@@ -51,7 +54,7 @@ describe('Test video blacklist management', function () {
     await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'My 2nd video', description: 'A video on server 2' })
 
     // Wait videos propagation, server 2 has transcoding enabled
-    await wait(15000)
+    await waitJobs(servers)
 
     // Blacklist the two videos on server 1
     await blacklistVideosOnServer(servers[0])
@@ -63,53 +66,85 @@ describe('Test video blacklist management', function () {
 
       expect(res.body.total).to.equal(2)
 
-      const videos = res.body.data
-      expect(videos).to.be.an('array')
-      expect(videos.length).to.equal(2)
+      const blacklistedVideos = res.body.data
+      expect(blacklistedVideos).to.be.an('array')
+      expect(blacklistedVideos.length).to.equal(2)
+
+      for (const blacklistedVideo of blacklistedVideos) {
+        expect(blacklistedVideo.reason).to.equal('super reason')
+        videoId = blacklistedVideo.video.id
+      }
     })
 
     it('Should get the correct sort when sorting by descending id', async function () {
       const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-id')
       expect(res.body.total).to.equal(2)
 
-      const videos = res.body.data
-      expect(videos).to.be.an('array')
-      expect(videos.length).to.equal(2)
+      const blacklistedVideos = res.body.data
+      expect(blacklistedVideos).to.be.an('array')
+      expect(blacklistedVideos.length).to.equal(2)
 
       const result = orderBy(res.body.data, [ 'id' ], [ 'desc' ])
 
-      expect(videos).to.deep.equal(result)
+      expect(blacklistedVideos).to.deep.equal(result)
     })
 
     it('Should get the correct sort when sorting by descending video name', async function () {
       const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-name')
       expect(res.body.total).to.equal(2)
 
-      const videos = res.body.data
-      expect(videos).to.be.an('array')
-      expect(videos.length).to.equal(2)
+      const blacklistedVideos = res.body.data
+      expect(blacklistedVideos).to.be.an('array')
+      expect(blacklistedVideos.length).to.equal(2)
 
       const result = orderBy(res.body.data, [ 'name' ], [ 'desc' ])
 
-      expect(videos).to.deep.equal(result)
+      expect(blacklistedVideos).to.deep.equal(result)
     })
 
     it('Should get the correct sort when sorting by ascending creation date', async function () {
       const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, 'createdAt')
       expect(res.body.total).to.equal(2)
 
-      const videos = res.body.data
-      expect(videos).to.be.an('array')
-      expect(videos.length).to.equal(2)
+      const blacklistedVideos = res.body.data
+      expect(blacklistedVideos).to.be.an('array')
+      expect(blacklistedVideos.length).to.equal(2)
 
       const result = orderBy(res.body.data, [ 'createdAt' ])
 
-      expect(videos).to.deep.equal(result)
+      expect(blacklistedVideos).to.deep.equal(result)
+    })
+  })
+
+  describe('When updating blacklisted videos', function () {
+    it('Should change the reason', async function () {
+      await updateVideoBlacklist(servers[0].url, servers[0].accessToken, videoId, 'my super reason updated')
+
+      const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-name')
+      const video = res.body.data.find(b => b.video.id === videoId)
+
+      expect(video.reason).to.equal('my super reason updated')
+    })
+  })
+
+  describe('When listing my videos', function () {
+    it('Should display blacklisted videos', async function () {
+      await blacklistVideosOnServer(servers[1])
+
+      const res = await getMyVideos(servers[1].url, servers[1].accessToken, 0, 5)
+
+      expect(res.body.total).to.equal(2)
+      expect(res.body.data).to.have.lengthOf(2)
+
+      for (const video of res.body.data) {
+        expect(video.blacklisted).to.be.true
+        expect(video.blacklistedReason).to.equal('super reason')
+      }
     })
   })
 
   describe('When removing a blacklisted video', function () {
-    let videoToRemove
+    let videoToRemove: VideoAbuse
     let blacklist = []
 
     it('Should not have any video in videos list on server 1', async function () {
@@ -126,7 +161,7 @@ describe('Test video blacklist management', function () {
       blacklist = res.body.data.slice(1)
 
       // Remove it
-      await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, videoToRemove.videoId)
+      await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, videoToRemove.video.id)
     })
 
     it('Should have the ex-blacklisted video in videos list on server 1', async function () {
@@ -137,8 +172,8 @@ describe('Test video blacklist management', function () {
       expect(videos).to.be.an('array')
       expect(videos.length).to.equal(1)
 
-      expect(videos[0].name).to.equal(videoToRemove.name)
-      expect(videos[0].id).to.equal(videoToRemove.videoId)
+      expect(videos[0].name).to.equal(videoToRemove.video.name)
+      expect(videos[0].id).to.equal(videoToRemove.video.id)
     })
 
     it('Should not have the ex-blacklisted video in videos blacklist list on server 1', async function () {
@@ -154,9 +189,5 @@ describe('Test video blacklist management', function () {
 
   after(async function () {
     killallServers(servers)
-
-    if (this['ok']) {
-      await flushTests()
-    }
   })
 })