server/tests/api/single-pod.js

   1 /* eslint-disable no-unused-expressions */
   2
   3 'use strict'
   4
   5 const chai = require('chai')
   6 const each = require('async/each')
   7 const expect = chai.expect
   8 const fs = require('fs')
   9 const keyBy = require('lodash/keyBy')
  10 const pathUtils = require('path')
  11 const series = require('async/series')
  12 const webtorrent = new (require('webtorrent'))()
  13
  14 const loginUtils = require('../utils/login')
  15 const miscsUtils = require('../utils/miscs')
  16 const serversUtils = require('../utils/servers')
  17 const videosUtils = require('../utils/videos')
  18
  19 describe('Test a single pod', function () {
  20   let server = null
  21   let videoId = -1
  22   let videosListBase = null
  23
  24   before(function (done) {
  25     this.timeout(20000)
  26
  27     series([
  28       function (next) {
  29         serversUtils.flushTests(next)
  30       },
  31       function (next) {
  32         serversUtils.runServer(1, function (server1) {
  33           server = server1
  34           next()
  35         })
  36       },
  37       function (next) {
  38         loginUtils.loginAndGetAccessToken(server, function (err, token) {
  39           if (err) throw err
  40           server.accessToken = token
  41           next()
  42         })
  43       }
  44     ], done)
  45   })
  46
  47   it('Should list video categories', function (done) {
  48     videosUtils.getVideoCategories(server.url, function (err, res) {
  49       if (err) throw err
  50
  51       const categories = res.body
  52       expect(Object.keys(categories)).to.have.length.above(10)
  53
  54       expect(categories[11]).to.equal('News')
  55
  56       done()
  57     })
  58   })
  59
  60   it('Should list video licences', function (done) {
  61     videosUtils.getVideoLicences(server.url, function (err, res) {
  62       if (err) throw err
  63
  64       const licences = res.body
  65       expect(Object.keys(licences)).to.have.length.above(5)
  66
  67       expect(licences[3]).to.equal('Attribution - No Derivatives')
  68
  69       done()
  70     })
  71   })
  72
  73   it('Should list video languages', function (done) {
  74     videosUtils.getVideoLanguages(server.url, function (err, res) {
  75       if (err) throw err
  76
  77       const languages = res.body
  78       expect(Object.keys(languages)).to.have.length.above(5)
  79
  80       expect(languages[3]).to.equal('Mandarin')
  81
  82       done()
  83     })
  84   })
  85
  86   it('Should not have videos', function (done) {
  87     videosUtils.getVideosList(server.url, function (err, res) {
  88       if (err) throw err
  89
  90       expect(res.body.total).to.equal(0)
  91       expect(res.body.data).to.be.an('array')
  92       expect(res.body.data.length).to.equal(0)
  93
  94       done()
  95     })
  96   })
  97
  98   it('Should upload the video', function (done) {
  99     const videoAttributes = {
 100       name: 'my super name',
 101       category: 2,
 102       nsfw: true,
 103       licence: 6,
 104       tags: [ 'tag1', 'tag2', 'tag3' ]
 105     }
 106     videosUtils.uploadVideo(server.url, server.accessToken, videoAttributes, done)
 107   })
 108
 109   it('Should seed the uploaded video', function (done) {
 110     // Yes, this could be long
 111     this.timeout(60000)
 112
 113     videosUtils.getVideosList(server.url, function (err, res) {
 114       if (err) throw err
 115
 116       expect(res.body.total).to.equal(1)
 117       expect(res.body.data).to.be.an('array')
 118       expect(res.body.data.length).to.equal(1)
 119
 120       const video = res.body.data[0]
 121       expect(video.name).to.equal('my super name')
 122       expect(video.category).to.equal(2)
 123       expect(video.categoryLabel).to.equal('Films')
 124       expect(video.licence).to.equal(6)
 125       expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
 126       expect(video.language).to.equal(3)
 127       expect(video.languageLabel).to.equal('Mandarin')
 128       expect(video.nsfw).to.be.truthy
 129       expect(video.description).to.equal('my super description')
 130       expect(video.podHost).to.equal('localhost:9001')
 131       expect(video.magnetUri).to.exist
 132       expect(video.author).to.equal('root')
 133       expect(video.isLocal).to.be.true
 134       expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
 135       expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
 136       expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
 137
 138       videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
 139         if (err) throw err
 140         expect(test).to.equal(true)
 141
 142         videoId = video.id
 143
 144         webtorrent.add(video.magnetUri, function (torrent) {
 145           expect(torrent.files).to.exist
 146           expect(torrent.files.length).to.equal(1)
 147           expect(torrent.files[0].path).to.exist.and.to.not.equal('')
 148
 149           done()
 150         })
 151       })
 152     })
 153   })
 154
 155   it('Should get the video', function (done) {
 156     // Yes, this could be long
 157     this.timeout(60000)
 158
 159     videosUtils.getVideo(server.url, videoId, function (err, res) {
 160       if (err) throw err
 161
 162       const video = res.body
 163       expect(video.name).to.equal('my super name')
 164       expect(video.category).to.equal(2)
 165       expect(video.categoryLabel).to.equal('Films')
 166       expect(video.licence).to.equal(6)
 167       expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
 168       expect(video.language).to.equal(3)
 169       expect(video.languageLabel).to.equal('Mandarin')
 170       expect(video.nsfw).to.be.truthy
 171       expect(video.description).to.equal('my super description')
 172       expect(video.podHost).to.equal('localhost:9001')
 173       expect(video.magnetUri).to.exist
 174       expect(video.author).to.equal('root')
 175       expect(video.isLocal).to.be.true
 176       expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
 177       expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
 178       expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
 179
 180       videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
 181         if (err) throw err
 182         expect(test).to.equal(true)
 183
 184         done()
 185       })
 186     })
 187   })
 188
 189   it('Should have the views updated', function (done) {
 190     videosUtils.getVideo(server.url, videoId, function (err, res) {
 191       if (err) throw err
 192
 193       const video = res.body
 194       expect(video.views).to.equal(1)
 195
 196       done()
 197     })
 198   })
 199
 200   it('Should search the video by name by default', function (done) {
 201     videosUtils.searchVideo(server.url, 'my', function (err, res) {
 202       if (err) throw err
 203
 204       expect(res.body.total).to.equal(1)
 205       expect(res.body.data).to.be.an('array')
 206       expect(res.body.data.length).to.equal(1)
 207
 208       const video = res.body.data[0]
 209       expect(video.name).to.equal('my super name')
 210       expect(video.category).to.equal(2)
 211       expect(video.categoryLabel).to.equal('Films')
 212       expect(video.licence).to.equal(6)
 213       expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
 214       expect(video.language).to.equal(3)
 215       expect(video.languageLabel).to.equal('Mandarin')
 216       expect(video.nsfw).to.be.truthy
 217       expect(video.description).to.equal('my super description')
 218       expect(video.podHost).to.equal('localhost:9001')
 219       expect(video.author).to.equal('root')
 220       expect(video.isLocal).to.be.true
 221       expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
 222       expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
 223       expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
 224
 225       videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
 226         if (err) throw err
 227         expect(test).to.equal(true)
 228
 229         done()
 230       })
 231     })
 232   })
 233
 234   // Not implemented yet
 235   // it('Should search the video by podHost', function (done) {
 236   //   videosUtils.searchVideo(server.url, '9001', 'host', function (err, res) {
 237   //     if (err) throw err
 238
 239   //     expect(res.body.total).to.equal(1)
 240   //     expect(res.body.data).to.be.an('array')
 241   //     expect(res.body.data.length).to.equal(1)
 242
 243   //     const video = res.body.data[0]
 244   //     expect(video.name).to.equal('my super name')
 245   //     expect(video.description).to.equal('my super description')
 246   //     expect(video.podHost).to.equal('localhost:9001')
 247   //     expect(video.author).to.equal('root')
 248   //     expect(video.isLocal).to.be.true
 249   //     expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
 250   //     expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
 251   //     expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
 252
 253   //     videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
 254   //       if (err) throw err
 255   //       expect(test).to.equal(true)
 256
 257   //       done()
 258   //     })
 259   //   })
 260   // })
 261
 262   it('Should search the video by tag', function (done) {
 263     videosUtils.searchVideo(server.url, 'tag1', 'tags', function (err, res) {
 264       if (err) throw err
 265
 266       expect(res.body.total).to.equal(1)
 267       expect(res.body.data).to.be.an('array')
 268       expect(res.body.data.length).to.equal(1)
 269
 270       const video = res.body.data[0]
 271       expect(video.name).to.equal('my super name')
 272       expect(video.category).to.equal(2)
 273       expect(video.categoryLabel).to.equal('Films')
 274       expect(video.licence).to.equal(6)
 275       expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
 276       expect(video.language).to.equal(3)
 277       expect(video.languageLabel).to.equal('Mandarin')
 278       expect(video.nsfw).to.be.truthy
 279       expect(video.description).to.equal('my super description')
 280       expect(video.podHost).to.equal('localhost:9001')
 281       expect(video.author).to.equal('root')
 282       expect(video.isLocal).to.be.true
 283       expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
 284       expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
 285       expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
 286
 287       videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
 288         if (err) throw err
 289         expect(test).to.equal(true)
 290
 291         done()
 292       })
 293     })
 294   })
 295
 296   it('Should not find a search by name by default', function (done) {
 297     videosUtils.searchVideo(server.url, 'hello', function (err, res) {
 298       if (err) throw err
 299
 300       expect(res.body.total).to.equal(0)
 301       expect(res.body.data).to.be.an('array')
 302       expect(res.body.data.length).to.equal(0)
 303
 304       done()
 305     })
 306   })
 307
 308   it('Should not find a search by author', function (done) {
 309     videosUtils.searchVideo(server.url, 'hello', 'author', function (err, res) {
 310       if (err) throw err
 311
 312       expect(res.body.total).to.equal(0)
 313       expect(res.body.data).to.be.an('array')
 314       expect(res.body.data.length).to.equal(0)
 315
 316       done()
 317     })
 318   })
 319
 320   it('Should not find a search by tag', function (done) {
 321     videosUtils.searchVideo(server.url, 'hello', 'tags', function (err, res) {
 322       if (err) throw err
 323
 324       expect(res.body.total).to.equal(0)
 325       expect(res.body.data).to.be.an('array')
 326       expect(res.body.data.length).to.equal(0)
 327
 328       done()
 329     })
 330   })
 331
 332   it('Should remove the video', function (done) {
 333     videosUtils.removeVideo(server.url, server.accessToken, videoId, function (err) {
 334       if (err) throw err
 335
 336       fs.readdir(pathUtils.join(__dirname, '..', '..', '..', 'test1/videos/'), function (err, files) {
 337         if (err) throw err
 338
 339         expect(files.length).to.equal(0)
 340
 341         fs.readdir(pathUtils.join(__dirname, '..', '..', '..', 'test1/thumbnails/'), function (err, files) {
 342           if (err) throw err
 343
 344           expect(files.length).to.equal(0)
 345
 346           done()
 347         })
 348       })
 349     })
 350   })
 351
 352   it('Should not have videos', function (done) {
 353     videosUtils.getVideosList(server.url, function (err, res) {
 354       if (err) throw err
 355
 356       expect(res.body.total).to.equal(0)
 357       expect(res.body.data).to.be.an('array')
 358       expect(res.body.data.length).to.equal(0)
 359
 360       done()
 361     })
 362   })
 363
 364   it('Should upload 6 videos', function (done) {
 365     this.timeout(25000)
 366     const videos = [
 367       'video_short.mp4', 'video_short.ogv', 'video_short.webm',
 368       'video_short1.webm', 'video_short2.webm', 'video_short3.webm'
 369     ]
 370     each(videos, function (video, callbackEach) {
 371       const videoAttributes = {
 372         name: video + ' name',
 373         description: video + ' description',
 374         category: 2,
 375         licence: 1,
 376         language: 1,
 377         nsfw: true,
 378         tags: [ 'tag1', 'tag2', 'tag3' ],
 379         fixture: video
 380       }
 381
 382       videosUtils.uploadVideo(server.url, server.accessToken, videoAttributes, callbackEach)
 383     }, done)
 384   })
 385
 386   it('Should have the correct durations', function (done) {
 387     videosUtils.getVideosList(server.url, function (err, res) {
 388       if (err) throw err
 389
 390       expect(res.body.total).to.equal(6)
 391       const videos = res.body.data
 392       expect(videos).to.be.an('array')
 393       expect(videos.length).to.equal(6)
 394
 395       const videosByName = keyBy(videos, 'name')
 396       expect(videosByName['video_short.mp4 name'].duration).to.equal(5)
 397       expect(videosByName['video_short.ogv name'].duration).to.equal(5)
 398       expect(videosByName['video_short.webm name'].duration).to.equal(5)
 399       expect(videosByName['video_short1.webm name'].duration).to.equal(10)
 400       expect(videosByName['video_short2.webm name'].duration).to.equal(5)
 401       expect(videosByName['video_short3.webm name'].duration).to.equal(5)
 402
 403       done()
 404     })
 405   })
 406
 407   it('Should have the correct thumbnails', function (done) {
 408     videosUtils.getVideosList(server.url, function (err, res) {
 409       if (err) throw err
 410
 411       const videos = res.body.data
 412       // For the next test
 413       videosListBase = videos
 414
 415       each(videos, function (video, callbackEach) {
 416         if (err) throw err
 417         const videoName = video.name.replace(' name', '')
 418
 419         videosUtils.testVideoImage(server.url, videoName, video.thumbnailPath, function (err, test) {
 420           if (err) throw err
 421
 422           expect(test).to.equal(true)
 423           callbackEach()
 424         })
 425       }, done)
 426     })
 427   })
 428
 429   it('Should list only the two first videos', function (done) {
 430     videosUtils.getVideosListPagination(server.url, 0, 2, 'name', function (err, res) {
 431       if (err) throw err
 432
 433       const videos = res.body.data
 434       expect(res.body.total).to.equal(6)
 435       expect(videos.length).to.equal(2)
 436       expect(videos[0].name).to.equal(videosListBase[0].name)
 437       expect(videos[1].name).to.equal(videosListBase[1].name)
 438
 439       done()
 440     })
 441   })
 442
 443   it('Should list only the next three videos', function (done) {
 444     videosUtils.getVideosListPagination(server.url, 2, 3, 'name', function (err, res) {
 445       if (err) throw err
 446
 447       const videos = res.body.data
 448       expect(res.body.total).to.equal(6)
 449       expect(videos.length).to.equal(3)
 450       expect(videos[0].name).to.equal(videosListBase[2].name)
 451       expect(videos[1].name).to.equal(videosListBase[3].name)
 452       expect(videos[2].name).to.equal(videosListBase[4].name)
 453
 454       done()
 455     })
 456   })
 457
 458   it('Should list the last video', function (done) {
 459     videosUtils.getVideosListPagination(server.url, 5, 6, 'name', function (err, res) {
 460       if (err) throw err
 461
 462       const videos = res.body.data
 463       expect(res.body.total).to.equal(6)
 464       expect(videos.length).to.equal(1)
 465       expect(videos[0].name).to.equal(videosListBase[5].name)
 466
 467       done()
 468     })
 469   })
 470
 471   it('Should search the first video', function (done) {
 472     videosUtils.searchVideoWithPagination(server.url, 'webm', 'name', 0, 1, 'name', function (err, res) {
 473       if (err) throw err
 474
 475       const videos = res.body.data
 476       expect(res.body.total).to.equal(4)
 477       expect(videos.length).to.equal(1)
 478       expect(videos[0].name).to.equal('video_short1.webm name')
 479
 480       done()
 481     })
 482   })
 483
 484   it('Should search the last two videos', function (done) {
 485     videosUtils.searchVideoWithPagination(server.url, 'webm', 'name', 2, 2, 'name', function (err, res) {
 486       if (err) throw err
 487
 488       const videos = res.body.data
 489       expect(res.body.total).to.equal(4)
 490       expect(videos.length).to.equal(2)
 491       expect(videos[0].name).to.equal('video_short3.webm name')
 492       expect(videos[1].name).to.equal('video_short.webm name')
 493
 494       done()
 495     })
 496   })
 497
 498   it('Should search all the webm videos', function (done) {
 499     videosUtils.searchVideoWithPagination(server.url, 'webm', 'name', 0, 15, function (err, res) {
 500       if (err) throw err
 501
 502       const videos = res.body.data
 503       expect(res.body.total).to.equal(4)
 504       expect(videos.length).to.equal(4)
 505
 506       done()
 507     })
 508   })
 509
 510   it('Should search all the root author videos', function (done) {
 511     videosUtils.searchVideoWithPagination(server.url, 'root', 'author', 0, 15, function (err, res) {
 512       if (err) throw err
 513
 514       const videos = res.body.data
 515       expect(res.body.total).to.equal(6)
 516       expect(videos.length).to.equal(6)
 517
 518       done()
 519     })
 520   })
 521
 522   // Not implemented yet
 523   // it('Should search all the 9001 port videos', function (done) {
 524   //   videosUtils.searchVideoWithPagination(server.url, '9001', 'host', 0, 15, function (err, res) {
 525   //     if (err) throw err
 526
 527   //     const videos = res.body.data
 528   //     expect(res.body.total).to.equal(6)
 529   //     expect(videos.length).to.equal(6)
 530
 531   //     done()
 532   //   })
 533   // })
 534
 535   // it('Should search all the localhost videos', function (done) {
 536   //   videosUtils.searchVideoWithPagination(server.url, 'localhost', 'host', 0, 15, function (err, res) {
 537   //     if (err) throw err
 538
 539   //     const videos = res.body.data
 540   //     expect(res.body.total).to.equal(6)
 541   //     expect(videos.length).to.equal(6)
 542
 543   //     done()
 544   //   })
 545   // })
 546
 547   it('Should search the right magnetUri video', function (done) {
 548     const video = videosListBase[0]
 549     videosUtils.searchVideoWithPagination(server.url, encodeURIComponent(video.magnetUri), 'magnetUri', 0, 15, function (err, res) {
 550       if (err) throw err
 551
 552       const videos = res.body.data
 553       expect(res.body.total).to.equal(1)
 554       expect(videos.length).to.equal(1)
 555       expect(videos[0].name).to.equal(video.name)
 556
 557       done()
 558     })
 559   })
 560
 561   it('Should list and sort by name in descending order', function (done) {
 562     videosUtils.getVideosListSort(server.url, '-name', function (err, res) {
 563       if (err) throw err
 564
 565       const videos = res.body.data
 566       expect(res.body.total).to.equal(6)
 567       expect(videos.length).to.equal(6)
 568       expect(videos[0].name).to.equal('video_short.webm name')
 569       expect(videos[1].name).to.equal('video_short.ogv name')
 570       expect(videos[2].name).to.equal('video_short.mp4 name')
 571       expect(videos[3].name).to.equal('video_short3.webm name')
 572       expect(videos[4].name).to.equal('video_short2.webm name')
 573       expect(videos[5].name).to.equal('video_short1.webm name')
 574
 575       done()
 576     })
 577   })
 578
 579   it('Should search and sort by name in ascending order', function (done) {
 580     videosUtils.searchVideoWithSort(server.url, 'webm', 'name', function (err, res) {
 581       if (err) throw err
 582
 583       const videos = res.body.data
 584       expect(res.body.total).to.equal(4)
 585       expect(videos.length).to.equal(4)
 586
 587       expect(videos[0].name).to.equal('video_short1.webm name')
 588       expect(videos[1].name).to.equal('video_short2.webm name')
 589       expect(videos[2].name).to.equal('video_short3.webm name')
 590       expect(videos[3].name).to.equal('video_short.webm name')
 591
 592       videoId = videos[2].id
 593
 594       done()
 595     })
 596   })
 597
 598   it('Should update a video', function (done) {
 599     const attributes = {
 600       name: 'my super video updated',
 601       category: 4,
 602       licence: 2,
 603       language: 5,
 604       nsfw: false,
 605       description: 'my super description updated',
 606       tags: [ 'tagup1', 'tagup2' ]
 607     }
 608     videosUtils.updateVideo(server.url, server.accessToken, videoId, attributes, done)
 609   })
 610
 611   it('Should have the video updated', function (done) {
 612     this.timeout(60000)
 613
 614     videosUtils.getVideo(server.url, videoId, function (err, res) {
 615       if (err) throw err
 616
 617       const video = res.body
 618
 619       expect(video.name).to.equal('my super video updated')
 620       expect(video.category).to.equal(4)
 621       expect(video.categoryLabel).to.equal('Art')
 622       expect(video.licence).to.equal(2)
 623       expect(video.licenceLabel).to.equal('Attribution - Share Alike')
 624       expect(video.language).to.equal(5)
 625       expect(video.languageLabel).to.equal('Arabic')
 626       expect(video.nsfw).to.be.truthy
 627       expect(video.description).to.equal('my super description updated')
 628       expect(video.podHost).to.equal('localhost:9001')
 629       expect(video.author).to.equal('root')
 630       expect(video.isLocal).to.be.true
 631       expect(video.tags).to.deep.equal([ 'tagup1', 'tagup2' ])
 632       expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
 633       expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
 634
 635       videosUtils.testVideoImage(server.url, 'video_short3.webm', video.thumbnailPath, function (err, test) {
 636         if (err) throw err
 637         expect(test).to.equal(true)
 638
 639         webtorrent.add(video.magnetUri, function (torrent) {
 640           expect(torrent.files).to.exist
 641           expect(torrent.files.length).to.equal(1)
 642           expect(torrent.files[0].path).to.exist.and.to.not.equal('')
 643
 644           done()
 645         })
 646       })
 647     })
 648   })
 649
 650   it('Should update only the tags of a video', function (done) {
 651     const attributes = {
 652       tags: [ 'tag1', 'tag2', 'supertag' ]
 653     }
 654
 655     videosUtils.updateVideo(server.url, server.accessToken, videoId, attributes, function (err) {
 656       if (err) throw err
 657
 658       videosUtils.getVideo(server.url, videoId, function (err, res) {
 659         if (err) throw err
 660
 661         const video = res.body
 662
 663         expect(video.name).to.equal('my super video updated')
 664         expect(video.category).to.equal(4)
 665         expect(video.categoryLabel).to.equal('Art')
 666         expect(video.licence).to.equal(2)
 667         expect(video.licenceLabel).to.equal('Attribution - Share Alike')
 668         expect(video.language).to.equal(5)
 669         expect(video.languageLabel).to.equal('Arabic')
 670         expect(video.nsfw).to.be.truthy
 671         expect(video.description).to.equal('my super description updated')
 672         expect(video.podHost).to.equal('localhost:9001')
 673         expect(video.author).to.equal('root')
 674         expect(video.isLocal).to.be.true
 675         expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'supertag' ])
 676         expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
 677         expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
 678
 679         done()
 680       })
 681     })
 682   })
 683
 684   it('Should update only the description of a video', function (done) {
 685     const attributes = {
 686       description: 'hello everybody'
 687     }
 688
 689     videosUtils.updateVideo(server.url, server.accessToken, videoId, attributes, function (err) {
 690       if (err) throw err
 691
 692       videosUtils.getVideo(server.url, videoId, function (err, res) {
 693         if (err) throw err
 694
 695         const video = res.body
 696
 697         expect(video.name).to.equal('my super video updated')
 698         expect(video.category).to.equal(4)
 699         expect(video.categoryLabel).to.equal('Art')
 700         expect(video.licence).to.equal(2)
 701         expect(video.licenceLabel).to.equal('Attribution - Share Alike')
 702         expect(video.language).to.equal(5)
 703         expect(video.languageLabel).to.equal('Arabic')
 704         expect(video.nsfw).to.be.truthy
 705         expect(video.description).to.equal('hello everybody')
 706         expect(video.podHost).to.equal('localhost:9001')
 707         expect(video.author).to.equal('root')
 708         expect(video.isLocal).to.be.true
 709         expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'supertag' ])
 710         expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
 711         expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
 712
 713         done()
 714       })
 715     })
 716   })
 717
 718   it('Should like a video', function (done) {
 719     videosUtils.rateVideo(server.url, server.accessToken, videoId, 'like', function (err) {
 720       if (err) throw err
 721
 722       videosUtils.getVideo(server.url, videoId, function (err, res) {
 723         if (err) throw err
 724
 725         const video = res.body
 726
 727         expect(video.likes).to.equal(1)
 728         expect(video.dislikes).to.equal(0)
 729
 730         done()
 731       })
 732     })
 733   })
 734
 735   it('Should dislike the same video', function (done) {
 736     videosUtils.rateVideo(server.url, server.accessToken, videoId, 'dislike', function (err) {
 737       if (err) throw err
 738
 739       videosUtils.getVideo(server.url, videoId, function (err, res) {
 740         if (err) throw err
 741
 742         const video = res.body
 743
 744         expect(video.likes).to.equal(0)
 745         expect(video.dislikes).to.equal(1)
 746
 747         done()
 748       })
 749     })
 750   })
 751
 752   after(function (done) {
 753     process.kill(-server.app.pid)
 754
 755     // Keep the logs if the test failed
 756     if (this.ok) {
 757       serversUtils.flushTests(done)
 758     } else {
 759       done()
 760     }
 761   })
 762 })