PeerTube/server/tests/api/friends-basic.js

206 lines
5.8 KiB
JavaScript
Raw Normal View History

'use strict'
2015-06-09 17:41:40 +02:00
2016-03-16 22:29:27 +01:00
const chai = require('chai')
2016-07-18 17:17:52 +02:00
const each = require('async/each')
2016-03-16 22:29:27 +01:00
const expect = chai.expect
2016-07-18 17:17:52 +02:00
const series = require('async/series')
2015-06-09 17:41:40 +02:00
const loginUtils = require('../utils/login')
const miscsUtils = require('../utils/miscs')
const podsUtils = require('../utils/pods')
const serversUtils = require('../utils/servers')
2015-06-09 17:41:40 +02:00
describe('Test basic friends', function () {
let servers = []
2016-01-24 16:08:09 +01:00
function makeFriends (podNumber, callback) {
const server = servers[podNumber - 1]
return podsUtils.makeFriends(server.url, server.accessToken, callback)
}
function testMadeFriends (servers, serverToTest, callback) {
2016-03-16 22:29:27 +01:00
const friends = []
for (let i = 0; i < servers.length; i++) {
if (servers[i].url === serverToTest.url) continue
2016-11-14 20:45:00 +01:00
friends.push(servers[i].host)
}
podsUtils.getFriendsList(serverToTest.url, function (err, res) {
if (err) throw err
2017-01-04 20:59:23 +01:00
const result = res.body.data
expect(result).to.be.an('array')
expect(result.length).to.equal(2)
2016-11-14 20:45:00 +01:00
const resultHosts = [ result[0].host, result[1].host ]
expect(resultHosts[0]).to.not.equal(resultHosts[1])
2016-11-14 20:45:00 +01:00
const errorString = 'Friends host do not correspond for ' + serverToTest.host
expect(friends).to.contain(resultHosts[0], errorString)
expect(friends).to.contain(resultHosts[1], errorString)
callback()
})
}
// ---------------------------------------------------------------
before(function (done) {
this.timeout(20000)
serversUtils.flushAndRunMultipleServers(3, function (serversRun, urlsRun) {
servers = serversRun
2016-07-18 17:17:52 +02:00
each(servers, function (server, callbackEach) {
loginUtils.loginAndGetAccessToken(server, function (err, accessToken) {
if (err) return callbackEach(err)
server.accessToken = accessToken
callbackEach()
})
}, done)
})
})
it('Should not have friends', function (done) {
2016-07-18 17:17:52 +02:00
each(servers, function (server, callback) {
podsUtils.getFriendsList(server.url, function (err, res) {
if (err) throw err
2017-01-04 20:59:23 +01:00
const result = res.body.data
expect(result).to.be.an('array')
expect(result.length).to.equal(0)
callback()
})
}, done)
})
it('Should make friends', function (done) {
2016-09-21 23:05:31 +02:00
this.timeout(40000)
2016-07-18 17:17:52 +02:00
series([
// The second pod make friend with the third
function (next) {
makeFriends(2, next)
},
// Wait for the request between pods
function (next) {
2016-09-21 23:05:31 +02:00
setTimeout(next, 11000)
},
// The second pod should have the third as a friend
function (next) {
podsUtils.getFriendsList(servers[1].url, function (err, res) {
if (err) throw err
2015-06-09 17:41:40 +02:00
2017-01-04 20:59:23 +01:00
const result = res.body.data
expect(result).to.be.an('array')
expect(result.length).to.equal(1)
const pod = result[0]
2016-11-14 20:45:00 +01:00
expect(pod.host).to.equal(servers[2].host)
expect(pod.score).to.equal(20)
2016-12-11 21:50:51 +01:00
expect(miscsUtils.dateIsValid(pod.createdAt)).to.be.true
2015-06-09 17:41:40 +02:00
next()
})
},
// Same here, the third pod should have the second pod as a friend
function (next) {
podsUtils.getFriendsList(servers[2].url, function (err, res) {
2015-06-09 17:41:40 +02:00
if (err) throw err
2017-01-04 20:59:23 +01:00
const result = res.body.data
2015-06-09 17:41:40 +02:00
expect(result).to.be.an('array')
expect(result.length).to.equal(1)
const pod = result[0]
2016-11-14 20:45:00 +01:00
expect(pod.host).to.equal(servers[1].host)
expect(pod.score).to.equal(20)
2016-12-11 21:50:51 +01:00
expect(miscsUtils.dateIsValid(pod.createdAt)).to.be.true
next()
2015-06-09 17:41:40 +02:00
})
},
// Finally the first pod make friend with the second pod
function (next) {
makeFriends(1, next)
},
// Wait for the request between pods
function (next) {
2016-09-21 22:52:25 +02:00
setTimeout(next, 11000)
}
],
// Now each pod should be friend with the other ones
function (err) {
if (err) throw err
2016-07-18 17:17:52 +02:00
each(servers, function (server, callback) {
testMadeFriends(servers, server, callback)
2016-01-24 16:08:09 +01:00
}, done)
2015-06-09 17:41:40 +02:00
})
})
2015-06-09 17:41:40 +02:00
it('Should not be allowed to make friend again', function (done) {
const server = servers[1]
podsUtils.makeFriends(server.url, server.accessToken, 409, done)
})
2015-06-09 17:41:40 +02:00
it('Should quit friends of pod 2', function (done) {
2016-07-18 17:17:52 +02:00
series([
// Pod 1 quit friends
function (next) {
const server = servers[1]
podsUtils.quitFriends(server.url, server.accessToken, next)
},
// Pod 1 should not have friends anymore
function (next) {
podsUtils.getFriendsList(servers[1].url, function (err, res) {
if (err) throw err
2015-06-09 17:41:40 +02:00
2017-01-04 20:59:23 +01:00
const result = res.body.data
expect(result).to.be.an('array')
expect(result.length).to.equal(0)
next()
})
},
// Other pods shouldn't have pod 1 too
function (next) {
2016-07-18 17:17:52 +02:00
each([ servers[0].url, servers[2].url ], function (url, callback) {
podsUtils.getFriendsList(url, function (err, res) {
2016-01-24 16:08:09 +01:00
if (err) throw err
2017-01-04 20:59:23 +01:00
const result = res.body.data
2016-01-24 16:08:09 +01:00
expect(result).to.be.an('array')
expect(result.length).to.equal(1)
2016-11-14 20:45:00 +01:00
expect(result[0].host).not.to.be.equal(servers[1].host)
callback()
2016-01-24 16:08:09 +01:00
})
}, next)
}
], done)
})
it('Should allow pod 2 to make friend again', function (done) {
2016-09-21 23:05:31 +02:00
this.timeout(20000)
const server = servers[1]
podsUtils.makeFriends(server.url, server.accessToken, function () {
2016-09-21 22:52:25 +02:00
setTimeout(function () {
each(servers, function (server, callback) {
testMadeFriends(servers, server, callback)
}, done)
}, 11000)
})
})
after(function (done) {
servers.forEach(function (server) {
process.kill(-server.app.pid)
})
2015-06-09 17:41:40 +02:00
if (this.ok) {
serversUtils.flushTests(done)
} else {
done()
}
2015-06-09 17:41:40 +02:00
})
})