server/tests/api/videos/single-server.ts

   1 /* tslint:disable:no-unused-expression */
   2
   3 import * as chai from 'chai'
   4 import { keyBy } from 'lodash'
   5 import 'mocha'
   6 import { VideoPrivacy } from '../../../../shared/models/videos'
   7 import {
   8   checkVideoFilesWereRemoved, completeVideoCheck, flushTests, getVideo, getVideoCategories, getVideoLanguages, getVideoLicences,
   9   getVideoPrivacies, getVideosList, getVideosListPagination, getVideosListSort, killallServers, rateVideo, removeVideo, runServer,
  10   searchVideo, searchVideoWithPagination, searchVideoWithSort, ServerInfo, setAccessTokensToServers, testImage, updateVideo, uploadVideo,
  11   viewVideo
  12 } from '../../utils'
  13
  14 const expect = chai.expect
  15
  16 describe('Test a single server', function () {
  17   let server: ServerInfo = null
  18   let videoId = -1
  19   let videoUUID = ''
  20   let videosListBase: any[] = null
  21
  22   const getCheckAttributes = {
  23     name: 'my super name',
  24     category: 2,
  25     licence: 6,
  26     language: 3,
  27     nsfw: true,
  28     description: 'my super description',
  29     support: 'my super support text',
  30     host: 'localhost:9001',
  31     account: 'root',
  32     isLocal: true,
  33     duration: 5,
  34     tags: [ 'tag1', 'tag2', 'tag3' ],
  35     privacy: VideoPrivacy.PUBLIC,
  36     commentsEnabled: true,
  37     channel: {
  38       name: 'Default root channel',
  39       description: '',
  40       isLocal: true
  41     },
  42     fixture: 'video_short.webm',
  43     files: [
  44       {
  45         resolution: 720,
  46         size: 218910
  47       }
  48     ]
  49   }
  50
  51   const updateCheckAttributes = {
  52     name: 'my super video updated',
  53     category: 4,
  54     licence: 2,
  55     language: 5,
  56     nsfw: false,
  57     description: 'my super description updated',
  58     support: 'my super support text updated',
  59     host: 'localhost:9001',
  60     account: 'root',
  61     isLocal: true,
  62     tags: [ 'tagup1', 'tagup2' ],
  63     privacy: VideoPrivacy.PUBLIC,
  64     duration: 5,
  65     commentsEnabled: false,
  66     channel: {
  67       name: 'Default root channel',
  68       description: '',
  69       isLocal: true
  70     },
  71     fixture: 'video_short3.webm',
  72     files: [
  73       {
  74         resolution: 720,
  75         size: 292677
  76       }
  77     ]
  78   }
  79
  80   before(async function () {
  81     this.timeout(30000)
  82
  83     await flushTests()
  84
  85     server = await runServer(1)
  86
  87     await setAccessTokensToServers([ server ])
  88   })
  89
  90   it('Should list video categories', async function () {
  91     const res = await getVideoCategories(server.url)
  92
  93     const categories = res.body
  94     expect(Object.keys(categories)).to.have.length.above(10)
  95
  96     expect(categories[11]).to.equal('News')
  97   })
  98
  99   it('Should list video licences', async function () {
 100     const res = await getVideoLicences(server.url)
 101
 102     const licences = res.body
 103     expect(Object.keys(licences)).to.have.length.above(5)
 104
 105     expect(licences[3]).to.equal('Attribution - No Derivatives')
 106   })
 107
 108   it('Should list video languages', async function () {
 109     const res = await getVideoLanguages(server.url)
 110
 111     const languages = res.body
 112     expect(Object.keys(languages)).to.have.length.above(5)
 113
 114     expect(languages[3]).to.equal('Mandarin')
 115   })
 116
 117   it('Should list video privacies', async function () {
 118     const res = await getVideoPrivacies(server.url)
 119
 120     const privacies = res.body
 121     expect(Object.keys(privacies)).to.have.length.at.least(3)
 122
 123     expect(privacies[3]).to.equal('Private')
 124   })
 125
 126   it('Should not have videos', async function () {
 127     const res = await getVideosList(server.url)
 128
 129     expect(res.body.total).to.equal(0)
 130     expect(res.body.data).to.be.an('array')
 131     expect(res.body.data.length).to.equal(0)
 132   })
 133
 134   it('Should upload the video', async function () {
 135     const videoAttributes = {
 136       name: 'my super name',
 137       category: 2,
 138       nsfw: true,
 139       licence: 6,
 140       tags: [ 'tag1', 'tag2', 'tag3' ]
 141     }
 142     const res = await uploadVideo(server.url, server.accessToken, videoAttributes)
 143     expect(res.body.video).to.not.be.undefined
 144     expect(res.body.video.id).to.equal(1)
 145     expect(res.body.video.uuid).to.have.length.above(5)
 146
 147     videoId = res.body.video.id
 148     videoUUID = res.body.video.uuid
 149   })
 150
 151   it('Should get and seed the uploaded video', async function () {
 152     // Yes, this could be long
 153     this.timeout(60000)
 154
 155     const res = await getVideosList(server.url)
 156
 157     expect(res.body.total).to.equal(1)
 158     expect(res.body.data).to.be.an('array')
 159     expect(res.body.data.length).to.equal(1)
 160
 161     const video = res.body.data[0]
 162     await completeVideoCheck(server.url, video, getCheckAttributes)
 163   })
 164
 165   it('Should get the video by UUID', async function () {
 166     // Yes, this could be long
 167     this.timeout(60000)
 168
 169     const res = await getVideo(server.url, videoUUID)
 170
 171     const video = res.body
 172     await completeVideoCheck(server.url, video, getCheckAttributes)
 173   })
 174
 175   it('Should have the views updated', async function () {
 176     await viewVideo(server.url, videoId)
 177     await viewVideo(server.url, videoId)
 178     await viewVideo(server.url, videoId)
 179
 180     const res = await getVideo(server.url, videoId)
 181
 182     const video = res.body
 183     expect(video.views).to.equal(3)
 184   })
 185
 186   it('Should search the video by name', async function () {
 187     const res = await searchVideo(server.url, 'my')
 188
 189     expect(res.body.total).to.equal(1)
 190     expect(res.body.data).to.be.an('array')
 191     expect(res.body.data.length).to.equal(1)
 192
 193     const video = res.body.data[0]
 194     await completeVideoCheck(server.url, video, getCheckAttributes)
 195   })
 196
 197   // Not implemented yet
 198   // it('Should search the video by serverHost', async function () {
 199   //     const res = await   videosUtils.searchVideo(server.url, '9001', 'host')
 200
 201   //     expect(res.body.total).to.equal(1)
 202   //     expect(res.body.data).to.be.an('array')
 203   //     expect(res.body.data.length).to.equal(1)
 204
 205   //     const video = res.body.data[0]
 206   //     expect(video.name).to.equal('my super name')
 207   //     expect(video.description).to.equal('my super description')
 208   //     expect(video.serverHost).to.equal('localhost:9001')
 209   //     expect(video.author).to.equal('root')
 210   //     expect(video.isLocal).to.be.true
 211   //     expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
 212   //     expect(dateIsValid(video.createdAt)).to.be.true
 213   //     expect(dateIsValid(video.updatedAt)).to.be.true
 214
 215   //     const test = await testVideoImage(server.url, 'video_short.webm', video.thumbnailPath)
 216   //       expect(test).to.equal(true)
 217
 218   //       done()
 219   //     })
 220   //   })
 221   // })
 222
 223   // Not implemented yet
 224   // it('Should search the video by tag', async function () {
 225   //   const res = await searchVideo(server.url, 'tag1')
 226   //
 227   //   expect(res.body.total).to.equal(1)
 228   //   expect(res.body.data).to.be.an('array')
 229   //   expect(res.body.data.length).to.equal(1)
 230   //
 231   //   const video = res.body.data[0]
 232   //   expect(video.name).to.equal('my super name')
 233   //   expect(video.category).to.equal(2)
 234   //   expect(video.categoryLabel).to.equal('Films')
 235   //   expect(video.licence).to.equal(6)
 236   //   expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
 237   //   expect(video.language).to.equal(3)
 238   //   expect(video.languageLabel).to.equal('Mandarin')
 239   //   expect(video.nsfw).to.be.ok
 240   //   expect(video.description).to.equal('my super description')
 241   //   expect(video.serverHost).to.equal('localhost:9001')
 242   //   expect(video.accountName).to.equal('root')
 243   //   expect(video.isLocal).to.be.true
 244   //   expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
 245   //   expect(dateIsValid(video.createdAt)).to.be.true
 246   //   expect(dateIsValid(video.updatedAt)).to.be.true
 247   //
 248   //   const test = await testVideoImage(server.url, 'video_short.webm', video.thumbnailPath)
 249   //   expect(test).to.equal(true)
 250   // })
 251
 252   it('Should not find a search by name', async function () {
 253     const res = await searchVideo(server.url, 'hello')
 254
 255     expect(res.body.total).to.equal(0)
 256     expect(res.body.data).to.be.an('array')
 257     expect(res.body.data.length).to.equal(0)
 258   })
 259
 260   // Not implemented yet
 261   // it('Should not find a search by author', async function () {
 262   //   const res = await searchVideo(server.url, 'hello')
 263   //
 264   //   expect(res.body.total).to.equal(0)
 265   //   expect(res.body.data).to.be.an('array')
 266   //   expect(res.body.data.length).to.equal(0)
 267   // })
 268   //
 269   // Not implemented yet
 270   // it('Should not find a search by tag', async function () {
 271   //   const res = await searchVideo(server.url, 'hello')
 272   //
 273   //   expect(res.body.total).to.equal(0)
 274   //   expect(res.body.data).to.be.an('array')
 275   //   expect(res.body.data.length).to.equal(0)
 276   // })
 277
 278   it('Should remove the video', async function () {
 279     await removeVideo(server.url, server.accessToken, videoId)
 280
 281     await checkVideoFilesWereRemoved(videoUUID, 1)
 282   })
 283
 284   it('Should not have videos', async function () {
 285     const res = await getVideosList(server.url)
 286
 287     expect(res.body.total).to.equal(0)
 288     expect(res.body.data).to.be.an('array')
 289     expect(res.body.data).to.have.lengthOf(0)
 290   })
 291
 292   it('Should upload 6 videos', async function () {
 293     this.timeout(25000)
 294
 295     const videos = [
 296       'video_short.mp4', 'video_short.ogv', 'video_short.webm',
 297       'video_short1.webm', 'video_short2.webm', 'video_short3.webm'
 298     ]
 299
 300     const tasks: Promise<any>[] = []
 301     for (const video of videos) {
 302       const videoAttributes = {
 303         name: video + ' name',
 304         description: video + ' description',
 305         category: 2,
 306         licence: 1,
 307         language: 1,
 308         nsfw: true,
 309         tags: [ 'tag1', 'tag2', 'tag3' ],
 310         fixture: video
 311       }
 312
 313       const p = uploadVideo(server.url, server.accessToken, videoAttributes)
 314       tasks.push(p)
 315     }
 316
 317     await Promise.all(tasks)
 318   })
 319
 320   it('Should have the correct durations', async function () {
 321     const res = await getVideosList(server.url)
 322
 323     expect(res.body.total).to.equal(6)
 324     const videos = res.body.data
 325     expect(videos).to.be.an('array')
 326     expect(videos).to.have.lengthOf(6)
 327
 328     const videosByName = keyBy<{ duration: number }>(videos, 'name')
 329     expect(videosByName['video_short.mp4 name'].duration).to.equal(5)
 330     expect(videosByName['video_short.ogv name'].duration).to.equal(5)
 331     expect(videosByName['video_short.webm name'].duration).to.equal(5)
 332     expect(videosByName['video_short1.webm name'].duration).to.equal(10)
 333     expect(videosByName['video_short2.webm name'].duration).to.equal(5)
 334     expect(videosByName['video_short3.webm name'].duration).to.equal(5)
 335   })
 336
 337   it('Should have the correct thumbnails', async function () {
 338     const res = await getVideosList(server.url)
 339
 340     const videos = res.body.data
 341     // For the next test
 342     videosListBase = videos
 343
 344     for (const video of videos) {
 345       const videoName = video.name.replace(' name', '')
 346       await testImage(server.url, videoName, video.thumbnailPath)
 347     }
 348   })
 349
 350   it('Should list only the two first videos', async function () {
 351     const res = await getVideosListPagination(server.url, 0, 2, 'name')
 352
 353     const videos = res.body.data
 354     expect(res.body.total).to.equal(6)
 355     expect(videos.length).to.equal(2)
 356     expect(videos[0].name).to.equal(videosListBase[0].name)
 357     expect(videos[1].name).to.equal(videosListBase[1].name)
 358   })
 359
 360   it('Should list only the next three videos', async function () {
 361     const res = await getVideosListPagination(server.url, 2, 3, 'name')
 362
 363     const videos = res.body.data
 364     expect(res.body.total).to.equal(6)
 365     expect(videos.length).to.equal(3)
 366     expect(videos[0].name).to.equal(videosListBase[2].name)
 367     expect(videos[1].name).to.equal(videosListBase[3].name)
 368     expect(videos[2].name).to.equal(videosListBase[4].name)
 369   })
 370
 371   it('Should list the last video', async function () {
 372     const res = await getVideosListPagination(server.url, 5, 6, 'name')
 373
 374     const videos = res.body.data
 375     expect(res.body.total).to.equal(6)
 376     expect(videos.length).to.equal(1)
 377     expect(videos[0].name).to.equal(videosListBase[5].name)
 378   })
 379
 380   it('Should search the first video', async function () {
 381     const res = await searchVideoWithPagination(server.url, 'webm', 0, 1, 'name')
 382
 383     const videos = res.body.data
 384     expect(res.body.total).to.equal(4)
 385     expect(videos.length).to.equal(1)
 386     expect(videos[0].name).to.equal('video_short1.webm name')
 387   })
 388
 389   it('Should search the last two videos', async function () {
 390     const res = await searchVideoWithPagination(server.url, 'webm', 2, 2, 'name')
 391
 392     const videos = res.body.data
 393     expect(res.body.total).to.equal(4)
 394     expect(videos.length).to.equal(2)
 395     expect(videos[0].name).to.equal('video_short3.webm name')
 396     expect(videos[1].name).to.equal('video_short.webm name')
 397   })
 398
 399   it('Should search all the webm videos', async function () {
 400     const res = await searchVideoWithPagination(server.url, 'webm', 0, 15)
 401
 402     const videos = res.body.data
 403     expect(res.body.total).to.equal(4)
 404     expect(videos.length).to.equal(4)
 405   })
 406
 407   // Not implemented yet
 408   // it('Should search all the root author videos', async function () {
 409   //   const res = await searchVideoWithPagination(server.url, 'root', 0, 15)
 410   //
 411   //   const videos = res.body.data
 412   //   expect(res.body.total).to.equal(6)
 413   //   expect(videos.length).to.equal(6)
 414   // })
 415
 416   // Not implemented yet
 417   // it('Should search all the 9001 port videos', async function () {
 418   // const res = await   videosUtils.searchVideoWithPagination(server.url, '9001', 'host', 0, 15)
 419
 420   //     const videos = res.body.data
 421   //     expect(res.body.total).to.equal(6)
 422   //     expect(videos.length).to.equal(6)
 423
 424   //     done()
 425   //   })
 426   // })
 427
 428   // it('Should search all the localhost videos', async function () {
 429   // const res = await   videosUtils.searchVideoWithPagination(server.url, 'localhost', 'host', 0, 15)
 430
 431   //     const videos = res.body.data
 432   //     expect(res.body.total).to.equal(6)
 433   //     expect(videos.length).to.equal(6)
 434
 435   //     done()
 436   //   })
 437   // })
 438
 439   it('Should list and sort by name in descending order', async function () {
 440     const res = await getVideosListSort(server.url, '-name')
 441
 442     const videos = res.body.data
 443     expect(res.body.total).to.equal(6)
 444     expect(videos.length).to.equal(6)
 445     expect(videos[0].name).to.equal('video_short.webm name')
 446     expect(videos[1].name).to.equal('video_short.ogv name')
 447     expect(videos[2].name).to.equal('video_short.mp4 name')
 448     expect(videos[3].name).to.equal('video_short3.webm name')
 449     expect(videos[4].name).to.equal('video_short2.webm name')
 450     expect(videos[5].name).to.equal('video_short1.webm name')
 451   })
 452
 453   it('Should search and sort by name in ascending order', async function () {
 454     const res = await searchVideoWithSort(server.url, 'webm', 'name')
 455
 456     const videos = res.body.data
 457     expect(res.body.total).to.equal(4)
 458     expect(videos.length).to.equal(4)
 459
 460     expect(videos[0].name).to.equal('video_short1.webm name')
 461     expect(videos[1].name).to.equal('video_short2.webm name')
 462     expect(videos[2].name).to.equal('video_short3.webm name')
 463     expect(videos[3].name).to.equal('video_short.webm name')
 464
 465     videoId = videos[2].id
 466   })
 467
 468   it('Should update a video', async function () {
 469     const attributes = {
 470       name: 'my super video updated',
 471       category: 4,
 472       licence: 2,
 473       language: 5,
 474       nsfw: false,
 475       description: 'my super description updated',
 476       commentsEnabled: false,
 477       tags: [ 'tagup1', 'tagup2' ]
 478     }
 479     await updateVideo(server.url, server.accessToken, videoId, attributes)
 480   })
 481
 482   it('Should have the video updated', async function () {
 483     this.timeout(60000)
 484
 485     const res = await getVideo(server.url, videoId)
 486     const video = res.body
 487
 488     await completeVideoCheck(server.url, video, updateCheckAttributes)
 489   })
 490
 491   it('Should update only the tags of a video', async function () {
 492     const attributes = {
 493       tags: [ 'supertag', 'tag1', 'tag2' ]
 494     }
 495     await updateVideo(server.url, server.accessToken, videoId, attributes)
 496
 497     const res = await getVideo(server.url, videoId)
 498     const video = res.body
 499
 500     await completeVideoCheck(server.url, video, Object.assign(updateCheckAttributes, attributes))
 501   })
 502
 503   it('Should update only the description of a video', async function () {
 504     const attributes = {
 505       description: 'hello everybody'
 506     }
 507     await updateVideo(server.url, server.accessToken, videoId, attributes)
 508
 509     const res = await getVideo(server.url, videoId)
 510     const video = res.body
 511
 512     await completeVideoCheck(server.url, video, Object.assign(updateCheckAttributes, attributes))
 513   })
 514
 515   it('Should like a video', async function () {
 516     await rateVideo(server.url, server.accessToken, videoId, 'like')
 517
 518     const res = await getVideo(server.url, videoId)
 519     const video = res.body
 520
 521     expect(video.likes).to.equal(1)
 522     expect(video.dislikes).to.equal(0)
 523   })
 524
 525   it('Should dislike the same video', async function () {
 526     await rateVideo(server.url, server.accessToken, videoId, 'dislike')
 527
 528     const res = await getVideo(server.url, videoId)
 529     const video = res.body
 530
 531     expect(video.likes).to.equal(0)
 532     expect(video.dislikes).to.equal(1)
 533   })
 534
 535   after(async function () {
 536     killallServers([ server ])
 537
 538     // Keep the logs if the test failed
 539     if (this['ok']) {
 540       await flushTests()
 541     }
 542   })
 543 })