Add blacklist reason field

4 files changed, 203 insertions, 34 deletions

diff --git a/server/tests/api/check-params/video-blacklist.ts b/server/tests/api/check-params/video-blacklist.ts
index 6cd13d23f..415474718 100644
--- a/server/tests/api/check-params/video-blacklist.ts
+++ b/server/tests/api/check-params/video-blacklist.ts
@@ -3,13 +3,24 @@
 import 'mocha'
 
 import {
-  createUser, flushTests, getBlacklistedVideosList, killallServers, makePostBodyRequest, removeVideoFromBlacklist, runServer,
-  ServerInfo, setAccessTokensToServers, uploadVideo, userLogin
+  createUser,
+  flushTests,
+  getBlacklistedVideosList,
+  killallServers,
+  makePostBodyRequest,
+  makePutBodyRequest,
+  removeVideoFromBlacklist,
+  runServer,
+  ServerInfo,
+  setAccessTokensToServers,
+  uploadVideo,
+  userLogin
 } from '../../utils'
 import { checkBadCountPagination, checkBadSortPagination, checkBadStartPagination } from '../../utils/requests/check-api-params'
 
 describe('Test video blacklist API validators', function () {
   let server: ServerInfo
+  let notBlacklistedVideoId: number
   let userAccessToken = ''
 
   // ---------------------------------------------------------------
@@ -28,8 +39,15 @@ describe('Test video blacklist API validators', function () {
     await createUser(server.url, server.accessToken, username, password)
     userAccessToken = await userLogin(server, { username, password })
 
-    const res = await uploadVideo(server.url, server.accessToken, {})
-    server.video = res.body.video
+    {
+      const res = await uploadVideo(server.url, server.accessToken, {})
+      server.video = res.body.video
+    }
+
+    {
+      const res = await uploadVideo(server.url, server.accessToken, {})
+      notBlacklistedVideoId = res.body.video.uuid
+    }
   })
 
   describe('When adding a video in blacklist', function () {
@@ -59,20 +77,70 @@ describe('Test video blacklist API validators', function () {
       await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields, statusCodeExpected: 403 })
     })
 
-    it('Should fail with a local video', async function () {
-      const path = basePath + server.video.id + '/blacklist'
+    it('Should fail with an invalid reason', async function () {
+      const path = basePath + server.video.uuid + '/blacklist'
+      const fields = { reason: 'a'.repeat(305) }
+
+      await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
+    })
+
+    it('Should succeed with the correct params', async function () {
+      const path = basePath + server.video.uuid + '/blacklist'
+      const fields = { }
+
+      await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
+    })
+  })
+
+  describe('When updating a video in blacklist', function () {
+    const basePath = '/api/v1/videos/'
+
+    it('Should fail with a wrong video', async function () {
+      const wrongPath = '/api/v1/videos/blabla/blacklist'
+      const fields = {}
+      await makePutBodyRequest({ url: server.url, path: wrongPath, token: server.accessToken, fields })
+    })
+
+    it('Should fail with a video not blacklisted', async function () {
+      const path = '/api/v1/videos/' + notBlacklistedVideoId + '/blacklist'
       const fields = {}
-      await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 403 })
+      await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 404 })
+    })
+
+    it('Should fail with a non authenticated user', async function () {
+      const path = basePath + server.video + '/blacklist'
+      const fields = {}
+      await makePutBodyRequest({ url: server.url, path, token: 'hello', fields, statusCodeExpected: 401 })
+    })
+
+    it('Should fail with a non admin user', async function () {
+      const path = basePath + server.video + '/blacklist'
+      const fields = {}
+      await makePutBodyRequest({ url: server.url, path, token: userAccessToken, fields, statusCodeExpected: 403 })
+    })
+
+    it('Should fail with an invalid reason', async function () {
+      const path = basePath + server.video.uuid + '/blacklist'
+      const fields = { reason: 'a'.repeat(305) }
+
+      await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
+    })
+
+    it('Should succeed with the correct params', async function () {
+      const path = basePath + server.video.uuid + '/blacklist'
+      const fields = { reason: 'hello' }
+
+      await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
     })
   })
 
   describe('When removing a video in blacklist', function () {
     it('Should fail with a non authenticated user', async function () {
-      await removeVideoFromBlacklist(server.url, 'fake token', server.video.id, 401)
+      await removeVideoFromBlacklist(server.url, 'fake token', server.video.uuid, 401)
     })
 
     it('Should fail with a non admin user', async function () {
-      await removeVideoFromBlacklist(server.url, userAccessToken, server.video.id, 403)
+      await removeVideoFromBlacklist(server.url, userAccessToken, server.video.uuid, 403)
     })
 
     it('Should fail with an incorrect id', async function () {
@@ -81,7 +149,11 @@ describe('Test video blacklist API validators', function () {
 
     it('Should fail with a not blacklisted video', async function () {
       // The video was not added to the blacklist so it should fail
-      await removeVideoFromBlacklist(server.url, server.accessToken, server.video.id, 404)
+      await removeVideoFromBlacklist(server.url, server.accessToken, notBlacklistedVideoId, 404)
+    })
+
+    it('Should succeed with the correct params', async function () {
+      await removeVideoFromBlacklist(server.url, server.accessToken, server.video.uuid, 204)
     })
   })
 
diff --git a/server/tests/api/server/email.ts b/server/tests/api/server/email.ts
index 65d6a759f..db937f288 100644
--- a/server/tests/api/server/email.ts
+++ b/server/tests/api/server/email.ts
@@ -3,9 +3,10 @@
 import * as chai from 'chai'
 import 'mocha'
 import {
+  addVideoToBlacklist,
   askResetPassword,
   blockUser,
-  createUser,
+  createUser, removeVideoFromBlacklist,
   reportVideoAbuse,
   resetPassword,
   runServer,
@@ -22,7 +23,9 @@ const expect = chai.expect
 describe('Test emails', function () {
   let server: ServerInfo
   let userId: number
+  let userAccessToken: string
   let videoUUID: string
+  let videoUserUUID: string
   let verificationString: string
   const emails: object[] = []
   const user = {
@@ -48,6 +51,16 @@ describe('Test emails', function () {
     {
       const res = await createUser(server.url, server.accessToken, user.username, user.password)
       userId = res.body.user.id
+
+      userAccessToken = await userLogin(server, user)
+    }
+
+    {
+      const attributes = {
+        name: 'my super user video'
+      }
+      const res = await uploadVideo(server.url, userAccessToken, attributes)
+      videoUserUUID = res.body.video.uuid
     }
 
     {
@@ -158,6 +171,42 @@ describe('Test emails', function () {
     })
   })
 
+  describe('When blacklisting a video', function () {
+    it('Should send the notification email', async function () {
+      this.timeout(10000)
+
+      const reason = 'my super reason'
+      await addVideoToBlacklist(server.url, server.accessToken, videoUserUUID, reason)
+
+      await waitJobs(server)
+      expect(emails).to.have.lengthOf(5)
+
+      const email = emails[4]
+
+      expect(email['from'][0]['address']).equal('test-admin@localhost')
+      expect(email['to'][0]['address']).equal('user_1@example.com')
+      expect(email['subject']).contains(' blacklisted')
+      expect(email['text']).contains('my super user video')
+      expect(email['text']).contains('my super reason')
+    })
+
+    it('Should send the notification email', async function () {
+      this.timeout(10000)
+
+      await removeVideoFromBlacklist(server.url, server.accessToken, videoUserUUID)
+
+      await waitJobs(server)
+      expect(emails).to.have.lengthOf(6)
+
+      const email = emails[5]
+
+      expect(email['from'][0]['address']).equal('test-admin@localhost')
+      expect(email['to'][0]['address']).equal('user_1@example.com')
+      expect(email['subject']).contains(' unblacklisted')
+      expect(email['text']).contains('my super user video')
+    })
+  })
+
   after(async function () {
     killallServers([ server ])
   })
diff --git a/server/tests/api/videos/video-blacklist-management.ts b/server/tests/api/videos/video-blacklist-management.ts
index 4d1a06436..7bf39dc99 100644
--- 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'
@@ -7,29 +7,33 @@ import {
   addVideoToBlacklist,
   flushAndRunMultipleServers,
   getBlacklistedVideosList,
+  getMyVideos,
   getSortedBlacklistedVideosList,
   getVideosList,
   killallServers,
   removeVideoFromBlacklist,
   ServerInfo,
   setAccessTokensToServers,
+  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')
     }
   }
 
@@ -62,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 () {
@@ -125,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 () {
@@ -136,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 () {
diff --git a/server/tests/utils/videos/video-blacklist.ts b/server/tests/utils/videos/video-blacklist.ts
index aa0d232b6..7819f4b25 100644
--- a/server/tests/utils/videos/video-blacklist.ts
+++ b/server/tests/utils/videos/video-blacklist.ts
@@ -1,15 +1,26 @@
 import * as request from 'supertest'
 
-function addVideoToBlacklist (url: string, token: string, videoId: number, specialStatus = 204) {
+function addVideoToBlacklist (url: string, token: string, videoId: number | string, reason?: string, specialStatus = 204) {
   const path = '/api/v1/videos/' + videoId + '/blacklist'
 
   return request(url)
           .post(path)
+          .send({ reason })
           .set('Accept', 'application/json')
           .set('Authorization', 'Bearer ' + token)
           .expect(specialStatus)
 }
 
+function updateVideoBlacklist (url: string, token: string, videoId: number, reason?: string, specialStatus = 204) {
+  const path = '/api/v1/videos/' + videoId + '/blacklist'
+
+  return request(url)
+    .put(path)
+    .send({ reason })
+    .set('Accept', 'application/json')
+    .set('Authorization', 'Bearer ' + token)
+    .expect(specialStatus)}
+
 function removeVideoFromBlacklist (url: string, token: string, videoId: number | string, specialStatus = 204) {
   const path = '/api/v1/videos/' + videoId + '/blacklist'
 
@@ -50,5 +61,6 @@ export {
   addVideoToBlacklist,
   removeVideoFromBlacklist,
   getBlacklistedVideosList,
-  getSortedBlacklistedVideosList
+  getSortedBlacklistedVideosList,
+  updateVideoBlacklist
 }