server/tests/api/videos/video-nsfw.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import 'mocha'
   4 import * as chai from 'chai'
   5 import { cleanupTests, flushAndRunServer, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
   6 import { BooleanBothQuery, CustomConfig, ResultList, Video, VideosOverview } from '@shared/models'
   7
   8 const expect = chai.expect
   9
  10 function createOverviewRes (overview: VideosOverview) {
  11   const videos = overview.categories[0].videos
  12   return { data: videos, total: videos.length }
  13 }
  14
  15 describe('Test video NSFW policy', function () {
  16   let server: ServerInfo
  17   let userAccessToken: string
  18   let customConfig: CustomConfig
  19
  20   async function getVideosFunctions (token?: string, query: { nsfw?: BooleanBothQuery } = {}) {
  21     const user = await server.usersCommand.getMyInfo()
  22     const videoChannelName = user.videoChannels[0].name
  23     const accountName = user.account.name + '@' + user.account.host
  24     const hasQuery = Object.keys(query).length !== 0
  25     let promises: Promise<ResultList<Video>>[]
  26
  27     if (token) {
  28       promises = [
  29         server.searchCommand.advancedVideoSearch({ token, search: { search: 'n', sort: '-publishedAt', ...query } }),
  30         server.videosCommand.listWithToken({ token, ...query }),
  31         server.videosCommand.listByAccount({ token, accountName, ...query }),
  32         server.videosCommand.listByChannel({ token, videoChannelName, ...query })
  33       ]
  34
  35       // Overviews do not support video filters
  36       if (!hasQuery) {
  37         const p = server.overviewsCommand.getVideos({ page: 1, token })
  38                                          .then(res => createOverviewRes(res))
  39         promises.push(p)
  40       }
  41
  42       return Promise.all(promises)
  43     }
  44
  45     promises = [
  46       server.searchCommand.searchVideos({ search: 'n', sort: '-publishedAt' }),
  47       server.videosCommand.list(),
  48       server.videosCommand.listByAccount({ accountName }),
  49       server.videosCommand.listByChannel({ videoChannelName })
  50     ]
  51
  52     // Overviews do not support video filters
  53     if (!hasQuery) {
  54       const p = server.overviewsCommand.getVideos({ page: 1 })
  55                                        .then(res => createOverviewRes(res))
  56       promises.push(p)
  57     }
  58
  59     return Promise.all(promises)
  60   }
  61
  62   before(async function () {
  63     this.timeout(50000)
  64     server = await flushAndRunServer(1)
  65
  66     // Get the access tokens
  67     await setAccessTokensToServers([ server ])
  68
  69     {
  70       const attributes = { name: 'nsfw', nsfw: true, category: 1 }
  71       await server.videosCommand.upload({ attributes })
  72     }
  73
  74     {
  75       const attributes = { name: 'normal', nsfw: false, category: 1 }
  76       await server.videosCommand.upload({ attributes })
  77     }
  78
  79     customConfig = await server.configCommand.getCustomConfig()
  80   })
  81
  82   describe('Instance default NSFW policy', function () {
  83     it('Should display NSFW videos with display default NSFW policy', async function () {
  84       const serverConfig = await server.configCommand.getConfig()
  85       expect(serverConfig.instance.defaultNSFWPolicy).to.equal('display')
  86
  87       for (const body of await getVideosFunctions()) {
  88         expect(body.total).to.equal(2)
  89
  90         const videos = body.data
  91         expect(videos).to.have.lengthOf(2)
  92         expect(videos[0].name).to.equal('normal')
  93         expect(videos[1].name).to.equal('nsfw')
  94       }
  95     })
  96
  97     it('Should not display NSFW videos with do_not_list default NSFW policy', async function () {
  98       customConfig.instance.defaultNSFWPolicy = 'do_not_list'
  99       await server.configCommand.updateCustomConfig({ newCustomConfig: customConfig })
 100
 101       const serverConfig = await server.configCommand.getConfig()
 102       expect(serverConfig.instance.defaultNSFWPolicy).to.equal('do_not_list')
 103
 104       for (const body of await getVideosFunctions()) {
 105         expect(body.total).to.equal(1)
 106
 107         const videos = body.data
 108         expect(videos).to.have.lengthOf(1)
 109         expect(videos[0].name).to.equal('normal')
 110       }
 111     })
 112
 113     it('Should display NSFW videos with blur default NSFW policy', async function () {
 114       customConfig.instance.defaultNSFWPolicy = 'blur'
 115       await server.configCommand.updateCustomConfig({ newCustomConfig: customConfig })
 116
 117       const serverConfig = await server.configCommand.getConfig()
 118       expect(serverConfig.instance.defaultNSFWPolicy).to.equal('blur')
 119
 120       for (const body of await getVideosFunctions()) {
 121         expect(body.total).to.equal(2)
 122
 123         const videos = body.data
 124         expect(videos).to.have.lengthOf(2)
 125         expect(videos[0].name).to.equal('normal')
 126         expect(videos[1].name).to.equal('nsfw')
 127       }
 128     })
 129   })
 130
 131   describe('User NSFW policy', function () {
 132
 133     it('Should create a user having the default nsfw policy', async function () {
 134       const username = 'user1'
 135       const password = 'my super password'
 136       await server.usersCommand.create({ username: username, password: password })
 137
 138       userAccessToken = await server.loginCommand.getAccessToken({ username, password })
 139
 140       const user = await server.usersCommand.getMyInfo({ token: userAccessToken })
 141       expect(user.nsfwPolicy).to.equal('blur')
 142     })
 143
 144     it('Should display NSFW videos with blur user NSFW policy', async function () {
 145       customConfig.instance.defaultNSFWPolicy = 'do_not_list'
 146       await server.configCommand.updateCustomConfig({ newCustomConfig: customConfig })
 147
 148       for (const body of await getVideosFunctions(userAccessToken)) {
 149         expect(body.total).to.equal(2)
 150
 151         const videos = body.data
 152         expect(videos).to.have.lengthOf(2)
 153         expect(videos[0].name).to.equal('normal')
 154         expect(videos[1].name).to.equal('nsfw')
 155       }
 156     })
 157
 158     it('Should display NSFW videos with display user NSFW policy', async function () {
 159       await server.usersCommand.updateMe({ nsfwPolicy: 'display' })
 160
 161       for (const body of await getVideosFunctions(server.accessToken)) {
 162         expect(body.total).to.equal(2)
 163
 164         const videos = body.data
 165         expect(videos).to.have.lengthOf(2)
 166         expect(videos[0].name).to.equal('normal')
 167         expect(videos[1].name).to.equal('nsfw')
 168       }
 169     })
 170
 171     it('Should not display NSFW videos with do_not_list user NSFW policy', async function () {
 172       await server.usersCommand.updateMe({ nsfwPolicy: 'do_not_list' })
 173
 174       for (const body of await getVideosFunctions(server.accessToken)) {
 175         expect(body.total).to.equal(1)
 176
 177         const videos = body.data
 178         expect(videos).to.have.lengthOf(1)
 179         expect(videos[0].name).to.equal('normal')
 180       }
 181     })
 182
 183     it('Should be able to see my NSFW videos even with do_not_list user NSFW policy', async function () {
 184       const { total, data } = await server.videosCommand.listMyVideos()
 185       expect(total).to.equal(2)
 186
 187       expect(data).to.have.lengthOf(2)
 188       expect(data[0].name).to.equal('normal')
 189       expect(data[1].name).to.equal('nsfw')
 190     })
 191
 192     it('Should display NSFW videos when the nsfw param === true', async function () {
 193       for (const body of await getVideosFunctions(server.accessToken, { nsfw: 'true' })) {
 194         expect(body.total).to.equal(1)
 195
 196         const videos = body.data
 197         expect(videos).to.have.lengthOf(1)
 198         expect(videos[0].name).to.equal('nsfw')
 199       }
 200     })
 201
 202     it('Should hide NSFW videos when the nsfw param === true', async function () {
 203       for (const body of await getVideosFunctions(server.accessToken, { nsfw: 'false' })) {
 204         expect(body.total).to.equal(1)
 205
 206         const videos = body.data
 207         expect(videos).to.have.lengthOf(1)
 208         expect(videos[0].name).to.equal('normal')
 209       }
 210     })
 211
 212     it('Should display both videos when the nsfw param === both', async function () {
 213       for (const body of await getVideosFunctions(server.accessToken, { nsfw: 'both' })) {
 214         expect(body.total).to.equal(2)
 215
 216         const videos = body.data
 217         expect(videos).to.have.lengthOf(2)
 218         expect(videos[0].name).to.equal('normal')
 219         expect(videos[1].name).to.equal('nsfw')
 220       }
 221     })
 222   })
 223
 224   after(async function () {
 225     await cleanupTests([ server ])
 226   })
 227 })