server/tests/api/videos/video-change-ownership.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 { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
   6 import {
   7   acceptChangeOwnership,
   8   changeVideoOwnership,
   9   cleanupTests,
  10   createLive,
  11   createUser,
  12   doubleFollow,
  13   flushAndRunMultipleServers,
  14   flushAndRunServer,
  15   getMyUserInformation,
  16   getVideo,
  17   getVideoChangeOwnershipList,
  18   getVideosList,
  19   refuseChangeOwnership,
  20   ServerInfo,
  21   setAccessTokensToServers,
  22   setDefaultVideoChannel,
  23   uploadVideo,
  24   userLogin
  25 } from '../../../../shared/extra-utils'
  26 import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
  27 import { User } from '../../../../shared/models/users'
  28 import { VideoDetails, VideoPrivacy } from '../../../../shared/models/videos'
  29
  30 const expect = chai.expect
  31
  32 describe('Test video change ownership - nominal', function () {
  33   let servers: ServerInfo[] = []
  34   const firstUser = {
  35     username: 'first',
  36     password: 'My great password'
  37   }
  38   const secondUser = {
  39     username: 'second',
  40     password: 'My other password'
  41   }
  42
  43   let firstUserAccessToken = ''
  44   let firstUserChannelId: number
  45
  46   let secondUserAccessToken = ''
  47   let secondUserChannelId: number
  48
  49   let lastRequestChangeOwnershipId = ''
  50
  51   let liveId: number
  52
  53   before(async function () {
  54     this.timeout(50000)
  55
  56     servers = await flushAndRunMultipleServers(2)
  57     await setAccessTokensToServers(servers)
  58     await setDefaultVideoChannel(servers)
  59
  60     await servers[0].configCommand.updateCustomSubConfig({
  61       newConfig: {
  62         transcoding: {
  63           enabled: false
  64         },
  65         live: {
  66           enabled: true
  67         }
  68       }
  69     })
  70
  71     const videoQuota = 42000000
  72     await createUser({
  73       url: servers[0].url,
  74       accessToken: servers[0].accessToken,
  75       username: firstUser.username,
  76       password: firstUser.password,
  77       videoQuota: videoQuota
  78     })
  79     await createUser({
  80       url: servers[0].url,
  81       accessToken: servers[0].accessToken,
  82       username: secondUser.username,
  83       password: secondUser.password,
  84       videoQuota: videoQuota
  85     })
  86
  87     firstUserAccessToken = await userLogin(servers[0], firstUser)
  88     secondUserAccessToken = await userLogin(servers[0], secondUser)
  89
  90     {
  91       const res = await getMyUserInformation(servers[0].url, firstUserAccessToken)
  92       const firstUserInformation: User = res.body
  93       firstUserChannelId = firstUserInformation.videoChannels[0].id
  94     }
  95
  96     {
  97       const res = await getMyUserInformation(servers[0].url, secondUserAccessToken)
  98       const secondUserInformation: User = res.body
  99       secondUserChannelId = secondUserInformation.videoChannels[0].id
 100     }
 101
 102     {
 103       const videoAttributes = {
 104         name: 'my super name',
 105         description: 'my super description'
 106       }
 107       const res = await uploadVideo(servers[0].url, firstUserAccessToken, videoAttributes)
 108
 109       const resVideo = await getVideo(servers[0].url, res.body.video.id)
 110       servers[0].video = resVideo.body
 111     }
 112
 113     {
 114       const attributes = { name: 'live', channelId: firstUserChannelId, privacy: VideoPrivacy.PUBLIC }
 115       const res = await createLive(servers[0].url, firstUserAccessToken, attributes)
 116
 117       liveId = res.body.video.id
 118     }
 119
 120     await doubleFollow(servers[0], servers[1])
 121   })
 122
 123   it('Should not have video change ownership', async function () {
 124     const resFirstUser = await getVideoChangeOwnershipList(servers[0].url, firstUserAccessToken)
 125
 126     expect(resFirstUser.body.total).to.equal(0)
 127     expect(resFirstUser.body.data).to.be.an('array')
 128     expect(resFirstUser.body.data.length).to.equal(0)
 129
 130     const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken)
 131
 132     expect(resSecondUser.body.total).to.equal(0)
 133     expect(resSecondUser.body.data).to.be.an('array')
 134     expect(resSecondUser.body.data.length).to.equal(0)
 135   })
 136
 137   it('Should send a request to change ownership of a video', async function () {
 138     this.timeout(15000)
 139
 140     await changeVideoOwnership(servers[0].url, firstUserAccessToken, servers[0].video.id, secondUser.username)
 141   })
 142
 143   it('Should only return a request to change ownership for the second user', async function () {
 144     const resFirstUser = await getVideoChangeOwnershipList(servers[0].url, firstUserAccessToken)
 145
 146     expect(resFirstUser.body.total).to.equal(0)
 147     expect(resFirstUser.body.data).to.be.an('array')
 148     expect(resFirstUser.body.data.length).to.equal(0)
 149
 150     const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken)
 151
 152     expect(resSecondUser.body.total).to.equal(1)
 153     expect(resSecondUser.body.data).to.be.an('array')
 154     expect(resSecondUser.body.data.length).to.equal(1)
 155
 156     lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
 157   })
 158
 159   it('Should accept the same change ownership request without crashing', async function () {
 160     this.timeout(10000)
 161
 162     await changeVideoOwnership(servers[0].url, firstUserAccessToken, servers[0].video.id, secondUser.username)
 163   })
 164
 165   it('Should not create multiple change ownership requests while one is waiting', async function () {
 166     this.timeout(10000)
 167
 168     const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken)
 169
 170     expect(resSecondUser.body.total).to.equal(1)
 171     expect(resSecondUser.body.data).to.be.an('array')
 172     expect(resSecondUser.body.data.length).to.equal(1)
 173   })
 174
 175   it('Should not be possible to refuse the change of ownership from first user', async function () {
 176     this.timeout(10000)
 177
 178     await refuseChangeOwnership(servers[0].url, firstUserAccessToken, lastRequestChangeOwnershipId, HttpStatusCode.FORBIDDEN_403)
 179   })
 180
 181   it('Should be possible to refuse the change of ownership from second user', async function () {
 182     this.timeout(10000)
 183
 184     await refuseChangeOwnership(servers[0].url, secondUserAccessToken, lastRequestChangeOwnershipId)
 185   })
 186
 187   it('Should send a new request to change ownership of a video', async function () {
 188     this.timeout(15000)
 189
 190     await changeVideoOwnership(servers[0].url, firstUserAccessToken, servers[0].video.id, secondUser.username)
 191   })
 192
 193   it('Should return two requests to change ownership for the second user', async function () {
 194     const resFirstUser = await getVideoChangeOwnershipList(servers[0].url, firstUserAccessToken)
 195
 196     expect(resFirstUser.body.total).to.equal(0)
 197     expect(resFirstUser.body.data).to.be.an('array')
 198     expect(resFirstUser.body.data.length).to.equal(0)
 199
 200     const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken)
 201
 202     expect(resSecondUser.body.total).to.equal(2)
 203     expect(resSecondUser.body.data).to.be.an('array')
 204     expect(resSecondUser.body.data.length).to.equal(2)
 205
 206     lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
 207   })
 208
 209   it('Should not be possible to accept the change of ownership from first user', async function () {
 210     this.timeout(10000)
 211
 212     await acceptChangeOwnership(
 213       servers[0].url,
 214       firstUserAccessToken,
 215       lastRequestChangeOwnershipId,
 216       secondUserChannelId,
 217       HttpStatusCode.FORBIDDEN_403
 218     )
 219   })
 220
 221   it('Should be possible to accept the change of ownership from second user', async function () {
 222     this.timeout(10000)
 223
 224     await acceptChangeOwnership(servers[0].url, secondUserAccessToken, lastRequestChangeOwnershipId, secondUserChannelId)
 225
 226     await waitJobs(servers)
 227   })
 228
 229   it('Should have the channel of the video updated', async function () {
 230     for (const server of servers) {
 231       const res = await getVideo(server.url, servers[0].video.uuid)
 232
 233       const video: VideoDetails = res.body
 234
 235       expect(video.name).to.equal('my super name')
 236       expect(video.channel.displayName).to.equal('Main second channel')
 237       expect(video.channel.name).to.equal('second_channel')
 238     }
 239   })
 240
 241   it('Should send a request to change ownership of a live', async function () {
 242     this.timeout(15000)
 243
 244     await changeVideoOwnership(servers[0].url, firstUserAccessToken, liveId, secondUser.username)
 245
 246     const resSecondUser = await getVideoChangeOwnershipList(servers[0].url, secondUserAccessToken)
 247
 248     expect(resSecondUser.body.total).to.equal(3)
 249     expect(resSecondUser.body.data.length).to.equal(3)
 250
 251     lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
 252   })
 253
 254   it('Should accept a live ownership change', async function () {
 255     this.timeout(20000)
 256
 257     await acceptChangeOwnership(servers[0].url, secondUserAccessToken, lastRequestChangeOwnershipId, secondUserChannelId)
 258
 259     await waitJobs(servers)
 260
 261     for (const server of servers) {
 262       const res = await getVideo(server.url, servers[0].video.uuid)
 263
 264       const video: VideoDetails = res.body
 265
 266       expect(video.name).to.equal('my super name')
 267       expect(video.channel.displayName).to.equal('Main second channel')
 268       expect(video.channel.name).to.equal('second_channel')
 269     }
 270   })
 271
 272   after(async function () {
 273     await cleanupTests(servers)
 274   })
 275 })
 276
 277 describe('Test video change ownership - quota too small', function () {
 278   let server: ServerInfo
 279   const firstUser = {
 280     username: 'first',
 281     password: 'My great password'
 282   }
 283   const secondUser = {
 284     username: 'second',
 285     password: 'My other password'
 286   }
 287   let firstUserAccessToken = ''
 288   let secondUserAccessToken = ''
 289   let lastRequestChangeOwnershipId = ''
 290
 291   before(async function () {
 292     this.timeout(50000)
 293
 294     // Run one server
 295     server = await flushAndRunServer(1)
 296     await setAccessTokensToServers([ server ])
 297
 298     const videoQuota = 42000000
 299     const limitedVideoQuota = 10
 300     await createUser({
 301       url: server.url,
 302       accessToken: server.accessToken,
 303       username: firstUser.username,
 304       password: firstUser.password,
 305       videoQuota: videoQuota
 306     })
 307     await createUser({
 308       url: server.url,
 309       accessToken: server.accessToken,
 310       username: secondUser.username,
 311       password: secondUser.password,
 312       videoQuota: limitedVideoQuota
 313     })
 314
 315     firstUserAccessToken = await userLogin(server, firstUser)
 316     secondUserAccessToken = await userLogin(server, secondUser)
 317
 318     // Upload some videos on the server
 319     const video1Attributes = {
 320       name: 'my super name',
 321       description: 'my super description'
 322     }
 323     await uploadVideo(server.url, firstUserAccessToken, video1Attributes)
 324
 325     await waitJobs(server)
 326
 327     const res = await getVideosList(server.url)
 328     const videos = res.body.data
 329
 330     expect(videos.length).to.equal(1)
 331
 332     server.video = videos.find(video => video.name === 'my super name')
 333   })
 334
 335   it('Should send a request to change ownership of a video', async function () {
 336     this.timeout(15000)
 337
 338     await changeVideoOwnership(server.url, firstUserAccessToken, server.video.id, secondUser.username)
 339   })
 340
 341   it('Should only return a request to change ownership for the second user', async function () {
 342     const resFirstUser = await getVideoChangeOwnershipList(server.url, firstUserAccessToken)
 343
 344     expect(resFirstUser.body.total).to.equal(0)
 345     expect(resFirstUser.body.data).to.be.an('array')
 346     expect(resFirstUser.body.data.length).to.equal(0)
 347
 348     const resSecondUser = await getVideoChangeOwnershipList(server.url, secondUserAccessToken)
 349
 350     expect(resSecondUser.body.total).to.equal(1)
 351     expect(resSecondUser.body.data).to.be.an('array')
 352     expect(resSecondUser.body.data.length).to.equal(1)
 353
 354     lastRequestChangeOwnershipId = resSecondUser.body.data[0].id
 355   })
 356
 357   it('Should not be possible to accept the change of ownership from second user because of exceeded quota', async function () {
 358     this.timeout(10000)
 359
 360     const secondUserInformationResponse = await getMyUserInformation(server.url, secondUserAccessToken)
 361     const secondUserInformation: User = secondUserInformationResponse.body
 362     const channelId = secondUserInformation.videoChannels[0].id
 363
 364     await acceptChangeOwnership(
 365       server.url,
 366       secondUserAccessToken,
 367       lastRequestChangeOwnershipId,
 368       channelId,
 369       HttpStatusCode.PAYLOAD_TOO_LARGE_413
 370     )
 371   })
 372
 373   after(async function () {
 374     await cleanupTests([ server ])
 375   })
 376 })