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

Refractor single server test

pull/175/head
Chocobozzz 2017-12-29 10:46:27 +01:00
parent a7ba16b62d
commit a20399c972
No known key found for this signature in database
GPG Key ID: 583A612D890159BE
2 changed files with 151 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

272
server/tests/api/videos/single-server.ts
View File

@ -4,6 +4,7 @@ import * as chai from 'chai'
import { keyBy } from 'lodash'
import 'mocha'
import { join } from 'path'
import { VideoPrivacy } from '../../../../shared/models/videos'
import {
dateIsValid,
flushTests,
@ -29,9 +30,9 @@ import {
updateVideo,
uploadVideo,
wait,
webtorrentAdd
} from '../../utils/index'
import { viewVideo } from '../../utils/videos/videos'
webtorrentAdd,
viewVideo, completeVideoCheck, immutableAssign
} from '../../utils'
const expect = chai.expect
@ -41,6 +42,56 @@ describe('Test a single server', function () {
let videoUUID = ''
let videosListBase: any[] = null
const getCheckAttributes = {
name: 'my super name',
category: 2,
licence: 6,
language: 3,
nsfw: true,
description: 'my super description',
host: 'localhost:9001',
account: 'root',
isLocal: true,
tags: [ 'tag1', 'tag2', 'tag3' ],
privacy: VideoPrivacy.PUBLIC,
channel: {
name: 'Default root channel',
isLocal: true
},
fixture: 'video_short.webm',
files: [
{
resolution: 720,
size: 218910
}
]
}
const updateCheckAttributes = {
name: 'my super video updated',
category: 4,
licence: 2,
language: 5,
nsfw: true,
description: 'my super description updated',
host: 'localhost:9001',
account: 'root',
isLocal: true,
tags: [ 'tagup1', 'tagup2' ],
privacy: VideoPrivacy.PUBLIC,
channel: {
name: 'Default root channel',
isLocal: true
},
fixture: 'video_short3.webm',
files: [
{
resolution: 720,
size: 292677
}
]
}
before(async function () {
this.timeout(10000)
@ -107,9 +158,12 @@ describe('Test a single server', function () {
expect(res.body.video).to.not.be.undefined
expect(res.body.video.id).to.equal(1)
expect(res.body.video.uuid).to.have.length.above(5)
videoId = res.body.video.id
videoUUID = res.body.video.uuid
})
it('Should seed the uploaded video', async function () {
it('Should get and seed the uploaded video', async function () {
// Yes, this could be long
this.timeout(60000)
@ -120,86 +174,7 @@ describe('Test a single server', function () {
expect(res.body.data.length).to.equal(1)
const video = res.body.data[0]
expect(video.name).to.equal('my super name')
expect(video.category).to.equal(2)
expect(video.categoryLabel).to.equal('Films')
expect(video.licence).to.equal(6)
expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
expect(video.language).to.equal(3)
expect(video.languageLabel).to.equal('Mandarin')
expect(video.nsfw).to.be.ok
expect(video.description).to.equal('my super description')
expect(video.serverHost).to.equal('localhost:9001')
expect(video.accountName).to.equal('root')
expect(video.isLocal).to.be.true
expect(dateIsValid(video.createdAt)).to.be.true
expect(dateIsValid(video.updatedAt)).to.be.true
const res2 = await getVideo(server.url, res.body.data[0].id)
const videoDetails = res2.body
expect(videoDetails.files).to.have.lengthOf(1)
const file = videoDetails.files[0]
const magnetUri = file.magnetUri
expect(file.magnetUri).to.have.lengthOf.above(2)
expect(file.torrentUrl).to.equal(`${server.url}/static/torrents/${videoDetails.uuid}-${file.resolution}.torrent`)
expect(file.fileUrl).to.equal(`${server.url}/static/webseed/${videoDetails.uuid}-${file.resolution}.webm`)
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', videoDetails.thumbnailPath)
expect(test).to.equal(true)
videoId = videoDetails.id
videoUUID = videoDetails.uuid
const torrent = await webtorrentAdd(magnetUri)
expect(torrent.files).to.be.an('array')
expect(torrent.files.length).to.equal(1)
expect(torrent.files[0].path).to.exist.and.to.not.equal('')
})
it('Should get the video', async function () {
// Yes, this could be long
this.timeout(60000)
const res = await getVideo(server.url, videoId)
const video = res.body
expect(video.name).to.equal('my super name')
expect(video.category).to.equal(2)
expect(video.categoryLabel).to.equal('Films')
expect(video.licence).to.equal(6)
expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
expect(video.language).to.equal(3)
expect(video.languageLabel).to.equal('Mandarin')
expect(video.nsfw).to.be.ok
expect(video.description).to.equal('my super description')
expect(video.serverHost).to.equal('localhost:9001')
expect(video.accountName).to.equal('root')
expect(video.isLocal).to.be.true
expect(dateIsValid(video.createdAt)).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)
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)
expect(test).to.equal(true)
// Wait the async views increment
await wait(500)
await completeVideoCheck(server.url, video, getCheckAttributes)
})
it('Should get the video by UUID', async function () {
@ -209,10 +184,7 @@ describe('Test a single server', function () {
const res = await getVideo(server.url, videoUUID)
const video = res.body
expect(video.name).to.equal('my super name')
// Wait the async views increment
await wait(500)
await completeVideoCheck(server.url, video, getCheckAttributes)
})
it('Should have the views updated', async function () {
@ -234,23 +206,7 @@ describe('Test a single server', function () {
expect(res.body.data.length).to.equal(1)
const video = res.body.data[0]
expect(video.name).to.equal('my super name')
expect(video.category).to.equal(2)
expect(video.categoryLabel).to.equal('Films')
expect(video.licence).to.equal(6)
expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
expect(video.language).to.equal(3)
expect(video.languageLabel).to.equal('Mandarin')
expect(video.nsfw).to.be.ok
expect(video.description).to.equal('my super description')
expect(video.serverHost).to.equal('localhost:9001')
expect(video.accountName).to.equal('root')
expect(video.isLocal).to.be.true
expect(dateIsValid(video.createdAt)).to.be.true
expect(dateIsValid(video.updatedAt)).to.be.true
const test = await testVideoImage(server.url, 'video_short.webm', video.thumbnailPath)
expect(test).to.equal(true)
await completeVideoCheck(server.url, video, getCheckAttributes)
})
// Not implemented yet
@ -337,10 +293,10 @@ describe('Test a single server', function () {
it('Should remove the video', async function () {
await removeVideo(server.url, server.accessToken, videoId)
const files1 = await readdirPromise(join(__dirname, '..', '..', '..', '..', 'test1/videos/'))
const files1 = await readdirPromise(join(__dirname, '..', '..', '..', '..', 'test1', 'videos'))
expect(files1).to.have.lengthOf(0)
const files2 = await readdirPromise(join(__dirname, '..', '..', '..', '..', 'test1/thumbnails/'))
const files2 = await readdirPromise(join(__dirname, '..', '..', '..', '..', 'test1', 'thumbnails'))
expect(files2).to.have.lengthOf(0)
})
@ -547,127 +503,33 @@ describe('Test a single server', function () {
this.timeout(60000)
const res = await getVideo(server.url, videoId)
const video = res.body
expect(video.name).to.equal('my super video updated')
expect(video.category).to.equal(4)
expect(video.categoryLabel).to.equal('Art')
expect(video.licence).to.equal(2)
expect(video.licenceLabel).to.equal('Attribution - Share Alike')
expect(video.language).to.equal(5)
expect(video.languageLabel).to.equal('Arabic')
expect(video.nsfw).to.be.ok
expect(video.description).to.equal('my super description updated')
expect(video.serverHost).to.equal('localhost:9001')
expect(video.accountName).to.equal('root')
expect(video.account.name).to.equal('root')
expect(video.isLocal).to.be.true
expect(video.tags).to.deep.equal([ 'tagup1', 'tagup2' ])
expect(dateIsValid(video.createdAt)).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)
const file = video.files[0]
const magnetUri = file.magnetUri
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(292677)
const test = await testVideoImage(server.url, 'video_short3.webm', video.thumbnailPath)
expect(test).to.equal(true)
const torrent = await webtorrentAdd(magnetUri)
expect(torrent.files).to.be.an('array')
expect(torrent.files.length).to.equal(1)
expect(torrent.files[0].path).to.exist.and.to.not.equal('')
await completeVideoCheck(server.url, video, updateCheckAttributes)
})
it('Should update only the tags of a video', async function () {
const attributes = {
tags: [ 'tag1', 'tag2', 'supertag' ]
tags: [ 'supertag', 'tag1', 'tag2' ]
}
await updateVideo(server.url, server.accessToken, videoId, attributes)
const res = await getVideo(server.url, videoId)
const video = res.body
expect(video.name).to.equal('my super video updated')
expect(video.category).to.equal(4)
expect(video.categoryLabel).to.equal('Art')
expect(video.licence).to.equal(2)
expect(video.licenceLabel).to.equal('Attribution - Share Alike')
expect(video.language).to.equal(5)
expect(video.languageLabel).to.equal('Arabic')
expect(video.nsfw).to.be.ok
expect(video.description).to.equal('my super description updated')
expect(video.serverHost).to.equal('localhost:9001')
expect(video.accountName).to.equal('root')
expect(video.isLocal).to.be.true
expect(video.tags).to.deep.equal([ 'supertag', 'tag1', 'tag2' ])
expect(dateIsValid(video.createdAt)).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)
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(292677)
await completeVideoCheck(server.url, video, Object.assign(updateCheckAttributes, attributes))
})
it('Should update only the description of a video', async function () {
const attributes = {
description: 'hello everybody'
}
await updateVideo(server.url, server.accessToken, videoId, attributes)
const res = await getVideo(server.url, videoId)
const video = res.body
expect(video.name).to.equal('my super video updated')
expect(video.category).to.equal(4)
expect(video.categoryLabel).to.equal('Art')
expect(video.licence).to.equal(2)
expect(video.licenceLabel).to.equal('Attribution - Share Alike')
expect(video.language).to.equal(5)
expect(video.languageLabel).to.equal('Arabic')
expect(video.nsfw).to.be.ok
expect(video.description).to.equal('hello everybody')
expect(video.serverHost).to.equal('localhost:9001')
expect(video.accountName).to.equal('root')
expect(video.isLocal).to.be.true
expect(video.tags).to.deep.equal([ 'supertag', 'tag1', 'tag2' ])
expect(dateIsValid(video.createdAt)).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)
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(292677)
await completeVideoCheck(server.url, video, Object.assign(updateCheckAttributes, attributes))
})
it('Should like a video', async function () {

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

@ -1,9 +1,14 @@
/* tslint:disable:no-unused-expression */
import { expect } from 'chai'
import { readFile } from 'fs'
import * as parseTorrent from 'parse-torrent'
import { isAbsolute, join } from 'path'
import * as request from 'supertest'
import { getMyUserInformation, makeGetRequest, readFilePromise, ServerInfo } from '../'
import { VideoPrivacy } from '../../../../shared/models/videos'
import { VIDEO_CATEGORIES, VIDEO_LANGUAGES, VIDEO_LICENCES, VIDEO_PRIVACIES } from '../../../initializers'
import { dateIsValid, webtorrentAdd } from '../index'
type VideoAttributes = {
name?: string
@ -312,6 +317,83 @@ function parseTorrentVideo (server: ServerInfo, videoUUID: string, resolution: n
})
}
async function completeVideoCheck (
url: string,
video: any,
attributes: {
name: string
category: number
licence: number
language: number
nsfw: boolean
description: string
host: string
account: string
isLocal: boolean,
tags: string[],
privacy: number,
channel: {
name: string,
isLocal: boolean
}
fixture: string,
files: {
resolution: number
size: number
}[]
}
) {
expect(video.name).to.equal(attributes.name)
expect(video.category).to.equal(attributes.category)
expect(video.categoryLabel).to.equal(VIDEO_CATEGORIES[attributes.category])
expect(video.licence).to.equal(attributes.licence)
expect(video.licenceLabel).to.equal(VIDEO_LICENCES[attributes.licence])
expect(video.language).to.equal(attributes.language)
expect(video.languageLabel).to.equal(VIDEO_LANGUAGES[attributes.language])
expect(video.nsfw).to.equal(attributes.nsfw)
expect(video.description).to.equal(attributes.description)
expect(video.serverHost).to.equal(attributes.host)
expect(video.accountName).to.equal(attributes.account)
expect(video.isLocal).to.equal(attributes.isLocal)
expect(dateIsValid(video.createdAt)).to.be.true
expect(dateIsValid(video.updatedAt)).to.be.true
const res = await getVideo(url, video.id)
const videoDetails = res.body
expect(videoDetails.files).to.have.lengthOf(attributes.files.length)
expect(videoDetails.tags).to.deep.equal(attributes.tags)
expect(videoDetails.privacy).to.deep.equal(attributes.privacy)
expect(videoDetails.privacyLabel).to.deep.equal(VIDEO_PRIVACIES[attributes.privacy])
expect(videoDetails.account.name).to.equal(attributes.account)
expect(videoDetails.channel.name).to.equal(attributes.channel.name)
expect(videoDetails.channel.isLocal).to.equal(attributes.channel.isLocal)
expect(dateIsValid(videoDetails.channel.createdAt)).to.be.true
expect(dateIsValid(videoDetails.channel.updatedAt)).to.be.true
for (const attributeFile of attributes.files) {
const file = videoDetails.files.find(f => f.resolution === attributeFile.resolution)
expect(file).not.to.be.undefined
const magnetUri = file.magnetUri
expect(file.magnetUri).to.have.lengthOf.above(2)
expect(file.torrentUrl).to.equal(`${url}/static/torrents/${videoDetails.uuid}-${file.resolution}.torrent`)
expect(file.fileUrl).to.equal(`${url}/static/webseed/${videoDetails.uuid}-${file.resolution}.webm`)
expect(file.resolution).to.equal(attributeFile.resolution)
expect(file.resolutionLabel).to.equal(attributeFile.resolution + 'p')
expect(file.size).to.equal(attributeFile.size)
const test = await testVideoImage(url, attributes.fixture, videoDetails.thumbnailPath)
expect(test).to.equal(true)
const torrent = await webtorrentAdd(magnetUri, true)
expect(torrent.files).to.be.an('array')
expect(torrent.files.length).to.equal(1)
expect(torrent.files[0].path).to.exist.and.to.not.equal('')
}
}
// ---------------------------------------------------------------------------
export {
@ -335,5 +417,6 @@ export {
updateVideo,
rateVideo,
viewVideo,
parseTorrentVideo
parseTorrentVideo,
completeVideoCheck
}