server/tests/external-plugins/auto-block-videos.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import 'mocha'
   4 import { expect } from 'chai'
   5 import { Video, VideoBlacklist } from '@shared/models'
   6 import {
   7   doubleFollow,
   8   getBlacklistedVideosList,
   9   getVideosList,
  10   installPlugin,
  11   MockBlocklist,
  12   removeVideoFromBlacklist,
  13   setAccessTokensToServers,
  14   updatePluginSettings,
  15   uploadVideoAndGetId,
  16   wait
  17 } from '../../../shared/extra-utils'
  18 import {
  19   cleanupTests,
  20   flushAndRunMultipleServers,
  21   killallServers,
  22   reRunServer,
  23   ServerInfo
  24 } from '../../../shared/extra-utils/server/servers'
  25
  26 async function check (server: ServerInfo, videoUUID: string, exists = true) {
  27   const res = await getVideosList(server.url)
  28
  29   const video = res.body.data.find(v => v.uuid === videoUUID)
  30
  31   if (exists) {
  32     expect(video).to.not.be.undefined
  33   } else {
  34     expect(video).to.be.undefined
  35   }
  36 }
  37
  38 describe('Official plugin auto-block videos', function () {
  39   let servers: ServerInfo[]
  40   let blocklistServer: MockBlocklist
  41   let server1Videos: Video[] = []
  42   let server2Videos: Video[] = []
  43   let port: number
  44
  45   before(async function () {
  46     this.timeout(60000)
  47
  48     servers = await flushAndRunMultipleServers(2)
  49     await setAccessTokensToServers(servers)
  50
  51     for (const server of servers) {
  52       await installPlugin({
  53         url: server.url,
  54         accessToken: server.accessToken,
  55         npmName: 'peertube-plugin-auto-block-videos'
  56       })
  57     }
  58
  59     blocklistServer = new MockBlocklist()
  60     port = await blocklistServer.initialize()
  61
  62     await uploadVideoAndGetId({ server: servers[0], videoName: 'video server 1' })
  63     await uploadVideoAndGetId({ server: servers[1], videoName: 'video server 2' })
  64     await uploadVideoAndGetId({ server: servers[1], videoName: 'video 2 server 2' })
  65     await uploadVideoAndGetId({ server: servers[1], videoName: 'video 3 server 2' })
  66
  67     {
  68       const res = await getVideosList(servers[0].url)
  69       server1Videos = res.body.data.map(v => Object.assign(v, { url: servers[0].url + '/videos/watch/' + v.uuid }))
  70     }
  71
  72     {
  73       const res = await getVideosList(servers[1].url)
  74       server2Videos = res.body.data.map(v => Object.assign(v, { url: servers[1].url + '/videos/watch/' + v.uuid }))
  75     }
  76
  77     await doubleFollow(servers[0], servers[1])
  78   })
  79
  80   it('Should update plugin settings', async function () {
  81     await updatePluginSettings({
  82       url: servers[0].url,
  83       accessToken: servers[0].accessToken,
  84       npmName: 'peertube-plugin-auto-block-videos',
  85       settings: {
  86         'blocklist-urls': `http://localhost:${port}/blocklist`,
  87         'check-seconds-interval': 1
  88       }
  89     })
  90   })
  91
  92   it('Should auto block a video', async function () {
  93     this.timeout(10000)
  94
  95     await check(servers[0], server2Videos[0].uuid, true)
  96
  97     blocklistServer.replace({
  98       data: [
  99         {
 100           value: server2Videos[0].url
 101         }
 102       ]
 103     })
 104
 105     await wait(2000)
 106
 107     await check(servers[0], server2Videos[0].uuid, false)
 108   })
 109
 110   it('Should have video in blacklists', async function () {
 111     const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken })
 112
 113     const videoBlacklists = res.body.data as VideoBlacklist[]
 114
 115     expect(videoBlacklists).to.have.lengthOf(1)
 116     expect(videoBlacklists[0].reason).to.contains('Automatically blocked from auto block plugin')
 117     expect(videoBlacklists[0].video.name).to.equal(server2Videos[0].name)
 118   })
 119
 120   it('Should not block a local video', async function () {
 121     this.timeout(10000)
 122
 123     await check(servers[0], server1Videos[0].uuid, true)
 124
 125     blocklistServer.replace({
 126       data: [
 127         {
 128           value: server1Videos[0].url
 129         }
 130       ]
 131     })
 132
 133     await wait(2000)
 134
 135     await check(servers[0], server1Videos[0].uuid, true)
 136   })
 137
 138   it('Should remove a video block', async function () {
 139     this.timeout(10000)
 140
 141     await check(servers[0], server2Videos[0].uuid, false)
 142
 143     blocklistServer.replace({
 144       data: [
 145         {
 146           value: server2Videos[0].url,
 147           action: 'remove'
 148         }
 149       ]
 150     })
 151
 152     await wait(2000)
 153
 154     await check(servers[0], server2Videos[0].uuid, true)
 155   })
 156
 157   it('Should auto block a video, manually unblock it and do not reblock it automatically', async function () {
 158     this.timeout(20000)
 159
 160     const video = server2Videos[1]
 161
 162     await check(servers[0], video.uuid, true)
 163
 164     blocklistServer.replace({
 165       data: [
 166         {
 167           value: video.url,
 168           updatedAt: new Date().toISOString()
 169         }
 170       ]
 171     })
 172
 173     await wait(2000)
 174
 175     await check(servers[0], video.uuid, false)
 176
 177     await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, video.uuid)
 178
 179     await check(servers[0], video.uuid, true)
 180
 181     killallServers([ servers[0] ])
 182     await reRunServer(servers[0])
 183     await wait(2000)
 184
 185     await check(servers[0], video.uuid, true)
 186   })
 187
 188   after(async function () {
 189     await blocklistServer.terminate()
 190
 191     await cleanupTests(servers)
 192   })
 193 })