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