server/tests/api/single-pod.js

   1 'use strict'
   2
   3 const chai = require('chai')
   4 const each = require('async/each')
   5 const expect = chai.expect
   6 const fs = require('fs')
   7 const keyBy = require('lodash/keyBy')
   8 const pathUtils = require('path')
   9 const series = require('async/series')
  10 const webtorrent = new (require('webtorrent'))()
  11
  12 const loginUtils = require('../utils/login')
  13 const miscsUtils = require('../utils/miscs')
  14 const serversUtils = require('../utils/servers')
  15 const videosUtils = require('../utils/videos')
  16
  17 describe('Test a single pod', function () {
  18   let server = null
  19   let videoId = -1
  20   let videosListBase = null
  21
  22   before(function (done) {
  23     this.timeout(20000)
  24
  25     series([
  26       function (next) {
  27         serversUtils.flushTests(next)
  28       },
  29       function (next) {
  30         serversUtils.runServer(1, function (server1) {
  31           server = server1
  32           next()
  33         })
  34       },
  35       function (next) {
  36         loginUtils.loginAndGetAccessToken(server, function (err, token) {
  37           if (err) throw err
  38           server.accessToken = token
  39           next()
  40         })
  41       }
  42     ], done)
  43   })
  44
  45   it('Should not have videos', function (done) {
  46     videosUtils.getVideosList(server.url, function (err, res) {
  47       if (err) throw err
  48
  49       expect(res.body.total).to.equal(0)
  50       expect(res.body.data).to.be.an('array')
  51       expect(res.body.data.length).to.equal(0)
  52
  53       done()
  54     })
  55   })
  56
  57   it('Should upload the video', function (done) {
  58     this.timeout(5000)
  59     const name = 'my super name'
  60     const description = 'my super description'
  61     const tags = [ 'tag1', 'tag2', 'tag3' ]
  62     const file = 'video_short.webm'
  63     videosUtils.uploadVideo(server.url, server.accessToken, name, description, tags, file, done)
  64   })
  65
  66   it('Should seed the uploaded video', function (done) {
  67     // Yes, this could be long
  68     this.timeout(60000)
  69
  70     videosUtils.getVideosList(server.url, function (err, res) {
  71       if (err) throw err
  72
  73       expect(res.body.total).to.equal(1)
  74       expect(res.body.data).to.be.an('array')
  75       expect(res.body.data.length).to.equal(1)
  76
  77       const video = res.body.data[0]
  78       expect(video.name).to.equal('my super name')
  79       expect(video.description).to.equal('my super description')
  80       expect(video.podUrl).to.equal('localhost:9001')
  81       expect(video.magnetUri).to.exist
  82       expect(video.author).to.equal('root')
  83       expect(video.isLocal).to.be.true
  84       expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
  85       expect(miscsUtils.dateIsValid(video.createdDate)).to.be.true
  86
  87       videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
  88         if (err) throw err
  89         expect(test).to.equal(true)
  90
  91         videoId = video.id
  92
  93         webtorrent.add(video.magnetUri, function (torrent) {
  94           expect(torrent.files).to.exist
  95           expect(torrent.files.length).to.equal(1)
  96           expect(torrent.files[0].path).to.exist.and.to.not.equal('')
  97
  98           done()
  99         })
 100       })
 101     })
 102   })
 103
 104   it('Should get the video', function (done) {
 105     // Yes, this could be long
 106     this.timeout(60000)
 107
 108     videosUtils.getVideo(server.url, videoId, function (err, res) {
 109       if (err) throw err
 110
 111       const video = res.body
 112       expect(video.name).to.equal('my super name')
 113       expect(video.description).to.equal('my super description')
 114       expect(video.podUrl).to.equal('localhost:9001')
 115       expect(video.magnetUri).to.exist
 116       expect(video.author).to.equal('root')
 117       expect(video.isLocal).to.be.true
 118       expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
 119       expect(miscsUtils.dateIsValid(video.createdDate)).to.be.true
 120
 121       videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
 122         if (err) throw err
 123         expect(test).to.equal(true)
 124
 125         done()
 126       })
 127     })
 128   })
 129
 130   it('Should search the video by name by default', function (done) {
 131     videosUtils.searchVideo(server.url, 'my', function (err, res) {
 132       if (err) throw err
 133
 134       expect(res.body.total).to.equal(1)
 135       expect(res.body.data).to.be.an('array')
 136       expect(res.body.data.length).to.equal(1)
 137
 138       const video = res.body.data[0]
 139       expect(video.name).to.equal('my super name')
 140       expect(video.description).to.equal('my super description')
 141       expect(video.podUrl).to.equal('localhost:9001')
 142       expect(video.author).to.equal('root')
 143       expect(video.isLocal).to.be.true
 144       expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
 145       expect(miscsUtils.dateIsValid(video.createdDate)).to.be.true
 146
 147       videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
 148         if (err) throw err
 149         expect(test).to.equal(true)
 150
 151         done()
 152       })
 153     })
 154   })
 155
 156   it('Should search the video by podUrl', function (done) {
 157     videosUtils.searchVideo(server.url, '9001', 'podUrl', function (err, res) {
 158       if (err) throw err
 159
 160       expect(res.body.total).to.equal(1)
 161       expect(res.body.data).to.be.an('array')
 162       expect(res.body.data.length).to.equal(1)
 163
 164       const video = res.body.data[0]
 165       expect(video.name).to.equal('my super name')
 166       expect(video.description).to.equal('my super description')
 167       expect(video.podUrl).to.equal('localhost:9001')
 168       expect(video.author).to.equal('root')
 169       expect(video.isLocal).to.be.true
 170       expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
 171       expect(miscsUtils.dateIsValid(video.createdDate)).to.be.true
 172
 173       videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
 174         if (err) throw err
 175         expect(test).to.equal(true)
 176
 177         done()
 178       })
 179     })
 180   })
 181
 182   it('Should search the video by tag', function (done) {
 183     videosUtils.searchVideo(server.url, 'tag1', 'tags', function (err, res) {
 184       if (err) throw err
 185
 186       expect(res.body.total).to.equal(1)
 187       expect(res.body.data).to.be.an('array')
 188       expect(res.body.data.length).to.equal(1)
 189
 190       const video = res.body.data[0]
 191       expect(video.name).to.equal('my super name')
 192       expect(video.description).to.equal('my super description')
 193       expect(video.podUrl).to.equal('localhost:9001')
 194       expect(video.author).to.equal('root')
 195       expect(video.isLocal).to.be.true
 196       expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
 197       expect(miscsUtils.dateIsValid(video.createdDate)).to.be.true
 198
 199       videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
 200         if (err) throw err
 201         expect(test).to.equal(true)
 202
 203         done()
 204       })
 205     })
 206   })
 207
 208   it('Should not find a search by name by default', function (done) {
 209     videosUtils.searchVideo(server.url, 'hello', function (err, res) {
 210       if (err) throw err
 211
 212       expect(res.body.total).to.equal(0)
 213       expect(res.body.data).to.be.an('array')
 214       expect(res.body.data.length).to.equal(0)
 215
 216       done()
 217     })
 218   })
 219
 220   it('Should not find a search by author', function (done) {
 221     videosUtils.searchVideo(server.url, 'hello', 'author', function (err, res) {
 222       if (err) throw err
 223
 224       expect(res.body.total).to.equal(0)
 225       expect(res.body.data).to.be.an('array')
 226       expect(res.body.data.length).to.equal(0)
 227
 228       done()
 229     })
 230   })
 231
 232   it('Should not find a search by tag', function (done) {
 233     videosUtils.searchVideo(server.url, 'tag', 'tags', function (err, res) {
 234       if (err) throw err
 235
 236       expect(res.body.total).to.equal(0)
 237       expect(res.body.data).to.be.an('array')
 238       expect(res.body.data.length).to.equal(0)
 239
 240       done()
 241     })
 242   })
 243
 244   it('Should remove the video', function (done) {
 245     videosUtils.removeVideo(server.url, server.accessToken, videoId, function (err) {
 246       if (err) throw err
 247
 248       fs.readdir(pathUtils.join(__dirname, '../../../test1/videos/'), function (err, files) {
 249         if (err) throw err
 250
 251         expect(files.length).to.equal(0)
 252
 253         fs.readdir(pathUtils.join(__dirname, '../../../test1/thumbnails/'), function (err, files) {
 254           if (err) throw err
 255
 256           expect(files.length).to.equal(0)
 257
 258           done()
 259         })
 260       })
 261     })
 262   })
 263
 264   it('Should not have videos', function (done) {
 265     videosUtils.getVideosList(server.url, function (err, res) {
 266       if (err) throw err
 267
 268       expect(res.body.total).to.equal(0)
 269       expect(res.body.data).to.be.an('array')
 270       expect(res.body.data.length).to.equal(0)
 271
 272       done()
 273     })
 274   })
 275
 276   it('Should upload 6 videos', function (done) {
 277     this.timeout(25000)
 278     const videos = [
 279       'video_short.mp4', 'video_short.ogv', 'video_short.webm',
 280       'video_short1.webm', 'video_short2.webm', 'video_short3.webm'
 281     ]
 282     each(videos, function (video, callbackEach) {
 283       const name = video + ' name'
 284       const description = video + ' description'
 285       const tags = [ 'tag1', 'tag2', 'tag3' ]
 286
 287       videosUtils.uploadVideo(server.url, server.accessToken, name, description, tags, video, callbackEach)
 288     }, done)
 289   })
 290
 291   it('Should have the correct durations', function (done) {
 292     videosUtils.getVideosList(server.url, function (err, res) {
 293       if (err) throw err
 294
 295       expect(res.body.total).to.equal(6)
 296       const videos = res.body.data
 297       expect(videos).to.be.an('array')
 298       expect(videos.length).to.equal(6)
 299
 300       const videosByName = keyBy(videos, 'name')
 301       expect(videosByName['video_short.mp4 name'].duration).to.equal(5)
 302       expect(videosByName['video_short.ogv name'].duration).to.equal(5)
 303       expect(videosByName['video_short.webm name'].duration).to.equal(5)
 304       expect(videosByName['video_short1.webm name'].duration).to.equal(10)
 305       expect(videosByName['video_short2.webm name'].duration).to.equal(5)
 306       expect(videosByName['video_short3.webm name'].duration).to.equal(5)
 307
 308       done()
 309     })
 310   })
 311
 312   it('Should have the correct thumbnails', function (done) {
 313     videosUtils.getVideosList(server.url, function (err, res) {
 314       if (err) throw err
 315
 316       const videos = res.body.data
 317       // For the next test
 318       videosListBase = videos
 319
 320       each(videos, function (video, callbackEach) {
 321         if (err) throw err
 322         const videoName = video.name.replace(' name', '')
 323
 324         videosUtils.testVideoImage(server.url, videoName, video.thumbnailPath, function (err, test) {
 325           if (err) throw err
 326
 327           expect(test).to.equal(true)
 328           callbackEach()
 329         })
 330       }, done)
 331     })
 332   })
 333
 334   it('Should list only the two first videos', function (done) {
 335     videosUtils.getVideosListPagination(server.url, 0, 2, function (err, res) {
 336       if (err) throw err
 337
 338       const videos = res.body.data
 339       expect(res.body.total).to.equal(6)
 340       expect(videos.length).to.equal(2)
 341       expect(videos[0].name === videosListBase[0].name)
 342       expect(videos[1].name === videosListBase[1].name)
 343
 344       done()
 345     })
 346   })
 347
 348   it('Should list only the next three videos', function (done) {
 349     videosUtils.getVideosListPagination(server.url, 2, 3, function (err, res) {
 350       if (err) throw err
 351
 352       const videos = res.body.data
 353       expect(res.body.total).to.equal(6)
 354       expect(videos.length).to.equal(3)
 355       expect(videos[0].name === videosListBase[2].name)
 356       expect(videos[1].name === videosListBase[3].name)
 357       expect(videos[2].name === videosListBase[4].name)
 358
 359       done()
 360     })
 361   })
 362
 363   it('Should list the last video', function (done) {
 364     videosUtils.getVideosListPagination(server.url, 5, 6, function (err, res) {
 365       if (err) throw err
 366
 367       const videos = res.body.data
 368       expect(res.body.total).to.equal(6)
 369       expect(videos.length).to.equal(1)
 370       expect(videos[0].name === videosListBase[5].name)
 371
 372       done()
 373     })
 374   })
 375
 376   it('Should search the first video', function (done) {
 377     videosUtils.searchVideoWithPagination(server.url, 'webm', 'name', 0, 1, function (err, res) {
 378       if (err) throw err
 379
 380       const videos = res.body.data
 381       expect(res.body.total).to.equal(4)
 382       expect(videos.length).to.equal(1)
 383       expect(videos[0].name === 'video_short.webm name')
 384
 385       done()
 386     })
 387   })
 388
 389   it('Should search the last two videos', function (done) {
 390     videosUtils.searchVideoWithPagination(server.url, 'webm', 'name', 2, 2, function (err, res) {
 391       if (err) throw err
 392
 393       const videos = res.body.data
 394       expect(res.body.total).to.equal(4)
 395       expect(videos.length).to.equal(2)
 396       expect(videos[0].name === 'video_short2.webm name')
 397       expect(videos[1].name === 'video_short3.webm name')
 398
 399       done()
 400     })
 401   })
 402
 403   it('Should search all the webm videos', function (done) {
 404     videosUtils.searchVideoWithPagination(server.url, 'webm', 'name', 0, 15, function (err, res) {
 405       if (err) throw err
 406
 407       const videos = res.body.data
 408       expect(res.body.total).to.equal(4)
 409       expect(videos.length).to.equal(4)
 410
 411       done()
 412     })
 413   })
 414
 415   it('Should search all the root author videos', function (done) {
 416     videosUtils.searchVideoWithPagination(server.url, 'root', 'author', 0, 15, function (err, res) {
 417       if (err) throw err
 418
 419       const videos = res.body.data
 420       expect(res.body.total).to.equal(6)
 421       expect(videos.length).to.equal(6)
 422
 423       done()
 424     })
 425   })
 426
 427   it('Should search all the 9001 port videos', function (done) {
 428     videosUtils.searchVideoWithPagination(server.url, '9001', 'podUrl', 0, 15, function (err, res) {
 429       if (err) throw err
 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 search all the localhost videos', function (done) {
 440     videosUtils.searchVideoWithPagination(server.url, 'localhost', 'podUrl', 0, 15, function (err, res) {
 441       if (err) throw err
 442
 443       const videos = res.body.data
 444       expect(res.body.total).to.equal(6)
 445       expect(videos.length).to.equal(6)
 446
 447       done()
 448     })
 449   })
 450
 451   it('Should search the good magnetUri video', function (done) {
 452     const video = videosListBase[0]
 453     videosUtils.searchVideoWithPagination(server.url, encodeURIComponent(video.magnetUri), 'magnetUri', 0, 15, function (err, res) {
 454       if (err) throw err
 455
 456       const videos = res.body.data
 457       expect(res.body.total).to.equal(1)
 458       expect(videos.length).to.equal(1)
 459       expect(videos[0].name).to.equal(video.name)
 460
 461       done()
 462     })
 463   })
 464
 465   it('Should list and sort by name in descending order', function (done) {
 466     videosUtils.getVideosListSort(server.url, '-name', function (err, res) {
 467       if (err) throw err
 468
 469       const videos = res.body.data
 470       expect(res.body.total).to.equal(6)
 471       expect(videos.length).to.equal(6)
 472       expect(videos[5].name === 'video_short.mp4 name')
 473       expect(videos[4].name === 'video_short.ogv name')
 474       expect(videos[3].name === 'video_short.webm name')
 475       expect(videos[2].name === 'video_short1.webm name')
 476       expect(videos[1].name === 'video_short2.webm name')
 477       expect(videos[0].name === 'video_short3.webm name')
 478
 479       done()
 480     })
 481   })
 482
 483   it('Should search and sort by name in ascending order', function (done) {
 484     videosUtils.searchVideoWithSort(server.url, 'webm', 'name', function (err, res) {
 485       if (err) throw err
 486
 487       const videos = res.body.data
 488       expect(res.body.total).to.equal(4)
 489       expect(videos.length).to.equal(4)
 490
 491       expect(videos[0].name === 'video_short.webm name')
 492       expect(videos[1].name === 'video_short1.webm name')
 493       expect(videos[2].name === 'video_short2.webm name')
 494       expect(videos[3].name === 'video_short3.webm name')
 495
 496       done()
 497     })
 498   })
 499
 500   after(function (done) {
 501     process.kill(-server.app.pid)
 502
 503     // Keep the logs if the test failed
 504     if (this.ok) {
 505       serversUtils.flushTests(done)
 506     } else {
 507       done()
 508     }
 509   })
 510 })