interesting
/
PeerTube
mirror of https://github.com/Chocobozzz/PeerTube.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Add video channel tests

This commit is contained in:
Chocobozzz 2017-10-24 19:41:30 +02:00
parent 72c7248b6f
commit 5f04dd2f74
No known key found for this signature in database
GPG Key ID: 583A612D890159BE
16 changed files with 869 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server/tests/api/check-params/remotes.ts
View File

@ -1,5 +1,7 @@
/* tslint:disable:no-unused-expression */ /* tslint:disable:no-unused-expression */
import 'mocha'
import { import {
ServerInfo, ServerInfo,
flushTests, flushTests,

310
server/tests/api/check-params/video-channels.ts Normal file
View File

@ -0,0 +1,310 @@
/* tslint:disable:no-unused-expression */
import * as request from 'supertest'
import { join } from 'path'
import 'mocha'
import * as chai from 'chai'
const expect = chai.expect
import {
ServerInfo,
flushTests,
runServer,
makePutBodyRequest,
setAccessTokensToServers,
killallServers,
getMyUserInformation,
makePostBodyRequest,
getVideoChannelsList,
createUser,
getUserAccessToken
} from '../../utils'
describe('Test videos API validator', function () {
const path = '/api/v1/videos/channels'
let server: ServerInfo
let channelId: number
let accessTokenUser: string
// ---------------------------------------------------------------
before(async function () {
this.timeout(20000)
await flushTests()
server = await runServer(1)
await setAccessTokensToServers([ server ])
const res = await getMyUserInformation(server.url, server.accessToken)
channelId = res.body.videoChannels[0].id
const user = {
username: 'fake',
password: 'fake_password'
}
await createUser(server.url, server.accessToken, user.username, user.password)
accessTokenUser = await getUserAccessToken(server, user)
})
describe('When listing a video channels', function () {
it('Should fail with a bad start pagination', async function () {
await request(server.url)
.get(path)
.query({ start: 'hello' })
.set('Accept', 'application/json')
.expect(400)
})
it('Should fail with a bad count pagination', async function () {
await request(server.url)
.get(path)
.query({ count: 'hello' })
.set('Accept', 'application/json')
.expect(400)
})
it('Should fail with an incorrect sort', async function () {
await request(server.url)
.get(path)
.query({ sort: 'hello' })
.set('Accept', 'application/json')
.expect(400)
})
})
describe('When listing author video channels', function () {
it('Should fail with bad author', async function () {
const path = '/api/v1/videos/authors/hello/channels'
await request(server.url)
.get(path)
.set('Accept', 'application/json')
.expect(400)
})
it('Should fail with a unknown author', async function () {
const path = '/api/v1/videos/authors/156/channels'
await request(server.url)
.get(path)
.set('Accept', 'application/json')
.expect(404)
})
})
describe('When adding a video channel', function () {
it('Should fail with a non authenticated user', async function () {
const fields = {
name: 'hello',
description: 'super description'
}
await makePostBodyRequest({ url: server.url, path, token: 'none', fields, statusCodeExpected: 401 })
})
it('Should fail with nothing', async function () {
const fields = {}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
})
it('Should fail without name', async function () {
const fields = {
description: 'super description'
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
})
it('Should fail with a long name', async function () {
const fields = {
name: 'hello tooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo' +
'oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo long',
description: 'super description'
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
})
it('Should fail with a long description', async function () {
const fields = {
name: 'hello',
description: 'super toooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo' +
'oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo0' +
'ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo' +
'oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo long description'
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
})
it('Should succeed with the correct parameters', async function () {
const fields = {
name: 'hello',
description: 'super description'
}
await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 204 })
})
})
describe('When updating a video channel', function () {
let videoChannelId
before(async function () {
const res = await getVideoChannelsList(server.url, 0, 1)
videoChannelId = res.body.data[0].id
})
it('Should fail with a non authenticated user', async function () {
const fields = {
name: 'hello',
description: 'super description'
}
await makePutBodyRequest({ url: server.url, path: path + '/' + videoChannelId, token: 'hi', fields, statusCodeExpected: 401 })
})
it('Should fail with another authenticated user', async function () {
const fields = {
name: 'hello',
description: 'super description'
}
await makePutBodyRequest({
url: server.url,
path: path + '/' + videoChannelId,
token: accessTokenUser,
fields,
statusCodeExpected: 403
})
})
it('Should fail with a long name', async function () {
const fields = {
name: 'hello tooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo' +
'oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo long',
description: 'super description'
}
await makePutBodyRequest({ url: server.url, path: path + '/' + videoChannelId, token: server.accessToken, fields })
})
it('Should fail with a long description', async function () {
const fields = {
name: 'hello',
description: 'super toooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo' +
'oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo0' +
'ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo' +
'oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo long description'
}
await makePutBodyRequest({ url: server.url, path: path + '/' + videoChannelId, token: server.accessToken, fields })
})
it('Should succeed with the correct parameters', async function () {
const fields = {
name: 'hello 2',
description: 'super description 2'
}
await makePutBodyRequest({
url: server.url,
path: path + '/' + videoChannelId,
token: server.accessToken,
fields,
statusCodeExpected: 204
})
})
})
describe('When getting a video channel', function () {
let videoChannelId: number
before(async function () {
const res = await getVideoChannelsList(server.url, 0, 1)
videoChannelId = res.body.data[0].id
})
it('Should return the list of the video channels with nothing', async function () {
const res = await request(server.url)
.get(path)
.set('Accept', 'application/json')
.expect(200)
.expect('Content-Type', /json/)
expect(res.body.data).to.be.an('array')
})
it('Should fail without a correct uuid', async function () {
await request(server.url)
.get(path + '/coucou')
.set('Accept', 'application/json')
.expect(400)
})
it('Should return 404 with an incorrect video channel', async function () {
await request(server.url)
.get(path + '/4da6fde3-88f7-4d16-b119-108df5630b06')
.set('Accept', 'application/json')
.expect(404)
})
it('Should succeed with the correct parameters', async function () {
await request(server.url)
.get(path + '/' + videoChannelId)
.set('Accept', 'application/json')
.expect(200)
})
})
describe('When deleting a video channel', function () {
let videoChannelId: number
before(async function () {
const res = await getVideoChannelsList(server.url, 0, 1)
videoChannelId = res.body.data[0].id
})
it('Should fail with a non authenticated user', async function () {
await request(server.url)
.delete(path + '/' + videoChannelId)
.set('Authorization', 'Bearer coucou')
.expect(401)
})
it('Should fail with another authenticated user', async function () {
await request(server.url)
.delete(path + '/' + videoChannelId)
.set('Authorization', 'Bearer ' + accessTokenUser)
.expect(403)
})
it('Should fail with an unknown id', async function () {
await request(server.url)
.delete(path + '/454554')
.set('Authorization', 'Bearer ' + server.accessToken)
.expect(404)
})
it('Should succeed with the correct parameters', async function () {
await request(server.url)
.delete(path + '/' + videoChannelId)
.set('Authorization', 'Bearer ' + server.accessToken)
.expect(204)
})
it('Should fail to delete the last user video channel', async function () {
const res = await getVideoChannelsList(server.url, 0, 1)
videoChannelId = res.body.data[0].id
await request(server.url)
.delete(path + '/' + videoChannelId)
.set('Authorization', 'Bearer ' + server.accessToken)
.expect(409
)
})
})
after(async function () {
killallServers([ server ])
// Keep the logs if the test failed
if (this['ok']) {
await flushTests()
}
})
})

123
server/tests/api/check-params/videos.ts
View File

@ -14,12 +14,16 @@ import {
makePutBodyRequest, makePutBodyRequest,
setAccessTokensToServers, setAccessTokensToServers,
killallServers, killallServers,
makePostUploadRequest makePostUploadRequest,
getMyUserInformation,
createUser,
getUserAccessToken
} from '../../utils' } from '../../utils'
describe('Test videos API validator', function () { describe('Test videos API validator', function () {
const path = '/api/v1/videos/' const path = '/api/v1/videos/'
let server: ServerInfo let server: ServerInfo
let channelId: number
// --------------------------------------------------------------- // ---------------------------------------------------------------
@ -31,6 +35,9 @@ describe('Test videos API validator', function () {
server = await runServer(1) server = await runServer(1)
await setAccessTokensToServers([ server ]) await setAccessTokensToServers([ server ])
const res = await getMyUserInformation(server.url, server.accessToken)
channelId = res.body.videoChannels[0].id
}) })
describe('When listing a video', function () { describe('When listing a video', function () {
@ -106,7 +113,8 @@ describe('Test videos API validator', function () {
language: 6, language: 6,
nsfw: false, nsfw: false,
description: 'my super description', description: 'my super description',
tags: [ 'tag1', 'tag2' ] tags: [ 'tag1', 'tag2' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
@ -122,7 +130,8 @@ describe('Test videos API validator', function () {
language: 6, language: 6,
nsfw: false, nsfw: false,
description: 'my super description', description: 'my super description',
tags: [ 'tag1', 'tag2' ] tags: [ 'tag1', 'tag2' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
@ -137,7 +146,8 @@ describe('Test videos API validator', function () {
language: 6, language: 6,
nsfw: false, nsfw: false,
description: 'my super description', description: 'my super description',
tags: [ 'tag1', 'tag2' ] tags: [ 'tag1', 'tag2' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
@ -153,7 +163,8 @@ describe('Test videos API validator', function () {
language: 6, language: 6,
nsfw: false, nsfw: false,
description: 'my super description', description: 'my super description',
tags: [ 'tag1', 'tag2' ] tags: [ 'tag1', 'tag2' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
@ -168,7 +179,8 @@ describe('Test videos API validator', function () {
language: 6, language: 6,
nsfw: false, nsfw: false,
description: 'my super description', description: 'my super description',
tags: [ 'tag1', 'tag2' ] tags: [ 'tag1', 'tag2' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
@ -184,7 +196,8 @@ describe('Test videos API validator', function () {
language: 6, language: 6,
nsfw: false, nsfw: false,
description: 'my super description', description: 'my super description',
tags: [ 'tag1', 'tag2' ] tags: [ 'tag1', 'tag2' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
@ -200,7 +213,8 @@ describe('Test videos API validator', function () {
language: 563, language: 563,
nsfw: false, nsfw: false,
description: 'my super description', description: 'my super description',
tags: [ 'tag1', 'tag2' ] tags: [ 'tag1', 'tag2' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
@ -215,7 +229,8 @@ describe('Test videos API validator', function () {
licence: 4, licence: 4,
language: 6, language: 6,
description: 'my super description', description: 'my super description',
tags: [ 'tag1', 'tag2' ] tags: [ 'tag1', 'tag2' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
@ -223,7 +238,7 @@ describe('Test videos API validator', function () {
await makePostUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches }) await makePostUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
}) })
it('Should fail with a bad nsfw attribue', async function () { it('Should fail with a bad nsfw attribute', async function () {
const fields = { const fields = {
name: 'my super name', name: 'my super name',
category: 5, category: 5,
@ -231,7 +246,8 @@ describe('Test videos API validator', function () {
language: 6, language: 6,
nsfw: 2, nsfw: 2,
description: 'my super description', description: 'my super description',
tags: [ 'tag1', 'tag2' ] tags: [ 'tag1', 'tag2' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
@ -246,7 +262,8 @@ describe('Test videos API validator', function () {
licence: 1, licence: 1,
language: 6, language: 6,
nsfw: false, nsfw: false,
tags: [ 'tag1', 'tag2' ] tags: [ 'tag1', 'tag2' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
@ -264,6 +281,23 @@ describe('Test videos API validator', function () {
description: 'my super description which is very very very very very very very very very very very very very very' + description: 'my super description which is very very very very very very very very very very very very very very' +
'very very very very very very very very very very very very very very very very very very very very very' + 'very very very very very very very very very very very very very very very very very very very very very' +
'very very very very very very very very very very very very very very very long', 'very very very very very very very very very very very very very very very long',
tags: [ 'tag1', 'tag2' ],
channelId
}
const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
}
await makePostUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
})
it('Should fail without a channel', async function () {
const fields = {
name: 'my super name',
category: 5,
licence: 1,
language: 6,
nsfw: false,
description: 'my super description',
tags: [ 'tag1', 'tag2' ] tags: [ 'tag1', 'tag2' ]
} }
const attaches = { const attaches = {
@ -272,6 +306,50 @@ describe('Test videos API validator', function () {
await makePostUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches }) await makePostUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
}) })
it('Should fail with a bad channel', async function () {
const fields = {
name: 'my super name',
category: 5,
licence: 1,
language: 6,
nsfw: false,
description: 'my super description',
tags: [ 'tag1', 'tag2' ],
channelId: 545454
}
const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
}
await makePostUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
})
it('Should fail with another user channel', async function () {
const user = {
username: 'fake',
password: 'fake_password'
}
await createUser(server.url, server.accessToken, user.username, user.password)
const accessTokenUser = await getUserAccessToken(server, user)
const res = await getMyUserInformation(server.url, accessTokenUser)
const channelId = res.body.videoChannels[0].id
const fields = {
name: 'my super name',
category: 5,
licence: 1,
language: 6,
nsfw: false,
description: 'my super description',
tags: [ 'tag1', 'tag2' ],
channelId
}
const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
}
await makePostUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
})
it('Should fail with too many tags', async function () { it('Should fail with too many tags', async function () {
const fields = { const fields = {
name: 'my super name', name: 'my super name',
@ -280,7 +358,8 @@ describe('Test videos API validator', function () {
language: 6, language: 6,
nsfw: false, nsfw: false,
description: 'my super description', description: 'my super description',
tags: [ 'tag1', 'tag2', 'tag3', 'tag4' ] tags: [ 'tag1', 'tag2', 'tag3', 'tag4' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
@ -296,7 +375,8 @@ describe('Test videos API validator', function () {
language: 6, language: 6,
nsfw: false, nsfw: false,
description: 'my super description', description: 'my super description',
tags: [ 'tag1', 't' ] tags: [ 'tag1', 't' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
@ -312,7 +392,8 @@ describe('Test videos API validator', function () {
language: 6, language: 6,
nsfw: false, nsfw: false,
description: 'my super description', description: 'my super description',
tags: [ 'my_super_tag_too_long', 'tag1' ] tags: [ 'my_super_tag_too_long', 'tag1' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')
@ -328,7 +409,8 @@ describe('Test videos API validator', function () {
language: 6, language: 6,
nsfw: false, nsfw: false,
description: 'my super description', description: 'my super description',
tags: [ 'tag1', 'tag2' ] tags: [ 'tag1', 'tag2' ],
channelId
} }
const attaches = {} const attaches = {}
await makePostUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches }) await makePostUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
@ -342,7 +424,8 @@ describe('Test videos API validator', function () {
language: 6, language: 6,
nsfw: false, nsfw: false,
description: 'my super description', description: 'my super description',
tags: [ 'tag1', 'tag2' ] tags: [ 'tag1', 'tag2' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short_fake.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_short_fake.webm')
@ -358,7 +441,8 @@ describe('Test videos API validator', function () {
language: 6, language: 6,
nsfw: false, nsfw: false,
description: 'my super description', description: 'my super description',
tags: [ 'tag1', 'tag2' ] tags: [ 'tag1', 'tag2' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_too_long.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_too_long.webm')
@ -376,7 +460,8 @@ describe('Test videos API validator', function () {
language: 6, language: 6,
nsfw: false, nsfw: false,
description: 'my super description', description: 'my super description',
tags: [ 'tag1', 'tag2' ] tags: [ 'tag1', 'tag2' ],
channelId
} }
const attaches = { const attaches = {
'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm') 'videofile': join(__dirname, '..', 'fixtures', 'video_short.webm')

61
server/tests/api/friends-advanced.ts
View File

@ -72,7 +72,7 @@ describe('Test advanced friends', function () {
await setAccessTokensToServers(servers) await setAccessTokensToServers(servers)
}) })
it('Should make friends with two pod each in a different group', async function () { it('Should not make friends with two different groups', async function () {
this.timeout(20000) this.timeout(20000)
// Pod 3 makes friend with the first one // Pod 3 makes friend with the first one
@ -81,7 +81,7 @@ describe('Test advanced friends', function () {
// Pod 4 makes friend with the second one // Pod 4 makes friend with the second one
await makeFriendsWrapper(4) await makeFriendsWrapper(4)
// Now if the fifth wants to make friends with the third et the first // Now if the fifth wants to make friends with the third and the first
await makeFriendsWrapper(5) await makeFriendsWrapper(5)
await wait(11000) await wait(11000)
@ -104,8 +104,8 @@ describe('Test advanced friends', function () {
} }
}) })
it('Should make friends with the pods 1, 2, 3', async function () { it('Should remove bad pod and new pod should not become friend with it', async function () {
this.timeout(150000) this.timeout(200000)
// Pods 1, 2, 3 and 4 become friends // Pods 1, 2, 3 and 4 become friends
await makeFriendsWrapper(2) await makeFriendsWrapper(2)
@ -119,6 +119,9 @@ describe('Test advanced friends', function () {
expect(res.body.data.length).to.equal(3) expect(res.body.data.length).to.equal(3)
} }
// Wait initial video channel requests
await wait(11000)
// Kill pod 4 // Kill pod 4
servers[3].app.kill() servers[3].app.kill()
@ -133,6 +136,16 @@ describe('Test advanced friends', function () {
await wait(11000) await wait(11000)
await uploadVideoWrapper(1)
await uploadVideoWrapper(2)
await wait(11000)
await uploadVideoWrapper(1)
await uploadVideoWrapper(2)
await wait(11000)
serverNumbersToTest = [ 1, 2 ] serverNumbersToTest = [ 1, 2 ]
for (const i of serverNumbersToTest) { for (const i of serverNumbersToTest) {
@ -147,31 +160,39 @@ describe('Test advanced friends', function () {
} }
} }
// Rerun server 4 // Rerun server 4
const newServer = await runServer(4) const newServer = await runServer(4)
servers[3].app = newServer.app servers[3].app = newServer.app
servers[3].app servers[3].app
const res1 = await getFriendsListWrapper(4)
// Pod 4 didn't know pod 1 and 2 removed it // Pod 4 didn't know pod 1 and 2 removed it
const res1 = await getFriendsListWrapper(4)
expect(res1.body.data.length).to.equal(3) expect(res1.body.data.length).to.equal(3)
// Pod 3 didn't upload video, it's still friend with pod 3
const res2 = await getFriendsListWrapper(3)
expect(res2.body.data.length).to.equal(3)
// Pod 6 asks pod 1, 2 and 3 // Pod 6 asks pod 1, 2 and 3
await makeFriendsWrapper(6) await makeFriendsWrapper(6)
await wait(11000) await wait(11000)
const res2 = await getFriendsListWrapper(6) const res3 = await getFriendsListWrapper(6)
// Pod 4 should not be our friend // Pod 4 should not be our friend
const friends = res2.body.data const friends = res3.body.data
expect(friends.length).to.equal(3) expect(friends.length).to.equal(3)
for (const pod of friends) { for (const pod of friends) {
expect(pod.host).not.equal(servers[3].host) expect(pod.host).not.equal(servers[3].host)
} }
}) })
// Pod 1 is friend with : 2 3 6
// Pod 2 is friend with : 1 3 6
// Pod 3 is friend with : 1 2 4 6
// Pod 4 is friend with : 1 2 3
// Pod 6 is friend with : 1 2 3
it('Should pod 1 quit friends', async function () { it('Should pod 1 quit friends', async function () {
this.timeout(25000) this.timeout(25000)
@ -180,21 +201,26 @@ describe('Test advanced friends', function () {
await wait(15000) await wait(15000)
// Pod 1 remove friends
await quitFriendsWrapper(1) await quitFriendsWrapper(1)
// Remove pod 1 from pod 2
const res1 = await getVideosWrapper(1) const res1 = await getVideosWrapper(1)
const videos1 = res1.body.data const videos1 = res1.body.data
expect(videos1).to.be.an('array') expect(videos1).to.be.an('array')
expect(videos1.length).to.equal(2) expect(videos1.length).to.equal(4)
const res2 = await getVideosWrapper(2) const res2 = await getVideosWrapper(2)
const videos2 = res2.body.data const videos2 = res2.body.data
expect(videos2).to.be.an('array') expect(videos2).to.be.an('array')
expect(videos2.length).to.equal(3) expect(videos2.length).to.equal(5)
}) })
it('Should make friends between pod 1 and 2 and exchange their videos', async function () { // Pod 1 is friend with nothing
// Pod 2 is friend with : 3 6
// Pod 3 is friend with : 2 4 6
// Pod 4 is friend with : 2 3
// Pod 6 is friend with : 2 3
it('Should make friends between pod 1, 2, 3 and 6 and exchange their videos', async function () {
this.timeout(20000) this.timeout(20000)
await makeFriendsWrapper(1) await makeFriendsWrapper(1)
@ -204,10 +230,15 @@ describe('Test advanced friends', function () {
const res = await getVideosWrapper(1) const res = await getVideosWrapper(1)
const videos = res.body.data const videos = res.body.data
expect(videos).to.be.an('array') expect(videos).to.be.an('array')
expect(videos.length).to.equal(5) expect(videos.length).to.equal(9)
}) })
it('Should allow pod 6 to quit pod 1 & 2 and be friend with pod 3', async function () { // Pod 1 is friend with : 2 3 6
// Pod 2 is friend with : 1 3 6
// Pod 3 is friend with : 1 2 4 6
// Pod 4 is friend with : 2 3
// Pod 6 is friend with : 1 2 3
it('Should allow pod 6 to quit pod 1, 2 and 3 and be friend with pod 3', async function () {
this.timeout(30000) this.timeout(30000)
// Pod 3 should have 4 friends // Pod 3 should have 4 friends

6
server/tests/api/friends-basic.ts
View File

@ -87,7 +87,7 @@ describe('Test basic friends', function () {
const pod1 = friends[0] const pod1 = friends[0]
expect(pod1.host).to.equal(servers[2].host) expect(pod1.host).to.equal(servers[2].host)
expect(pod1.email).to.equal('admin3@example.com') expect(pod1.email).to.equal('admin3@example.com')
expect(pod1.score).to.equal(20) expect(pod1.score).to.be.at.least(20)
expect(dateIsValid(pod1.createdAt)).to.be.true expect(dateIsValid(pod1.createdAt)).to.be.true
// Same here, the third pod should have the second pod as a friend // Same here, the third pod should have the second pod as a friend
@ -99,7 +99,7 @@ describe('Test basic friends', function () {
const pod2 = result[0] const pod2 = result[0]
expect(pod2.host).to.equal(servers[1].host) expect(pod2.host).to.equal(servers[1].host)
expect(pod2.email).to.equal('admin2@example.com') expect(pod2.email).to.equal('admin2@example.com')
expect(pod2.score).to.equal(20) expect(pod2.score).to.be.at.least(20)
expect(dateIsValid(pod2.createdAt)).to.be.true expect(dateIsValid(pod2.createdAt)).to.be.true
// Finally the first pod make friend with the second pod // Finally the first pod make friend with the second pod
@ -133,7 +133,7 @@ describe('Test basic friends', function () {
const pod = res.body.data[0] const pod = res.body.data[0]
expect(pod.host).to.equal('localhost:9002') expect(pod.host).to.equal('localhost:9002')
expect(pod.email).to.equal('admin2@example.com') expect(pod.email).to.equal('admin2@example.com')
expect(pod.score).to.equal(20) expect(pod.score).to.be.at.least(20)
expect(dateIsValid(pod.createdAt)).to.be.true expect(dateIsValid(pod.createdAt)).to.be.true
}) })

134
server/tests/api/multiple-pods.ts
View File

@ -19,8 +19,12 @@ import {
updateVideo, updateVideo,
uploadVideo, uploadVideo,
wait, wait,
webtorrentAdd webtorrentAdd,
addVideoChannel,
getVideoChannelsList,
getUserAccessToken
} from '../utils' } from '../utils'
import { createUser } from '../utils/users'
const expect = chai.expect const expect = chai.expect
@ -28,6 +32,7 @@ describe('Test multiple pods', function () {
let servers: ServerInfo[] = [] let servers: ServerInfo[] = []
const toRemove = [] const toRemove = []
let videoUUID = '' let videoUUID = ''
let videoChannelId: number
before(async function () { before(async function () {
this.timeout(120000) this.timeout(120000)
@ -37,6 +42,14 @@ describe('Test multiple pods', function () {
// Get the access tokens // Get the access tokens
await setAccessTokensToServers(servers) await setAccessTokensToServers(servers)
const videoChannel = {
name: 'my channel',
description: 'super channel'
}
await addVideoChannel(servers[0].url, servers[0].accessToken, videoChannel)
const channelRes = await getVideoChannelsList(servers[0].url, 0, 1)
videoChannelId = channelRes.body.data[0].id
// The second pod make friend with the third // The second pod make friend with the third
await makeFriends(servers[1].url, servers[1].accessToken) await makeFriends(servers[1].url, servers[1].accessToken)
@ -69,6 +82,7 @@ describe('Test multiple pods', function () {
nsfw: true, nsfw: true,
description: 'my super description for pod 1', description: 'my super description for pod 1',
tags: [ 'tag1p1', 'tag2p1' ], tags: [ 'tag1p1', 'tag2p1' ],
channelId: videoChannelId,
fixture: 'video_short1.webm' fixture: 'video_short1.webm'
} }
await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes) await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
@ -101,21 +115,30 @@ describe('Test multiple pods', function () {
expect(dateIsValid(video.updatedAt)).to.be.true expect(dateIsValid(video.updatedAt)).to.be.true
expect(video.author).to.equal('root') expect(video.author).to.equal('root')
expect(video.files).to.have.lengthOf(1) const res2 = await getVideo(server.url, video.uuid)
const videoDetails = res2.body
const file = video.files[0] expect(videoDetails.channel.name).to.equal('my channel')
expect(videoDetails.channel.description).to.equal('super channel')
expect(dateIsValid(videoDetails.channel.createdAt)).to.be.true
expect(dateIsValid(videoDetails.channel.updatedAt)).to.be.true
expect(videoDetails.files).to.have.lengthOf(1)
const file = videoDetails.files[0]
const magnetUri = file.magnetUri const magnetUri = file.magnetUri
expect(file.magnetUri).to.have.lengthOf.above(2) expect(file.magnetUri).to.have.lengthOf.above(2)
expect(file.torrentUrl).to.equal(`http://${video.podHost}/static/torrents/${video.uuid}-${file.resolution}.torrent`) expect(file.torrentUrl).to.equal(`http://${videoDetails.podHost}/static/torrents/${videoDetails.uuid}-${file.resolution}.torrent`)
expect(file.fileUrl).to.equal(`http://${video.podHost}/static/webseed/${video.uuid}-${file.resolution}.webm`) expect(file.fileUrl).to.equal(`http://${videoDetails.podHost}/static/webseed/${videoDetails.uuid}-${file.resolution}.webm`)
expect(file.resolution).to.equal(720) expect(file.resolution).to.equal(720)
expect(file.resolutionLabel).to.equal('720p') expect(file.resolutionLabel).to.equal('720p')
expect(file.size).to.equal(572456) expect(file.size).to.equal(572456)
if (server.url !== 'http://localhost:9001') { if (server.url !== 'http://localhost:9001') {
expect(video.isLocal).to.be.false expect(video.isLocal).to.be.false
expect(videoDetails.channel.isLocal).to.be.false
} else { } else {
expect(video.isLocal).to.be.true expect(video.isLocal).to.be.true
expect(videoDetails.channel.isLocal).to.be.true
} }
// All pods should have the same magnet Uri // All pods should have the same magnet Uri
@ -133,6 +156,13 @@ describe('Test multiple pods', function () {
it('Should upload the video on pod 2 and propagate on each pod', async function () { it('Should upload the video on pod 2 and propagate on each pod', async function () {
this.timeout(120000) this.timeout(120000)
const user = {
username: 'user1',
password: 'super_password'
}
await createUser(servers[1].url, servers[1].accessToken, user.username, user.password)
const userAccessToken = await getUserAccessToken(servers[1], user)
const videoAttributes = { const videoAttributes = {
name: 'my super name for pod 2', name: 'my super name for pod 2',
category: 4, category: 4,
@ -143,7 +173,7 @@ describe('Test multiple pods', function () {
tags: [ 'tag1p2', 'tag2p2', 'tag3p2' ], tags: [ 'tag1p2', 'tag2p2', 'tag3p2' ],
fixture: 'video_short2.webm' fixture: 'video_short2.webm'
} }
await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes) await uploadVideo(servers[1].url, userAccessToken, videoAttributes)
// Transcoding, so wait more than 22000 // Transcoding, so wait more than 22000
await wait(60000) await wait(60000)
@ -172,20 +202,27 @@ describe('Test multiple pods', function () {
expect(video.tags).to.deep.equal([ 'tag1p2', 'tag2p2', 'tag3p2' ]) expect(video.tags).to.deep.equal([ 'tag1p2', 'tag2p2', 'tag3p2' ])
expect(dateIsValid(video.createdAt)).to.be.true expect(dateIsValid(video.createdAt)).to.be.true
expect(dateIsValid(video.updatedAt)).to.be.true expect(dateIsValid(video.updatedAt)).to.be.true
expect(video.author).to.equal('root') expect(video.author).to.equal('user1')
expect(video.files).to.have.lengthOf(4) if (server.url !== 'http://localhost:9002') {
expect(video.isLocal).to.be.false
} else {
expect(video.isLocal).to.be.true
}
const res2 = await getVideo(server.url, video.uuid)
const videoDetails = res2.body
expect(videoDetails.channel.name).to.equal('Default user1 channel')
expect(dateIsValid(videoDetails.channel.createdAt)).to.be.true
expect(dateIsValid(videoDetails.channel.updatedAt)).to.be.true
expect(videoDetails.files).to.have.lengthOf(4)
// Check common attributes // Check common attributes
for (const file of video.files) { for (const file of videoDetails.files) {
expect(file.magnetUri).to.have.lengthOf.above(2) expect(file.magnetUri).to.have.lengthOf.above(2)
if (server.url !== 'http://localhost:9002') {
expect(video.isLocal).to.be.false
} else {
expect(video.isLocal).to.be.true
}
// All pods should have the same magnet Uri // All pods should have the same magnet Uri
if (baseMagnet[file.resolution] === undefined) { if (baseMagnet[file.resolution] === undefined) {
baseMagnet[file.resolution] = file.magnet baseMagnet[file.resolution] = file.magnet
@ -194,27 +231,27 @@ describe('Test multiple pods', function () {
} }
} }
const file240p = video.files.find(f => f.resolution === 240) const file240p = videoDetails.files.find(f => f.resolution === 240)
expect(file240p).not.to.be.undefined expect(file240p).not.to.be.undefined
expect(file240p.resolutionLabel).to.equal('240p') expect(file240p.resolutionLabel).to.equal('240p')
expect(file240p.size).to.be.above(180000).and.below(200000) expect(file240p.size).to.be.above(180000).and.below(200000)
const file360p = video.files.find(f => f.resolution === 360) const file360p = videoDetails.files.find(f => f.resolution === 360)
expect(file360p).not.to.be.undefined expect(file360p).not.to.be.undefined
expect(file360p.resolutionLabel).to.equal('360p') expect(file360p.resolutionLabel).to.equal('360p')
expect(file360p.size).to.be.above(270000).and.below(290000) expect(file360p.size).to.be.above(270000).and.below(290000)
const file480p = video.files.find(f => f.resolution === 480) const file480p = videoDetails.files.find(f => f.resolution === 480)
expect(file480p).not.to.be.undefined expect(file480p).not.to.be.undefined
expect(file480p.resolutionLabel).to.equal('480p') expect(file480p.resolutionLabel).to.equal('480p')
expect(file480p.size).to.be.above(380000).and.below(400000) expect(file480p.size).to.be.above(380000).and.below(400000)
const file720p = video.files.find(f => f.resolution === 720) const file720p = videoDetails.files.find(f => f.resolution === 720)
expect(file720p).not.to.be.undefined expect(file720p).not.to.be.undefined
expect(file720p.resolutionLabel).to.equal('720p') expect(file720p.resolutionLabel).to.equal('720p')
expect(file720p.size).to.be.above(700000).and.below(7200000) expect(file720p.size).to.be.above(700000).and.below(7200000)
const test = await testVideoImage(server.url, 'video_short2.webm', video.thumbnailPath) const test = await testVideoImage(server.url, 'video_short2.webm', videoDetails.thumbnailPath)
expect(test).to.equal(true) expect(test).to.equal(true)
} }
}) })
@ -284,9 +321,11 @@ describe('Test multiple pods', function () {
expect(dateIsValid(video1.createdAt)).to.be.true expect(dateIsValid(video1.createdAt)).to.be.true
expect(dateIsValid(video1.updatedAt)).to.be.true expect(dateIsValid(video1.updatedAt)).to.be.true
expect(video1.files).to.have.lengthOf(1) const res2 = await getVideo(server.url, video1.id)
const video1Details = res2.body
expect(video1Details.files).to.have.lengthOf(1)
const file1 = video1.files[0] const file1 = video1Details.files[0]
expect(file1.magnetUri).to.have.lengthOf.above(2) expect(file1.magnetUri).to.have.lengthOf.above(2)
expect(file1.resolution).to.equal(720) expect(file1.resolution).to.equal(720)
expect(file1.resolutionLabel).to.equal('720p') expect(file1.resolutionLabel).to.equal('720p')
@ -308,9 +347,12 @@ describe('Test multiple pods', function () {
expect(dateIsValid(video2.createdAt)).to.be.true expect(dateIsValid(video2.createdAt)).to.be.true
expect(dateIsValid(video2.updatedAt)).to.be.true expect(dateIsValid(video2.updatedAt)).to.be.true
expect(video2.files).to.have.lengthOf(1) const res3 = await getVideo(server.url, video2.id)
const video2Details = res3.body
const file2 = video2.files[0] expect(video2Details.files).to.have.lengthOf(1)
const file2 = video2Details.files[0]
const magnetUri2 = file2.magnetUri const magnetUri2 = file2.magnetUri
expect(file2.magnetUri).to.have.lengthOf.above(2) expect(file2.magnetUri).to.have.lengthOf.above(2)
expect(file2.resolution).to.equal(720) expect(file2.resolution).to.equal(720)
@ -352,7 +394,10 @@ describe('Test multiple pods', function () {
toRemove.push(res.body.data[2]) toRemove.push(res.body.data[2])
toRemove.push(res.body.data[3]) toRemove.push(res.body.data[3])
const torrent = await webtorrentAdd(video.files[0].magnetUri) const res2 = await getVideo(servers[2].url, video.id)
const videoDetails = res2.body
const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri)
expect(torrent.files).to.be.an('array') expect(torrent.files).to.be.an('array')
expect(torrent.files.length).to.equal(1) expect(torrent.files.length).to.equal(1)
expect(torrent.files[0].path).to.exist.and.to.not.equal('') expect(torrent.files[0].path).to.exist.and.to.not.equal('')
@ -365,8 +410,10 @@ describe('Test multiple pods', function () {
const res = await getVideosList(servers[0].url) const res = await getVideosList(servers[0].url)
const video = res.body.data[1] const video = res.body.data[1]
const res2 = await getVideo(servers[0].url, video.id)
const videoDetails = res2.body
const torrent = await webtorrentAdd(video.files[0].magnetUri) const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri)
expect(torrent.files).to.be.an('array') expect(torrent.files).to.be.an('array')
expect(torrent.files.length).to.equal(1) expect(torrent.files.length).to.equal(1)
expect(torrent.files[0].path).to.exist.and.to.not.equal('') expect(torrent.files[0].path).to.exist.and.to.not.equal('')
@ -379,8 +426,10 @@ describe('Test multiple pods', function () {
const res = await getVideosList(servers[1].url) const res = await getVideosList(servers[1].url)
const video = res.body.data[2] const video = res.body.data[2]
const res2 = await getVideo(servers[1].url, video.id)
const videoDetails = res2.body
const torrent = await webtorrentAdd(video.files[0].magnetUri) const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri)
expect(torrent.files).to.be.an('array') expect(torrent.files).to.be.an('array')
expect(torrent.files.length).to.equal(1) expect(torrent.files.length).to.equal(1)
expect(torrent.files[0].path).to.exist.and.to.not.equal('') expect(torrent.files[0].path).to.exist.and.to.not.equal('')
@ -393,8 +442,10 @@ describe('Test multiple pods', function () {
const res = await getVideosList(servers[0].url) const res = await getVideosList(servers[0].url)
const video = res.body.data[3] const video = res.body.data[3]
const res2 = await getVideo(servers[0].url, video.id)
const videoDetails = res2.body
const torrent = await webtorrentAdd(video.files[0].magnetUri) const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri)
expect(torrent.files).to.be.an('array') expect(torrent.files).to.be.an('array')
expect(torrent.files.length).to.equal(1) expect(torrent.files.length).to.equal(1)
expect(torrent.files[0].path).to.exist.and.to.not.equal('') expect(torrent.files[0].path).to.exist.and.to.not.equal('')
@ -407,7 +458,10 @@ describe('Test multiple pods', function () {
const res = await getVideosList(servers[0].url) const res = await getVideosList(servers[0].url)
const video = res.body.data.find(v => v.name === 'my super name for pod 2') const video = res.body.data.find(v => v.name === 'my super name for pod 2')
const file = video.files.find(f => f.resolution === 360) const res2 = await getVideo(servers[0].url, video.id)
const videoDetails = res2.body
const file = videoDetails.files.find(f => f.resolution === 360)
expect(file).not.to.be.undefined expect(file).not.to.be.undefined
const torrent = await webtorrentAdd(file.magnetUri) const torrent = await webtorrentAdd(file.magnetUri)
@ -425,14 +479,14 @@ describe('Test multiple pods', function () {
before(async function () { before(async function () {
const res1 = await getVideosList(servers[0].url) const res1 = await getVideosList(servers[0].url)
remoteVideosPod1 = res1.body.data.filter(video => video.isLocal === false).map(video => video.id) remoteVideosPod1 = res1.body.data.filter(video => video.isLocal === false).map(video => video.uuid)
const res2 = await getVideosList(servers[1].url) const res2 = await getVideosList(servers[1].url)
remoteVideosPod2 = res2.body.data.filter(video => video.isLocal === false).map(video => video.id) remoteVideosPod2 = res2.body.data.filter(video => video.isLocal === false).map(video => video.uuid)
const res3 = await getVideosList(servers[2].url) const res3 = await getVideosList(servers[2].url)
localVideosPod3 = res3.body.data.filter(video => video.isLocal === true).map(video => video.id) localVideosPod3 = res3.body.data.filter(video => video.isLocal === true).map(video => video.uuid)
remoteVideosPod3 = res3.body.data.filter(video => video.isLocal === false).map(video => video.id) remoteVideosPod3 = res3.body.data.filter(video => video.isLocal === false).map(video => video.uuid)
}) })
it('Should view multiple videos on owned servers', async function () { it('Should view multiple videos on owned servers', async function () {
@ -452,8 +506,11 @@ describe('Test multiple pods', function () {
const res = await getVideosList(server.url) const res = await getVideosList(server.url)
const videos = res.body.data const videos = res.body.data
expect(videos.find(video => video.views === 3)).to.be.an('object') const video0 = videos.find(v => v.uuid === localVideosPod3[0])
expect(videos.find(video => video.views === 1)).to.be.an('object') const video1 = videos.find(v => v.uuid === localVideosPod3[1])
expect(video0.views).to.equal(4)
expect(video1.views).to.equal(2)
} }
}) })
@ -573,7 +630,10 @@ describe('Test multiple pods', function () {
expect(videoUpdated.tags).to.deep.equal([ 'tag_up_1', 'tag_up_2' ]) expect(videoUpdated.tags).to.deep.equal([ 'tag_up_1', 'tag_up_2' ])
expect(dateIsValid(videoUpdated.updatedAt, 20000)).to.be.true expect(dateIsValid(videoUpdated.updatedAt, 20000)).to.be.true
const file = videoUpdated.files[0] const res2 = await getVideo(server.url, videoUpdated.uuid)
const videoUpdatedDetails = res2.body
const file = videoUpdatedDetails .files[0]
expect(file.magnetUri).to.have.lengthOf.above(2) expect(file.magnetUri).to.have.lengthOf.above(2)
expect(file.resolution).to.equal(720) expect(file.resolution).to.equal(720)
expect(file.resolutionLabel).to.equal('720p') expect(file.resolutionLabel).to.equal('720p')
@ -584,7 +644,7 @@ describe('Test multiple pods', function () {
// Avoid "duplicate torrent" errors // Avoid "duplicate torrent" errors
const refreshWebTorrent = true const refreshWebTorrent = true
const torrent = await webtorrentAdd(videoUpdated.files[0].magnetUri, refreshWebTorrent) const torrent = await webtorrentAdd(videoUpdatedDetails .files[0].magnetUri, refreshWebTorrent)
expect(torrent.files).to.be.an('array') expect(torrent.files).to.be.an('array')
expect(torrent.files.length).to.equal(1) expect(torrent.files.length).to.equal(1)
expect(torrent.files[0].path).to.exist.and.to.not.equal('') expect(torrent.files[0].path).to.exist.and.to.not.equal('')

2
server/tests/api/request-schedulers.ts
View File

@ -68,7 +68,7 @@ describe('Test requests schedulers stats', function () {
const res = await getRequestsStats(server) const res = await getRequestsStats(server)
const requestSchedulers = res.body const requestSchedulers = res.body
const requestScheduler = requestSchedulers.requestScheduler const requestScheduler = requestSchedulers.requestScheduler
expect(requestScheduler.totalRequests).to.equal(1) expect(requestScheduler.totalRequests).to.equal(3)
}) })
after(async function () { after(async function () {

63
server/tests/api/single-pod.ts
View File

@ -122,22 +122,25 @@ describe('Test a single pod', function () {
expect(dateIsValid(video.createdAt)).to.be.true expect(dateIsValid(video.createdAt)).to.be.true
expect(dateIsValid(video.updatedAt)).to.be.true expect(dateIsValid(video.updatedAt)).to.be.true
expect(video.files).to.have.lengthOf(1) const res2 = await getVideo(server.url, res.body.data[0].id)
const videoDetails = res2.body
const file = video.files[0] expect(videoDetails.files).to.have.lengthOf(1)
const file = videoDetails.files[0]
const magnetUri = file.magnetUri const magnetUri = file.magnetUri
expect(file.magnetUri).to.have.lengthOf.above(2) expect(file.magnetUri).to.have.lengthOf.above(2)
expect(file.torrentUrl).to.equal(`${server.url}/static/torrents/${video.uuid}-${file.resolution}.torrent`) expect(file.torrentUrl).to.equal(`${server.url}/static/torrents/${videoDetails.uuid}-${file.resolution}.torrent`)
expect(file.fileUrl).to.equal(`${server.url}/static/webseed/${video.uuid}-${file.resolution}.webm`) expect(file.fileUrl).to.equal(`${server.url}/static/webseed/${videoDetails.uuid}-${file.resolution}.webm`)
expect(file.resolution).to.equal(720) expect(file.resolution).to.equal(720)
expect(file.resolutionLabel).to.equal('720p') expect(file.resolutionLabel).to.equal('720p')
expect(file.size).to.equal(218910) expect(file.size).to.equal(218910)
const test = await testVideoImage(server.url, 'video_short.webm', video.thumbnailPath) const test = await testVideoImage(server.url, 'video_short.webm', videoDetails.thumbnailPath)
expect(test).to.equal(true) expect(test).to.equal(true)
videoId = video.id videoId = videoDetails.id
videoUUID = video.uuid videoUUID = videoDetails.uuid
const torrent = await webtorrentAdd(magnetUri) const torrent = await webtorrentAdd(magnetUri)
expect(torrent.files).to.be.an('array') expect(torrent.files).to.be.an('array')
@ -167,6 +170,10 @@ describe('Test a single pod', function () {
expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ]) expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
expect(dateIsValid(video.createdAt)).to.be.true expect(dateIsValid(video.createdAt)).to.be.true
expect(dateIsValid(video.updatedAt)).to.be.true expect(dateIsValid(video.updatedAt)).to.be.true
expect(video.channel.name).to.equal('Default root channel')
expect(video.channel.isLocal).to.be.true
expect(dateIsValid(video.channel.createdAt)).to.be.true
expect(dateIsValid(video.channel.updatedAt)).to.be.true
expect(video.files).to.have.lengthOf(1) expect(video.files).to.have.lengthOf(1)
@ -200,7 +207,7 @@ describe('Test a single pod', function () {
const res = await getVideo(server.url, videoId) const res = await getVideo(server.url, videoId)
const video = res.body const video = res.body
expect(video.views).to.equal(2) expect(video.views).to.equal(3)
}) })
it('Should search the video by name by default', async function () { it('Should search the video by name by default', async function () {
@ -227,14 +234,6 @@ describe('Test a single pod', function () {
expect(dateIsValid(video.createdAt)).to.be.true expect(dateIsValid(video.createdAt)).to.be.true
expect(dateIsValid(video.updatedAt)).to.be.true expect(dateIsValid(video.updatedAt)).to.be.true
expect(video.files).to.have.lengthOf(1)
const file = video.files[0]
expect(file.magnetUri).to.have.lengthOf.above(2)
expect(file.resolution).to.equal(720)
expect(file.resolutionLabel).to.equal('720p')
expect(file.size).to.equal(218910)
const test = await testVideoImage(server.url, 'video_short.webm', video.thumbnailPath) const test = await testVideoImage(server.url, 'video_short.webm', video.thumbnailPath)
expect(test).to.equal(true) expect(test).to.equal(true)
}) })
@ -289,14 +288,6 @@ describe('Test a single pod', function () {
expect(dateIsValid(video.createdAt)).to.be.true expect(dateIsValid(video.createdAt)).to.be.true
expect(dateIsValid(video.updatedAt)).to.be.true expect(dateIsValid(video.updatedAt)).to.be.true
expect(video.files).to.have.lengthOf(1)
const file = video.files[0]
expect(file.magnetUri).to.have.lengthOf.above(2)
expect(file.resolution).to.equal(720)
expect(file.resolutionLabel).to.equal('720p')
expect(file.size).to.equal(218910)
const test = await testVideoImage(server.url, 'video_short.webm', video.thumbnailPath) const test = await testVideoImage(server.url, 'video_short.webm', video.thumbnailPath)
expect(test).to.equal(true) expect(test).to.equal(true)
}) })
@ -493,10 +484,13 @@ describe('Test a single pod', function () {
it('Should search the right magnetUri video', async function () { it('Should search the right magnetUri video', async function () {
const video = videosListBase[0] const video = videosListBase[0]
const res = await searchVideoWithPagination(server.url, encodeURIComponent(video.files[0].magnetUri), 'magnetUri', 0, 15) const res = await getVideo(server.url, video.id)
const videoDetails = res.body
const videos = res.body.data const res2 = await searchVideoWithPagination(server.url, encodeURIComponent(videoDetails.files[0].magnetUri), 'magnetUri', 0, 15)
expect(res.body.total).to.equal(1)
const videos = res2.body.data
expect(res2.body.total).to.equal(1)
expect(videos.length).to.equal(1) expect(videos.length).to.equal(1)
expect(videos[0].name).to.equal(video.name) expect(videos[0].name).to.equal(video.name)
}) })
@ -566,6 +560,11 @@ describe('Test a single pod', function () {
expect(dateIsValid(video.createdAt)).to.be.true expect(dateIsValid(video.createdAt)).to.be.true
expect(dateIsValid(video.updatedAt)).to.be.true expect(dateIsValid(video.updatedAt)).to.be.true
expect(video.channel.name).to.equal('Default root channel')
expect(video.channel.isLocal).to.be.true
expect(dateIsValid(video.channel.createdAt)).to.be.true
expect(dateIsValid(video.channel.updatedAt)).to.be.true
expect(video.files).to.have.lengthOf(1) expect(video.files).to.have.lengthOf(1)
const file = video.files[0] const file = video.files[0]
@ -610,6 +609,11 @@ describe('Test a single pod', function () {
expect(dateIsValid(video.createdAt)).to.be.true expect(dateIsValid(video.createdAt)).to.be.true
expect(dateIsValid(video.updatedAt)).to.be.true expect(dateIsValid(video.updatedAt)).to.be.true
expect(video.channel.name).to.equal('Default root channel')
expect(video.channel.isLocal).to.be.true
expect(dateIsValid(video.channel.createdAt)).to.be.true
expect(dateIsValid(video.channel.updatedAt)).to.be.true
expect(video.files).to.have.lengthOf(1) expect(video.files).to.have.lengthOf(1)
const file = video.files[0] const file = video.files[0]
@ -645,6 +649,11 @@ describe('Test a single pod', function () {
expect(dateIsValid(video.createdAt)).to.be.true expect(dateIsValid(video.createdAt)).to.be.true
expect(dateIsValid(video.updatedAt)).to.be.true expect(dateIsValid(video.updatedAt)).to.be.true
expect(video.channel.name).to.equal('Default root channel')
expect(video.channel.isLocal).to.be.true
expect(dateIsValid(video.channel.createdAt)).to.be.true
expect(dateIsValid(video.channel.updatedAt)).to.be.true
expect(video.files).to.have.lengthOf(1) expect(video.files).to.have.lengthOf(1)
const file = video.files[0] const file = video.files[0]

2
server/tests/api/users.ts
View File

@ -72,7 +72,7 @@ describe('Test users', function () {
}) })
it('Should not login with an invalid password', async function () { it('Should not login with an invalid password', async function () {
const user = { username: server.user.username, password: 'mewthree' } const user = { username: server.user.username, password: 'mew_three' }
const res = await login(server.url, server.client, user, 400) const res = await login(server.url, server.client, user, 400)
expect(res.body.error).to.equal('invalid_grant') expect(res.body.error).to.equal('invalid_grant')

141
server/tests/api/video-channels.ts Normal file
View File

@ -0,0 +1,141 @@
/* tslint:disable:no-unused-expression */
import { keyBy } from 'lodash'
import { join } from 'path'
import 'mocha'
import * as chai from 'chai'
const expect = chai.expect
import {
ServerInfo,
flushTests,
runServer,
setAccessTokensToServers,
killallServers,
getMyUserInformation,
getVideoChannelsList,
addVideoChannel,
getAuthorVideoChannelsList,
updateVideoChannel,
deleteVideoChannel,
getVideoChannel
} from '../utils'
import { User } from '../../../shared'
describe('Test a video channels', function () {
let server: ServerInfo
let userInfo: User
let videoChannelId: number
before(async function () {
this.timeout(120000)
await flushTests()
server = await runServer(1)
await setAccessTokensToServers([ server ])
})
it('Should have one video channel (created with root)', async () => {
const res = await getVideoChannelsList(server.url, 0, 2)
expect(res.body.total).to.equal(1)
expect(res.body.data).to.be.an('array')
expect(res.body.data).to.have.lengthOf(1)
})
it('Should create another video channel', async () => {
const videoChannel = {
name: 'second video channel',
description: 'super video channel description'
}
await addVideoChannel(server.url, server.accessToken, videoChannel)
})
it('Should have two video channels when getting my information', async () => {
const res = await getMyUserInformation(server.url, server.accessToken)
userInfo = res.body
expect(userInfo.videoChannels).to.be.an('array')
expect(userInfo.videoChannels).to.have.lengthOf(2)
const videoChannels = userInfo.videoChannels
expect(videoChannels[0].name).to.equal('Default root channel')
expect(videoChannels[1].name).to.equal('second video channel')
expect(videoChannels[1].description).to.equal('super video channel description')
})
it('Should have two video channels when getting author channels', async () => {
const res = await getAuthorVideoChannelsList(server.url, userInfo.author.uuid)
expect(res.body.total).to.equal(2)
expect(res.body.data).to.be.an('array')
expect(res.body.data).to.have.lengthOf(2)
const videoChannels = res.body.data
expect(videoChannels[0].name).to.equal('Default root channel')
expect(videoChannels[1].name).to.equal('second video channel')
expect(videoChannels[1].description).to.equal('super video channel description')
videoChannelId = videoChannels[1].id
})
it('Should list video channels', async () => {
const res = await getVideoChannelsList(server.url, 1, 1, '-name')
expect(res.body.total).to.equal(2)
expect(res.body.data).to.be.an('array')
expect(res.body.data).to.have.lengthOf(1)
expect(res.body.data[0].name).to.equal('Default root channel')
})
it('Should update video channel', async () => {
const videoChannelAttributes = {
name: 'video channel updated',
description: 'video channel description updated'
}
await updateVideoChannel(server.url, server.accessToken, videoChannelId, videoChannelAttributes)
})
it('Should have video channel updated', async () => {
const res = await getVideoChannelsList(server.url, 0, 1, '-name')
expect(res.body.total).to.equal(2)
expect(res.body.data).to.be.an('array')
expect(res.body.data).to.have.lengthOf(1)
expect(res.body.data[0].name).to.equal('video channel updated')
expect(res.body.data[0].description).to.equal('video channel description updated')
})
it('Should get video channel', async () => {
const res = await getVideoChannel(server.url, videoChannelId)
const videoChannel = res.body
expect(videoChannel.name).to.equal('video channel updated')
expect(videoChannel.description).to.equal('video channel description updated')
})
it('Should delete video channel', async () => {
await deleteVideoChannel(server.url, server.accessToken, videoChannelId)
})
it('Should have video channel deleted', async () => {
const res = await getVideoChannelsList(server.url, 0, 10)
expect(res.body.total).to.equal(1)
expect(res.body.data).to.be.an('array')
expect(res.body.data).to.have.lengthOf(1)
expect(res.body.data[0].name).to.equal('Default root channel')
})
after(async function () {
killallServers([ server ])
// Keep the logs if the test failed
if (this['ok']) {
await flushTests()
}
})
})

17
server/tests/api/video-transcoder.ts
View File

@ -13,7 +13,8 @@ import {
setAccessTokensToServers, setAccessTokensToServers,
flushAndRunMultipleServers, flushAndRunMultipleServers,
killallServers, killallServers,
webtorrentAdd webtorrentAdd,
getVideo
} from '../utils' } from '../utils'
describe('Test video transcoding', function () { describe('Test video transcoding', function () {
@ -42,9 +43,12 @@ describe('Test video transcoding', function () {
const res = await getVideosList(servers[0].url) const res = await getVideosList(servers[0].url)
const video = res.body.data[0] const video = res.body.data[0]
expect(video.files).to.have.lengthOf(1)
const magnetUri = video.files[0].magnetUri const res2 = await getVideo(servers[0].url, video.id)
const videoDetails = res2.body
expect(videoDetails.files).to.have.lengthOf(1)
const magnetUri = videoDetails.files[0].magnetUri
expect(magnetUri).to.match(/\.webm/) expect(magnetUri).to.match(/\.webm/)
const torrent = await webtorrentAdd(magnetUri) const torrent = await webtorrentAdd(magnetUri)
@ -68,9 +72,12 @@ describe('Test video transcoding', function () {
const res = await getVideosList(servers[1].url) const res = await getVideosList(servers[1].url)
const video = res.body.data[0] const video = res.body.data[0]
expect(video.files).to.have.lengthOf(4) const res2 = await getVideo(servers[1].url, video.id)
const videoDetails = res2.body
const magnetUri = video.files[0].magnetUri expect(videoDetails.files).to.have.lengthOf(4)
const magnetUri = videoDetails.files[0].magnetUri
expect(magnetUri).to.match(/\.mp4/) expect(magnetUri).to.match(/\.mp4/)
const torrent = await webtorrentAdd(magnetUri) const torrent = await webtorrentAdd(magnetUri)

12
server/tests/cli/update-host.ts
View File

@ -13,7 +13,8 @@ import {
ServerInfo, ServerInfo,
setAccessTokensToServers, setAccessTokensToServers,
uploadVideo, uploadVideo,
wait wait,
getVideo
} from '../utils' } from '../utils'
describe('Test update host scripts', function () { describe('Test update host scripts', function () {
@ -55,13 +56,16 @@ describe('Test update host scripts', function () {
expect(videos).to.have.lengthOf(2) expect(videos).to.have.lengthOf(2)
for (const video of videos) { for (const video of videos) {
expect(video.files).to.have.lengthOf(4) const res2 = await getVideo(server.url, video.id)
const videoDetails = res2.body
for (const file of video.files) { expect(videoDetails.files).to.have.lengthOf(4)
for (const file of videoDetails.files) {
expect(file.magnetUri).to.contain('localhost%3A9002%2Ftracker%2Fsocket') expect(file.magnetUri).to.contain('localhost%3A9002%2Ftracker%2Fsocket')
expect(file.magnetUri).to.contain('localhost%3A9002%2Fstatic%2Fwebseed%2F') expect(file.magnetUri).to.contain('localhost%3A9002%2Fstatic%2Fwebseed%2F')
const torrent = await parseTorrentVideo(server, video.uuid, file.resolution) const torrent = await parseTorrentVideo(server, videoDetails.uuid, file.resolution)
expect(torrent.announce[0]).to.equal('ws://localhost:9002/tracker/socket') expect(torrent.announce[0]).to.equal('ws://localhost:9002/tracker/socket')
expect(torrent.urlList[0]).to.contain('http://localhost:9002/static/webseed') expect(torrent.urlList[0]).to.contain('http://localhost:9002/static/webseed')
} }

1
server/tests/utils/index.ts
View File

@ -11,4 +11,5 @@ export * from './services'
export * from './users' export * from './users'
export * from './video-abuses' export * from './video-abuses'
export * from './video-blacklist' export * from './video-blacklist'
export * from './video-channels'
export * from './videos' export * from './videos'

2
server/tests/utils/login.ts
View File

@ -32,7 +32,7 @@ async function loginAndGetAccessToken (server: Server) {
return res.body.access_token as string return res.body.access_token as string
} }
async function getUserAccessToken (server, user) { async function getUserAccessToken (server: Server, user: User) {
const res = await login(server.url, server.client, user, 200) const res = await login(server.url, server.client, user, 200)
return res.body.access_token as string return res.body.access_token as string

95
server/tests/utils/video-channels.ts Normal file
View File

@ -0,0 +1,95 @@
import * as request from 'supertest'
type VideoChannelAttributes = {
name?: string
description?: string
}
function getVideoChannelsList (url: string, start: number, count: number, sort?: string) {
const path = '/api/v1/videos/channels'
const req = request(url)
.get(path)
.query({ start: start })
.query({ count: count })
if (sort) req.query({ sort })
return req.set('Accept', 'application/json')
.expect(200)
.expect('Content-Type', /json/)
}
function getAuthorVideoChannelsList (url: string, authorId: number | string) {
const path = '/api/v1/videos/authors/' + authorId + '/channels'
return request(url)
.get(path)
.set('Accept', 'application/json')
.expect(200)
.expect('Content-Type', /json/)
}
function addVideoChannel (url: string, token: string, videoChannelAttributesArg: VideoChannelAttributes, expectedStatus = 204) {
const path = '/api/v1/videos/channels'
// Default attributes
let attributes = {
name: 'my super video channel',
description: 'my super channel description'
}
attributes = Object.assign(attributes, videoChannelAttributesArg)
return request(url)
.post(path)
.send(attributes)
.set('Accept', 'application/json')
.set('Authorization', 'Bearer ' + token)
.expect(expectedStatus)
}
function updateVideoChannel (url: string, token: string, channelId: number, attributes: VideoChannelAttributes, expectedStatus = 204) {
const body = {}
const path = '/api/v1/videos/channels/' + channelId
if (attributes.name) body['name'] = attributes.name
if (attributes.description) body['description'] = attributes.description
return request(url)
.put(path)
.send(body)
.set('Accept', 'application/json')
.set('Authorization', 'Bearer ' + token)
.expect(expectedStatus)
}
function deleteVideoChannel (url: string, token: string, channelId: number, expectedStatus = 204) {
const path = '/api/v1/videos/channels/'
return request(url)
.delete(path + channelId)
.set('Accept', 'application/json')
.set('Authorization', 'Bearer ' + token)
.expect(expectedStatus)
}
function getVideoChannel (url: string, channelId: number) {
const path = '/api/v1/videos/channels/' + channelId
return request(url)
.get(path)
.set('Accept', 'application/json')
.expect(200)
.expect('Content-Type', /json/)
}
// ---------------------------------------------------------------------------
export {
getVideoChannelsList,
getAuthorVideoChannelsList,
addVideoChannel,
updateVideoChannel,
deleteVideoChannel,
getVideoChannel
}

12
server/tests/utils/videos.ts
View File

@ -6,6 +6,7 @@ import * as parseTorrent from 'parse-torrent'
import { makeGetRequest } from './requests' import { makeGetRequest } from './requests'
import { readFilePromise } from './miscs' import { readFilePromise } from './miscs'
import { ServerInfo } from './servers' import { ServerInfo } from './servers'
import { getMyUserInformation } from './users'
type VideoAttributes = { type VideoAttributes = {
name?: string name?: string
@ -15,6 +16,7 @@ type VideoAttributes = {
nsfw?: boolean nsfw?: boolean
description?: string description?: string
tags?: string[] tags?: string[]
channelId?: number
fixture?: string fixture?: string
} }
@ -162,8 +164,14 @@ async function testVideoImage (url: string, imageName: string, imagePath: string
} }
} }
function uploadVideo (url: string, accessToken: string, videoAttributesArg: VideoAttributes, specialStatus = 204) { async function uploadVideo (url: string, accessToken: string, videoAttributesArg: VideoAttributes, specialStatus = 204) {
const path = '/api/v1/videos/upload' const path = '/api/v1/videos/upload'
let defaultChannelId = '1'
try {
const res = await getMyUserInformation(url, accessToken)
defaultChannelId = res.body.videoChannels[0].id
} catch (e) { /* empty */ }
// Default attributes // Default attributes
let attributes = { let attributes = {
@ -171,6 +179,7 @@ function uploadVideo (url: string, accessToken: string, videoAttributesArg: Vide
category: 5, category: 5,
licence: 4, licence: 4,
language: 3, language: 3,
channelId: defaultChannelId,
nsfw: true, nsfw: true,
description: 'my super description', description: 'my super description',
tags: [ 'tag' ], tags: [ 'tag' ],
@ -187,6 +196,7 @@ function uploadVideo (url: string, accessToken: string, videoAttributesArg: Vide
.field('licence', attributes.licence.toString()) .field('licence', attributes.licence.toString())
.field('nsfw', JSON.stringify(attributes.nsfw)) .field('nsfw', JSON.stringify(attributes.nsfw))
.field('description', attributes.description) .field('description', attributes.description)
.field('channelId', attributes.channelId)
if (attributes.language !== undefined) { if (attributes.language !== undefined) {
req.field('language', attributes.language.toString()) req.field('language', attributes.language.toString())