server/tests/api/multiplePods.js

   1 'use strict'
   2
   3 const async = require('async')
   4 const chai = require('chai')
   5 const expect = chai.expect
   6 const pathUtils = require('path')
   7
   8 const utils = require('./utils')
   9 const webtorrent = require(pathUtils.join(__dirname, '../../lib/webtorrent'))
  10 webtorrent.silent = true
  11
  12 describe('Test multiple pods', function () {
  13   let servers = []
  14   const to_remove = []
  15
  16   before(function (done) {
  17     this.timeout(30000)
  18
  19     async.series([
  20       // Run servers
  21       function (next) {
  22         utils.flushAndRunMultipleServers(3, function (servers_run) {
  23           servers = servers_run
  24           next()
  25         })
  26       },
  27       // Get the access tokens
  28       function (next) {
  29         async.each(servers, function (server, callback_each) {
  30           utils.loginAndGetAccessToken(server, function (err, access_token) {
  31             if (err) return callback_each(err)
  32
  33             server.access_token = access_token
  34             callback_each()
  35           })
  36         }, next)
  37       },
  38       // The second pod make friend with the third
  39       function (next) {
  40         utils.makeFriends(servers[1].url, next)
  41       },
  42       // Wait for the request between pods
  43       function (next) {
  44         setTimeout(next, 10000)
  45       },
  46       // Pod 1 make friends too
  47       function (next) {
  48         utils.makeFriends(servers[0].url, next)
  49       },
  50       function (next) {
  51         webtorrent.create({ host: 'client', port: '1' }, next)
  52       }
  53     ], done)
  54   })
  55
  56   it('Should not have videos for all pods', function (done) {
  57     async.each(servers, function (server, callback) {
  58       utils.getVideosList(server.url, function (err, res) {
  59         if (err) throw err
  60
  61         expect(res.body).to.be.an('array')
  62         expect(res.body.length).to.equal(0)
  63
  64         callback()
  65       })
  66     }, done)
  67   })
  68
  69   describe('Should upload the video and propagate on each pod', function () {
  70     it('Should upload the video on pod 1 and propagate on each pod', function (done) {
  71       this.timeout(15000)
  72
  73       async.series([
  74         function (next) {
  75           utils.uploadVideo(servers[0].url, servers[0].access_token, 'my super name for pod 1', 'my super description for pod 1', 'video_short1.webm', next)
  76         },
  77         function (next) {
  78           setTimeout(next, 11000)
  79         }],
  80         // All pods should have this video
  81         function (err) {
  82           if (err) throw err
  83
  84           async.each(servers, function (server, callback) {
  85             let base_magnet = null
  86
  87             utils.getVideosList(server.url, function (err, res) {
  88               if (err) throw err
  89
  90               const videos = res.body
  91               expect(videos).to.be.an('array')
  92               expect(videos.length).to.equal(1)
  93               const video = videos[0]
  94               expect(video.name).to.equal('my super name for pod 1')
  95               expect(video.description).to.equal('my super description for pod 1')
  96               expect(video.podUrl).to.equal('http://localhost:9001')
  97               expect(video.magnetUri).to.exist
  98               expect(video.duration).to.equal(10)
  99
 100               if (server.url !== 'http://localhost:9001') {
 101                 expect(video.isLocal).to.be.false
 102               } else {
 103                 expect(video.isLocal).to.be.true
 104               }
 105
 106               // All pods should have the same magnet Uri
 107               if (base_magnet === null) {
 108                 base_magnet = video.magnetUri
 109               } else {
 110                 expect(video.magnetUri).to.equal.magnetUri
 111               }
 112
 113               utils.testImage(server.url, 'video_short1.webm', video.thumbnail_path, function (err, test) {
 114                 if (err) throw err
 115                 expect(test).to.equal(true)
 116
 117                 callback()
 118               })
 119             })
 120           }, done)
 121         }
 122       )
 123     })
 124
 125     it('Should upload the video on pod 2 and propagate on each pod', function (done) {
 126       this.timeout(15000)
 127
 128       async.series([
 129         function (next) {
 130           utils.uploadVideo(servers[1].url, servers[1].access_token, 'my super name for pod 2', 'my super description for pod 2', 'video_short2.webm', next)
 131         },
 132         function (next) {
 133           setTimeout(next, 11000)
 134         }],
 135         // All pods should have this video
 136         function (err) {
 137           if (err) throw err
 138
 139           async.each(servers, function (server, callback) {
 140             let base_magnet = null
 141
 142             utils.getVideosList(server.url, function (err, res) {
 143               if (err) throw err
 144
 145               const videos = res.body
 146               expect(videos).to.be.an('array')
 147               expect(videos.length).to.equal(2)
 148               const video = videos[1]
 149               expect(video.name).to.equal('my super name for pod 2')
 150               expect(video.description).to.equal('my super description for pod 2')
 151               expect(video.podUrl).to.equal('http://localhost:9002')
 152               expect(video.magnetUri).to.exist
 153               expect(video.duration).to.equal(5)
 154
 155               if (server.url !== 'http://localhost:9002') {
 156                 expect(video.isLocal).to.be.false
 157               } else {
 158                 expect(video.isLocal).to.be.true
 159               }
 160
 161               // All pods should have the same magnet Uri
 162               if (base_magnet === null) {
 163                 base_magnet = video.magnetUri
 164               } else {
 165                 expect(video.magnetUri).to.equal.magnetUri
 166               }
 167
 168               utils.testImage(server.url, 'video_short2.webm', video.thumbnail_path, function (err, test) {
 169                 if (err) throw err
 170                 expect(test).to.equal(true)
 171
 172                 callback()
 173               })
 174             })
 175           }, done)
 176         }
 177       )
 178     })
 179
 180     it('Should upload two videos on pod 3 and propagate on each pod', function (done) {
 181       this.timeout(30000)
 182
 183       async.series([
 184         function (next) {
 185           utils.uploadVideo(servers[2].url, servers[2].access_token, 'my super name for pod 3', 'my super description for pod 3', 'video_short3.webm', next)
 186         },
 187         function (next) {
 188           utils.uploadVideo(servers[2].url, servers[2].access_token, 'my super name for pod 3-2', 'my super description for pod 3-2', 'video_short.webm', next)
 189         },
 190         function (next) {
 191           setTimeout(next, 22000)
 192         }],
 193         function (err) {
 194           if (err) throw err
 195
 196           let base_magnet = null
 197           // All pods should have this video
 198           async.each(servers, function (server, callback) {
 199             utils.getVideosList(server.url, function (err, res) {
 200               if (err) throw err
 201
 202               const videos = res.body
 203               expect(videos).to.be.an('array')
 204               expect(videos.length).to.equal(4)
 205
 206               // We not sure about the order of the two last uploads
 207               let video1 = null
 208               let video2 = null
 209               if (videos[2].name === 'my super name for pod 3') {
 210                 video1 = videos[2]
 211                 video2 = videos[3]
 212               } else {
 213                 video1 = videos[3]
 214                 video2 = videos[2]
 215               }
 216
 217               expect(video1.name).to.equal('my super name for pod 3')
 218               expect(video1.description).to.equal('my super description for pod 3')
 219               expect(video1.podUrl).to.equal('http://localhost:9003')
 220               expect(video1.magnetUri).to.exist
 221               expect(video1.duration).to.equal(5)
 222
 223               expect(video2.name).to.equal('my super name for pod 3-2')
 224               expect(video2.description).to.equal('my super description for pod 3-2')
 225               expect(video2.podUrl).to.equal('http://localhost:9003')
 226               expect(video2.magnetUri).to.exist
 227               expect(video2.duration).to.equal(5)
 228
 229               if (server.url !== 'http://localhost:9003') {
 230                 expect(video1.isLocal).to.be.false
 231                 expect(video2.isLocal).to.be.false
 232               } else {
 233                 expect(video1.isLocal).to.be.true
 234                 expect(video2.isLocal).to.be.true
 235               }
 236
 237               // All pods should have the same magnet Uri
 238               if (base_magnet === null) {
 239                 base_magnet = video2.magnetUri
 240               } else {
 241                 expect(video2.magnetUri).to.equal.magnetUri
 242               }
 243
 244               utils.testImage(server.url, 'video_short3.webm', video1.thumbnail_path, function (err, test) {
 245                 if (err) throw err
 246                 expect(test).to.equal(true)
 247
 248                 utils.testImage(server.url, 'video_short.webm', video2.thumbnail_path, function (err, test) {
 249                   if (err) throw err
 250                   expect(test).to.equal(true)
 251
 252                   callback()
 253                 })
 254               })
 255             })
 256           }, done)
 257         }
 258       )
 259     })
 260   })
 261
 262   describe('Should seed the uploaded video', function () {
 263     it('Should add the file 1 by asking pod 3', function (done) {
 264       // Yes, this could be long
 265       this.timeout(200000)
 266
 267       utils.getVideosList(servers[2].url, function (err, res) {
 268         if (err) throw err
 269
 270         const video = res.body[0]
 271         to_remove.push(res.body[2].id)
 272         to_remove.push(res.body[3].id)
 273
 274         webtorrent.add(video.magnetUri, function (torrent) {
 275           expect(torrent.files).to.exist
 276           expect(torrent.files.length).to.equal(1)
 277           expect(torrent.files[0].path).to.exist.and.to.not.equal('')
 278
 279           done()
 280         })
 281       })
 282     })
 283
 284     it('Should add the file 2 by asking pod 1', function (done) {
 285       // Yes, this could be long
 286       this.timeout(200000)
 287
 288       utils.getVideosList(servers[0].url, function (err, res) {
 289         if (err) throw err
 290
 291         const video = res.body[1]
 292
 293         webtorrent.add(video.magnetUri, function (torrent) {
 294           expect(torrent.files).to.exist
 295           expect(torrent.files.length).to.equal(1)
 296           expect(torrent.files[0].path).to.exist.and.to.not.equal('')
 297
 298           done()
 299         })
 300       })
 301     })
 302
 303     it('Should add the file 3 by asking pod 2', function (done) {
 304       // Yes, this could be long
 305       this.timeout(200000)
 306
 307       utils.getVideosList(servers[1].url, function (err, res) {
 308         if (err) throw err
 309
 310         const video = res.body[2]
 311
 312         webtorrent.add(video.magnetUri, function (torrent) {
 313           expect(torrent.files).to.exist
 314           expect(torrent.files.length).to.equal(1)
 315           expect(torrent.files[0].path).to.exist.and.to.not.equal('')
 316
 317           done()
 318         })
 319       })
 320     })
 321
 322     it('Should add the file 3-2 by asking pod 1', function (done) {
 323       // Yes, this could be long
 324       this.timeout(200000)
 325
 326       utils.getVideosList(servers[0].url, function (err, res) {
 327         if (err) throw err
 328
 329         const video = res.body[3]
 330
 331         webtorrent.add(video.magnetUri, function (torrent) {
 332           expect(torrent.files).to.exist
 333           expect(torrent.files.length).to.equal(1)
 334           expect(torrent.files[0].path).to.exist.and.to.not.equal('')
 335
 336           done()
 337         })
 338       })
 339     })
 340
 341     it('Should remove the file 3 and 3-2 by asking pod 3', function (done) {
 342       this.timeout(15000)
 343
 344       async.series([
 345         function (next) {
 346           utils.removeVideo(servers[2].url, servers[2].access_token, to_remove[0], next)
 347         },
 348         function (next) {
 349           utils.removeVideo(servers[2].url, servers[2].access_token, to_remove[1], next)
 350         }],
 351         function (err) {
 352           if (err) throw err
 353           setTimeout(done, 11000)
 354         }
 355       )
 356     })
 357
 358     it('Should have videos 1 and 3 on each pod', function (done) {
 359       async.each(servers, function (server, callback) {
 360         utils.getVideosList(server.url, function (err, res) {
 361           if (err) throw err
 362
 363           const videos = res.body
 364           expect(videos).to.be.an('array')
 365           expect(videos.length).to.equal(2)
 366           expect(videos[0].id).not.to.equal(videos[1].id)
 367           expect(videos[0].id).not.to.equal(to_remove[0])
 368           expect(videos[1].id).not.to.equal(to_remove[0])
 369           expect(videos[0].id).not.to.equal(to_remove[1])
 370           expect(videos[1].id).not.to.equal(to_remove[1])
 371
 372           callback()
 373         })
 374       }, done)
 375     })
 376   })
 377
 378   after(function (done) {
 379     servers.forEach(function (server) {
 380       process.kill(-server.app.pid)
 381     })
 382     process.kill(-webtorrent.app.pid)
 383
 384     // Keep the logs if the test failed
 385     if (this.ok) {
 386       utils.flushTests(done)
 387     } else {
 388       done()
 389     }
 390   })
 391 })