server/tests/api/friends-basic.ts

   1 /* tslint:disable:no-unused-expression */
   2
   3 import 'mocha'
   4 import * as chai from 'chai'
   5 const expect = chai.expect
   6
   7 import {
   8   ServerInfo,
   9   flushTests,
  10   quitFriends,
  11   wait,
  12   setAccessTokensToServers,
  13   flushAndRunMultipleServers,
  14   killallServers,
  15   makeFriends,
  16   getFriendsList,
  17   dateIsValid,
  18   quitOneFriend
  19 } from '../utils'
  20
  21 describe('Test basic friends', function () {
  22   let servers = []
  23
  24   function makeFriendsWrapper (podNumber: number) {
  25     const server = servers[podNumber - 1]
  26     return makeFriends(server.url, server.accessToken)
  27   }
  28
  29   async function testMadeFriends (servers: ServerInfo[], serverToTest: ServerInfo) {
  30     const friends = []
  31     for (let i = 0; i < servers.length; i++) {
  32       if (servers[i].url === serverToTest.url) continue
  33       friends.push(servers[i].host)
  34     }
  35
  36     const res = await getFriendsList(serverToTest.url)
  37
  38     const result = res.body.data
  39     expect(result).to.be.an('array')
  40     expect(result.length).to.equal(2)
  41
  42     const resultHosts = [ result[0].host, result[1].host ]
  43     expect(resultHosts[0]).to.not.equal(resultHosts[1])
  44
  45     const errorString = 'Friends host do not correspond for ' + serverToTest.host
  46     expect(friends).to.contain(resultHosts[0], errorString)
  47     expect(friends).to.contain(resultHosts[1], errorString)
  48   }
  49
  50   // ---------------------------------------------------------------
  51
  52   before(async function () {
  53     this.timeout(120000)
  54
  55     servers = await flushAndRunMultipleServers(3)
  56
  57     await setAccessTokensToServers(servers)
  58   })
  59
  60   it('Should not have friends', async function () {
  61     for (const server of servers) {
  62       const res = await getFriendsList(server.url)
  63
  64       const result = res.body.data
  65       expect(result).to.be.an('array')
  66       expect(result.length).to.equal(0)
  67     }
  68   })
  69
  70   it('Should make friends', async function () {
  71     this.timeout(120000)
  72
  73     // The second pod make friend with the third
  74     await makeFriendsWrapper(2)
  75
  76     // Wait for the request between pods
  77     await wait(11000)
  78
  79     // The second pod should have the third as a friend
  80     const res1 = await getFriendsList(servers[1].url)
  81
  82     const friends = res1.body.data
  83     expect(friends).to.be.an('array')
  84     expect(friends.length).to.equal(1)
  85
  86     const pod1 = friends[0]
  87     expect(pod1.host).to.equal(servers[2].host)
  88     expect(pod1.email).to.equal('admin3@example.com')
  89     expect(pod1.score).to.equal(20)
  90     expect(dateIsValid(pod1.createdAt)).to.be.true
  91
  92     // Same here, the third pod should have the second pod as a friend
  93     const res2 = await getFriendsList(servers[2].url)
  94     const result = res2.body.data
  95     expect(result).to.be.an('array')
  96     expect(result.length).to.equal(1)
  97
  98     const pod2 = result[0]
  99     expect(pod2.host).to.equal(servers[1].host)
 100     expect(pod2.email).to.equal('admin2@example.com')
 101     expect(pod2.score).to.equal(20)
 102     expect(dateIsValid(pod2.createdAt)).to.be.true
 103
 104     // Finally the first pod make friend with the second pod
 105     await makeFriendsWrapper(1)
 106
 107     // Wait for the request between pods
 108     await wait(11000)
 109
 110     // Now each pod should be friend with the other ones
 111     for (const server of servers) {
 112       await testMadeFriends(servers, server)
 113     }
 114   })
 115
 116   it('Should not be allowed to make friend again', async function () {
 117     this.timeout(10000)
 118
 119     const server = servers[1]
 120     await makeFriends(server.url, server.accessToken, 409)
 121   })
 122
 123   it('Should quit friends of pod 2', async function () {
 124     this.timeout(10000)
 125
 126     // Pod 1 quit friends
 127     await quitFriends(servers[1].url, servers[1].accessToken)
 128
 129     // Pod 1 should not have friends anymore
 130     const res = await getFriendsList(servers[1].url)
 131     const friends = res.body.data
 132     expect(friends).to.be.an('array')
 133     expect(friends).to.have.lengthOf(0)
 134
 135     // Other pods shouldn't have pod 1 too
 136     const serversToTest = [ servers[0].url, servers[2].url ]
 137     for (const url of serversToTest) {
 138       const res = await getFriendsList(url)
 139       const friends = res.body.data
 140
 141       expect(friends).to.be.an('array')
 142       expect(friends.length).to.equal(1)
 143       expect(friends[0].host).not.to.be.equal(servers[1].host)
 144     }
 145   })
 146
 147   it('Should allow pod 2 to make friend again', async function () {
 148     this.timeout(120000)
 149
 150     const server = servers[1]
 151     await makeFriends(server.url, server.accessToken)
 152     await wait(11000)
 153
 154     for (const server of servers) {
 155       await testMadeFriends(servers, server)
 156     }
 157   })
 158
 159   it('Should allow pod 1 to quit only pod 2', async function () {
 160     // Pod 1 quits pod 2
 161     const server = servers[0]
 162
 163     // Get pod 2 id so we can query it
 164     const res1 = await getFriendsList(server.url)
 165     const friends1 = res1.body.data
 166     let pod1 = friends1.find(friend => (friend.host === servers[1].host))
 167
 168     // Remove it from the friends list
 169     await quitOneFriend(server.url, server.accessToken, pod1.id)
 170
 171     // Pod 1 should have only pod 3 in its friends list
 172     const res2 = await getFriendsList(servers[0].url)
 173     const friends2 = res2.body.data
 174     expect(friends2).to.be.an('array')
 175     expect(friends2.length).to.equal(1)
 176
 177     const pod2 = friends2[0]
 178     expect(pod2.host).to.equal(servers[2].host)
 179
 180     // Pod 2 should have only pod 3 in its friends list
 181     const res3 = await getFriendsList(servers[1].url)
 182     const friends3 = res3.body.data
 183     expect(friends3).to.be.an('array')
 184     expect(friends3.length).to.equal(1)
 185
 186     const pod = friends3[0]
 187     expect(pod.host).to.equal(servers[2].host)
 188
 189     // Pod 3 should have both pods in its friends list
 190     const res4 = await getFriendsList(servers[2].url)
 191     const friends4 = res4.body.data
 192     expect(friends4).to.be.an('array')
 193     expect(friends4.length).to.equal(2)
 194   })
 195
 196   after(async function () {
 197     killallServers(servers)
 198
 199     if (this['ok']) {
 200       await flushTests()
 201     }
 202   })
 203 })