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