server/tests/api/friendsBasic.js

   1 'use strict'
   2
   3 const async = require('async')
   4 const chai = require('chai')
   5 const expect = chai.expect
   6
   7 const utils = require('./utils')
   8
   9 describe('Test basic friends', function () {
  10   let servers = []
  11
  12   function makeFriends (podNumber, callback) {
  13     const server = servers[podNumber - 1]
  14     return utils.makeFriends(server.url, server.accessToken, callback)
  15   }
  16
  17   function testMadeFriends (servers, serverToTest, callback) {
  18     const friends = []
  19     for (let i = 0; i < servers.length; i++) {
  20       if (servers[i].url === serverToTest.url) continue
  21       friends.push(servers[i].url)
  22     }
  23
  24     utils.getFriendsList(serverToTest.url, function (err, res) {
  25       if (err) throw err
  26
  27       const result = res.body
  28       const resultUrls = [ result[0].url, result[1].url ]
  29       expect(result).to.be.an('array')
  30       expect(result.length).to.equal(2)
  31       expect(resultUrls[0]).to.not.equal(resultUrls[1])
  32
  33       const errorString = 'Friends url do not correspond for ' + serverToTest.url
  34       expect(friends).to.contain(resultUrls[0], errorString)
  35       expect(friends).to.contain(resultUrls[1], errorString)
  36       callback()
  37     })
  38   }
  39
  40   // ---------------------------------------------------------------
  41
  42   before(function (done) {
  43     this.timeout(20000)
  44     utils.flushAndRunMultipleServers(3, function (serversRun, urlsRun) {
  45       servers = serversRun
  46
  47       async.each(servers, function (server, callbackEach) {
  48         utils.loginAndGetAccessToken(server, function (err, accessToken) {
  49           if (err) return callbackEach(err)
  50
  51           server.accessToken = accessToken
  52           callbackEach()
  53         })
  54       }, done)
  55     })
  56   })
  57
  58   it('Should not have friends', function (done) {
  59     async.each(servers, function (server, callback) {
  60       utils.getFriendsList(server.url, function (err, res) {
  61         if (err) throw err
  62
  63         const result = res.body
  64         expect(result).to.be.an('array')
  65         expect(result.length).to.equal(0)
  66         callback()
  67       })
  68     }, done)
  69   })
  70
  71   it('Should make friends', function (done) {
  72     this.timeout(10000)
  73
  74     async.series([
  75       // The second pod make friend with the third
  76       function (next) {
  77         makeFriends(2, next)
  78       },
  79       // Wait for the request between pods
  80       function (next) {
  81         setTimeout(next, 1000)
  82       },
  83       // The second pod should have the third as a friend
  84       function (next) {
  85         utils.getFriendsList(servers[1].url, function (err, res) {
  86           if (err) throw err
  87
  88           const result = res.body
  89           expect(result).to.be.an('array')
  90           expect(result.length).to.equal(1)
  91           expect(result[0].url).to.be.equal(servers[2].url)
  92
  93           next()
  94         })
  95       },
  96       // Same here, the third pod should have the second pod as a friend
  97       function (next) {
  98         utils.getFriendsList(servers[2].url, function (err, res) {
  99           if (err) throw err
 100
 101           const result = res.body
 102           expect(result).to.be.an('array')
 103           expect(result.length).to.equal(1)
 104           expect(result[0].url).to.be.equal(servers[1].url)
 105
 106           next()
 107         })
 108       },
 109       // Finally the first pod make friend with the second pod
 110       function (next) {
 111         makeFriends(1, next)
 112       },
 113       // Wait for the request between pods
 114       function (next) {
 115         setTimeout(next, 1000)
 116       }
 117     ],
 118     // Now each pod should be friend with the other ones
 119     function (err) {
 120       if (err) throw err
 121       async.each(servers, function (server, callback) {
 122         testMadeFriends(servers, server, callback)
 123       }, done)
 124     })
 125   })
 126
 127   it('Should not be allowed to make friend again', function (done) {
 128     const server = servers[1]
 129     utils.makeFriends(server.url, server.accessToken, 409, done)
 130   })
 131
 132   it('Should quit friends of pod 2', function (done) {
 133     async.series([
 134       // Pod 1 quit friends
 135       function (next) {
 136         const server = servers[1]
 137         utils.quitFriends(server.url, server.accessToken, next)
 138       },
 139       // Pod 1 should not have friends anymore
 140       function (next) {
 141         utils.getFriendsList(servers[1].url, function (err, res) {
 142           if (err) throw err
 143
 144           const result = res.body
 145           expect(result).to.be.an('array')
 146           expect(result.length).to.equal(0)
 147
 148           next()
 149         })
 150       },
 151       // Other pods shouldn't have pod 1 too
 152       function (next) {
 153         async.each([ servers[0].url, servers[2].url ], function (url, callback) {
 154           utils.getFriendsList(url, function (err, res) {
 155             if (err) throw err
 156
 157             const result = res.body
 158             expect(result).to.be.an('array')
 159             expect(result.length).to.equal(1)
 160             expect(result[0].url).not.to.be.equal(servers[1].url)
 161             callback()
 162           })
 163         }, next)
 164       }
 165     ], done)
 166   })
 167
 168   it('Should allow pod 2 to make friend again', function (done) {
 169     const server = servers[1]
 170     utils.makeFriends(server.url, server.accessToken, function () {
 171       async.each(servers, function (server, callback) {
 172         testMadeFriends(servers, server, callback)
 173       }, done)
 174     })
 175   })
 176
 177   after(function (done) {
 178     servers.forEach(function (server) {
 179       process.kill(-server.app.pid)
 180     })
 181
 182     if (this.ok) {
 183       utils.flushTests(done)
 184     } else {
 185       done()
 186     }
 187   })
 188 })