PeerTube/server/tests/api/single-pod.js

763 lines
24 KiB
JavaScript
Raw Normal View History

/* eslint-disable no-unused-expressions */
'use strict'
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
const fs = require('fs')
2016-05-03 22:41:46 +02:00
const keyBy = require('lodash/keyBy')
2016-03-16 22:29:27 +01:00
const pathUtils = require('path')
2016-07-18 17:17:52 +02:00
const series = require('async/series')
const webtorrent = new (require('webtorrent'))()
const loginUtils = require('../utils/login')
const miscsUtils = require('../utils/miscs')
const serversUtils = require('../utils/servers')
const videosUtils = require('../utils/videos')
describe('Test a single pod', function () {
let server = null
let videoId = -1
let videosListBase = null
before(function (done) {
this.timeout(20000)
2016-07-18 17:17:52 +02:00
series([
function (next) {
serversUtils.flushTests(next)
},
function (next) {
serversUtils.runServer(1, function (server1) {
server = server1
next()
})
},
function (next) {
loginUtils.loginAndGetAccessToken(server, function (err, token) {
if (err) throw err
2016-05-13 15:27:31 +02:00
server.accessToken = token
next()
})
}
], done)
})
2015-06-09 17:41:40 +02:00
2017-03-22 21:15:55 +01:00
it('Should list video categories', function (done) {
videosUtils.getVideoCategories(server.url, function (err, res) {
if (err) throw err
const categories = res.body
expect(Object.keys(categories)).to.have.length.above(10)
expect(categories[11]).to.equal('News')
done()
})
})
2017-03-27 20:53:11 +02:00
it('Should list video licences', function (done) {
videosUtils.getVideoLicences(server.url, function (err, res) {
if (err) throw err
const licences = res.body
expect(Object.keys(licences)).to.have.length.above(5)
expect(licences[3]).to.equal('Attribution - No Derivatives')
done()
})
})
2017-04-07 12:13:37 +02:00
it('Should list video languages', function (done) {
videosUtils.getVideoLanguages(server.url, function (err, res) {
if (err) throw err
const languages = res.body
expect(Object.keys(languages)).to.have.length.above(5)
expect(languages[3]).to.equal('Mandarin')
done()
})
})
it('Should not have videos', function (done) {
videosUtils.getVideosList(server.url, function (err, res) {
if (err) throw err
2015-06-09 17:41:40 +02:00
expect(res.body.total).to.equal(0)
expect(res.body.data).to.be.an('array')
expect(res.body.data.length).to.equal(0)
2015-06-09 17:41:40 +02:00
done()
2015-06-09 17:41:40 +02:00
})
})
2015-06-09 17:41:40 +02:00
it('Should upload the video', function (done) {
const videoAttributes = {
name: 'my super name',
category: 2,
2017-03-28 21:19:46 +02:00
nsfw: true,
2017-03-27 20:53:11 +02:00
licence: 6,
tags: [ 'tag1', 'tag2', 'tag3' ]
}
videosUtils.uploadVideo(server.url, server.accessToken, videoAttributes, done)
})
2015-06-09 17:41:40 +02:00
it('Should seed the uploaded video', function (done) {
// Yes, this could be long
this.timeout(60000)
2015-06-09 17:41:40 +02:00
videosUtils.getVideosList(server.url, function (err, res) {
if (err) throw err
2015-06-09 17:41:40 +02:00
expect(res.body.total).to.equal(1)
expect(res.body.data).to.be.an('array')
expect(res.body.data.length).to.equal(1)
2015-06-09 17:41:40 +02:00
const video = res.body.data[0]
expect(video.name).to.equal('my super name')
2017-03-22 21:15:55 +01:00
expect(video.category).to.equal(2)
expect(video.categoryLabel).to.equal('Films')
2017-03-27 20:53:11 +02:00
expect(video.licence).to.equal(6)
expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
2017-04-07 12:13:37 +02:00
expect(video.language).to.equal(3)
expect(video.languageLabel).to.equal('Mandarin')
2017-03-28 21:19:46 +02:00
expect(video.nsfw).to.be.truthy
expect(video.description).to.equal('my super description')
2016-11-14 20:45:00 +01:00
expect(video.podHost).to.equal('localhost:9001')
expect(video.magnetUri).to.exist
2016-05-03 21:03:51 +02:00
expect(video.author).to.equal('root')
expect(video.isLocal).to.be.true
2016-06-06 14:15:03 +02:00
expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
2016-12-11 21:50:51 +01:00
expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
2015-06-09 17:41:40 +02:00
videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
2016-05-10 21:55:59 +02:00
if (err) throw err
expect(test).to.equal(true)
2016-03-18 16:28:09 +01:00
videoId = video.id
2016-03-18 16:28:09 +01:00
2016-05-10 21:55:59 +02:00
webtorrent.add(video.magnetUri, function (torrent) {
expect(torrent.files).to.exist
expect(torrent.files.length).to.equal(1)
expect(torrent.files[0].path).to.exist.and.to.not.equal('')
2017-01-12 10:06:03 +01:00
done()
2016-05-10 21:55:59 +02:00
})
2016-03-18 16:28:09 +01:00
})
})
})
it('Should get the video', function (done) {
// Yes, this could be long
this.timeout(60000)
videosUtils.getVideo(server.url, videoId, function (err, res) {
2016-03-18 16:28:09 +01:00
if (err) throw err
const video = res.body
expect(video.name).to.equal('my super name')
2017-03-22 21:15:55 +01:00
expect(video.category).to.equal(2)
expect(video.categoryLabel).to.equal('Films')
2017-03-27 20:53:11 +02:00
expect(video.licence).to.equal(6)
expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
2017-04-07 12:13:37 +02:00
expect(video.language).to.equal(3)
expect(video.languageLabel).to.equal('Mandarin')
2017-03-28 21:19:46 +02:00
expect(video.nsfw).to.be.truthy
2016-03-18 16:28:09 +01:00
expect(video.description).to.equal('my super description')
2016-11-14 20:45:00 +01:00
expect(video.podHost).to.equal('localhost:9001')
2016-03-18 16:28:09 +01:00
expect(video.magnetUri).to.exist
2016-05-03 21:03:51 +02:00
expect(video.author).to.equal('root')
expect(video.isLocal).to.be.true
2016-06-06 14:15:03 +02:00
expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
2016-12-11 21:50:51 +01:00
expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
2015-06-09 17:41:40 +02:00
videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
2016-05-10 21:55:59 +02:00
if (err) throw err
expect(test).to.equal(true)
2015-06-09 17:41:40 +02:00
2016-08-14 16:50:22 +02:00
done()
2015-12-06 17:09:07 +01:00
})
2015-06-09 17:41:40 +02:00
})
})
2015-06-09 17:41:40 +02:00
it('Should have the views updated', function (done) {
videosUtils.getVideo(server.url, videoId, function (err, res) {
if (err) throw err
const video = res.body
expect(video.views).to.equal(1)
done()
})
})
it('Should search the video by name by default', function (done) {
videosUtils.searchVideo(server.url, 'my', function (err, res) {
if (err) throw err
2015-12-05 10:28:27 +01:00
expect(res.body.total).to.equal(1)
expect(res.body.data).to.be.an('array')
expect(res.body.data.length).to.equal(1)
2015-12-05 10:28:27 +01:00
const video = res.body.data[0]
expect(video.name).to.equal('my super name')
2017-03-22 21:15:55 +01:00
expect(video.category).to.equal(2)
expect(video.categoryLabel).to.equal('Films')
2017-03-27 20:53:11 +02:00
expect(video.licence).to.equal(6)
expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
2017-04-07 12:13:37 +02:00
expect(video.language).to.equal(3)
expect(video.languageLabel).to.equal('Mandarin')
2017-03-28 21:19:46 +02:00
expect(video.nsfw).to.be.truthy
expect(video.description).to.equal('my super description')
2016-11-14 20:45:00 +01:00
expect(video.podHost).to.equal('localhost:9001')
2016-05-03 21:03:51 +02:00
expect(video.author).to.equal('root')
expect(video.isLocal).to.be.true
2016-06-06 14:15:03 +02:00
expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
2016-12-11 21:50:51 +01:00
expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
2015-12-05 10:28:27 +01:00
videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
2016-05-10 21:55:59 +02:00
if (err) throw err
expect(test).to.equal(true)
done()
})
2015-12-05 10:28:27 +01:00
})
})
2015-12-05 10:28:27 +01:00
2016-12-24 16:59:17 +01:00
// Not implemented yet
// it('Should search the video by podHost', function (done) {
// videosUtils.searchVideo(server.url, '9001', 'host', function (err, res) {
// if (err) throw err
// expect(res.body.total).to.equal(1)
// expect(res.body.data).to.be.an('array')
// expect(res.body.data.length).to.equal(1)
// const video = res.body.data[0]
// expect(video.name).to.equal('my super name')
// expect(video.description).to.equal('my super description')
// expect(video.podHost).to.equal('localhost:9001')
// expect(video.author).to.equal('root')
// expect(video.isLocal).to.be.true
// expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
// expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
// expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
2016-12-24 16:59:17 +01:00
// videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
// if (err) throw err
// expect(test).to.equal(true)
// done()
// })
// })
// })
2016-06-06 14:54:52 +02:00
it('Should search the video by tag', function (done) {
videosUtils.searchVideo(server.url, 'tag1', 'tags', function (err, res) {
2016-06-06 14:54:52 +02:00
if (err) throw err
expect(res.body.total).to.equal(1)
expect(res.body.data).to.be.an('array')
expect(res.body.data.length).to.equal(1)
const video = res.body.data[0]
expect(video.name).to.equal('my super name')
2017-03-22 21:15:55 +01:00
expect(video.category).to.equal(2)
expect(video.categoryLabel).to.equal('Films')
2017-03-27 20:53:11 +02:00
expect(video.licence).to.equal(6)
expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
2017-04-07 12:13:37 +02:00
expect(video.language).to.equal(3)
expect(video.languageLabel).to.equal('Mandarin')
2017-03-28 21:19:46 +02:00
expect(video.nsfw).to.be.truthy
2016-06-06 14:54:52 +02:00
expect(video.description).to.equal('my super description')
2016-11-14 20:45:00 +01:00
expect(video.podHost).to.equal('localhost:9001')
2016-06-06 14:54:52 +02:00
expect(video.author).to.equal('root')
expect(video.isLocal).to.be.true
expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
2016-12-11 21:50:51 +01:00
expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
2016-06-06 14:54:52 +02:00
videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
2016-06-06 14:54:52 +02:00
if (err) throw err
expect(test).to.equal(true)
done()
})
})
})
it('Should not find a search by name by default', function (done) {
videosUtils.searchVideo(server.url, 'hello', function (err, res) {
if (err) throw err
2015-12-05 10:28:27 +01:00
expect(res.body.total).to.equal(0)
expect(res.body.data).to.be.an('array')
expect(res.body.data.length).to.equal(0)
2015-12-05 10:28:27 +01:00
done()
2015-12-05 10:28:27 +01:00
})
})
2015-12-05 10:28:27 +01:00
it('Should not find a search by author', function (done) {
videosUtils.searchVideo(server.url, 'hello', 'author', function (err, res) {
if (err) throw err
expect(res.body.total).to.equal(0)
expect(res.body.data).to.be.an('array')
expect(res.body.data.length).to.equal(0)
done()
})
})
2016-06-06 14:54:52 +02:00
it('Should not find a search by tag', function (done) {
2016-12-24 16:59:17 +01:00
videosUtils.searchVideo(server.url, 'hello', 'tags', function (err, res) {
2016-06-06 14:54:52 +02:00
if (err) throw err
expect(res.body.total).to.equal(0)
expect(res.body.data).to.be.an('array')
expect(res.body.data.length).to.equal(0)
done()
})
})
it('Should remove the video', function (done) {
videosUtils.removeVideo(server.url, server.accessToken, videoId, function (err) {
if (err) throw err
2015-11-06 17:34:15 +01:00
2017-01-17 21:42:47 +01:00
fs.readdir(pathUtils.join(__dirname, '..', '..', '..', 'test1/videos/'), function (err, files) {
if (err) throw err
2015-11-06 17:34:15 +01:00
expect(files.length).to.equal(0)
2016-10-21 11:33:31 +02:00
2017-01-17 21:42:47 +01:00
fs.readdir(pathUtils.join(__dirname, '..', '..', '..', 'test1/thumbnails/'), function (err, files) {
2016-10-21 11:33:31 +02:00
if (err) throw err
expect(files.length).to.equal(0)
done()
})
2015-12-06 17:09:07 +01:00
})
2015-06-09 17:41:40 +02:00
})
})
2015-06-09 17:41:40 +02:00
it('Should not have videos', function (done) {
videosUtils.getVideosList(server.url, function (err, res) {
if (err) throw err
2015-06-09 17:41:40 +02:00
expect(res.body.total).to.equal(0)
expect(res.body.data).to.be.an('array')
expect(res.body.data.length).to.equal(0)
2015-06-09 17:41:40 +02:00
done()
2015-06-09 17:41:40 +02:00
})
})
2015-06-09 17:41:40 +02:00
2016-05-03 22:41:46 +02:00
it('Should upload 6 videos', function (done) {
this.timeout(25000)
const videos = [
'video_short.mp4', 'video_short.ogv', 'video_short.webm',
'video_short1.webm', 'video_short2.webm', 'video_short3.webm'
]
2016-07-18 17:17:52 +02:00
each(videos, function (video, callbackEach) {
const videoAttributes = {
name: video + ' name',
description: video + ' description',
category: 2,
2017-03-27 20:53:11 +02:00
licence: 1,
2017-04-07 12:13:37 +02:00
language: 1,
2017-03-28 21:19:46 +02:00
nsfw: true,
tags: [ 'tag1', 'tag2', 'tag3' ],
fixture: video
}
2016-06-06 14:15:03 +02:00
videosUtils.uploadVideo(server.url, server.accessToken, videoAttributes, callbackEach)
2016-05-03 22:41:46 +02:00
}, done)
})
it('Should have the correct durations', function (done) {
videosUtils.getVideosList(server.url, function (err, res) {
2016-05-03 22:41:46 +02:00
if (err) throw err
expect(res.body.total).to.equal(6)
const videos = res.body.data
2016-05-03 22:41:46 +02:00
expect(videos).to.be.an('array')
expect(videos.length).to.equal(6)
const videosByName = keyBy(videos, 'name')
expect(videosByName['video_short.mp4 name'].duration).to.equal(5)
expect(videosByName['video_short.ogv name'].duration).to.equal(5)
expect(videosByName['video_short.webm name'].duration).to.equal(5)
expect(videosByName['video_short1.webm name'].duration).to.equal(10)
expect(videosByName['video_short2.webm name'].duration).to.equal(5)
expect(videosByName['video_short3.webm name'].duration).to.equal(5)
2016-05-03 22:41:46 +02:00
done()
})
})
2016-05-10 21:55:59 +02:00
it('Should have the correct thumbnails', function (done) {
videosUtils.getVideosList(server.url, function (err, res) {
if (err) throw err
const videos = res.body.data
// For the next test
videosListBase = videos
2016-05-10 21:55:59 +02:00
2016-07-18 17:17:52 +02:00
each(videos, function (video, callbackEach) {
2016-05-10 21:55:59 +02:00
if (err) throw err
const videoName = video.name.replace(' name', '')
2016-05-10 21:55:59 +02:00
videosUtils.testVideoImage(server.url, videoName, video.thumbnailPath, function (err, test) {
2016-05-10 21:55:59 +02:00
if (err) throw err
expect(test).to.equal(true)
callbackEach()
2016-05-10 21:55:59 +02:00
})
}, done)
})
})
it('Should list only the two first videos', function (done) {
2017-01-12 13:08:47 +01:00
videosUtils.getVideosListPagination(server.url, 0, 2, 'name', function (err, res) {
if (err) throw err
const videos = res.body.data
expect(res.body.total).to.equal(6)
expect(videos.length).to.equal(2)
2017-01-12 13:08:47 +01:00
expect(videos[0].name).to.equal(videosListBase[0].name)
expect(videos[1].name).to.equal(videosListBase[1].name)
done()
})
})
it('Should list only the next three videos', function (done) {
2017-01-12 13:08:47 +01:00
videosUtils.getVideosListPagination(server.url, 2, 3, 'name', function (err, res) {
if (err) throw err
const videos = res.body.data
expect(res.body.total).to.equal(6)
expect(videos.length).to.equal(3)
2017-01-12 13:08:47 +01:00
expect(videos[0].name).to.equal(videosListBase[2].name)
expect(videos[1].name).to.equal(videosListBase[3].name)
expect(videos[2].name).to.equal(videosListBase[4].name)
done()
})
})
it('Should list the last video', function (done) {
2017-01-12 13:08:47 +01:00
videosUtils.getVideosListPagination(server.url, 5, 6, 'name', function (err, res) {
if (err) throw err
const videos = res.body.data
expect(res.body.total).to.equal(6)
expect(videos.length).to.equal(1)
2017-01-12 13:08:47 +01:00
expect(videos[0].name).to.equal(videosListBase[5].name)
done()
})
})
it('Should search the first video', function (done) {
2017-01-12 13:08:47 +01:00
videosUtils.searchVideoWithPagination(server.url, 'webm', 'name', 0, 1, 'name', function (err, res) {
if (err) throw err
const videos = res.body.data
expect(res.body.total).to.equal(4)
expect(videos.length).to.equal(1)
2017-01-12 13:08:47 +01:00
expect(videos[0].name).to.equal('video_short1.webm name')
done()
})
})
it('Should search the last two videos', function (done) {
2017-01-12 13:08:47 +01:00
videosUtils.searchVideoWithPagination(server.url, 'webm', 'name', 2, 2, 'name', function (err, res) {
if (err) throw err
const videos = res.body.data
expect(res.body.total).to.equal(4)
expect(videos.length).to.equal(2)
2017-01-12 13:08:47 +01:00
expect(videos[0].name).to.equal('video_short3.webm name')
expect(videos[1].name).to.equal('video_short.webm name')
done()
})
})
it('Should search all the webm videos', function (done) {
videosUtils.searchVideoWithPagination(server.url, 'webm', 'name', 0, 15, function (err, res) {
if (err) throw err
const videos = res.body.data
expect(res.body.total).to.equal(4)
expect(videos.length).to.equal(4)
done()
})
})
it('Should search all the root author videos', function (done) {
videosUtils.searchVideoWithPagination(server.url, 'root', 'author', 0, 15, function (err, res) {
if (err) throw err
const videos = res.body.data
expect(res.body.total).to.equal(6)
expect(videos.length).to.equal(6)
done()
})
})
2016-12-24 16:59:17 +01:00
// Not implemented yet
// it('Should search all the 9001 port videos', function (done) {
// videosUtils.searchVideoWithPagination(server.url, '9001', 'host', 0, 15, function (err, res) {
// if (err) throw err
2016-12-24 16:59:17 +01:00
// const videos = res.body.data
// expect(res.body.total).to.equal(6)
// expect(videos.length).to.equal(6)
2016-12-24 16:59:17 +01:00
// done()
// })
// })
2016-12-24 16:59:17 +01:00
// it('Should search all the localhost videos', function (done) {
// videosUtils.searchVideoWithPagination(server.url, 'localhost', 'host', 0, 15, function (err, res) {
// if (err) throw err
2016-12-24 16:59:17 +01:00
// const videos = res.body.data
// expect(res.body.total).to.equal(6)
// expect(videos.length).to.equal(6)
2016-12-24 16:59:17 +01:00
// done()
// })
// })
2017-03-22 21:15:55 +01:00
it('Should search the right magnetUri video', function (done) {
const video = videosListBase[0]
videosUtils.searchVideoWithPagination(server.url, encodeURIComponent(video.magnetUri), 'magnetUri', 0, 15, function (err, res) {
if (err) throw err
const videos = res.body.data
expect(res.body.total).to.equal(1)
expect(videos.length).to.equal(1)
expect(videos[0].name).to.equal(video.name)
done()
})
})
2016-05-17 21:03:00 +02:00
it('Should list and sort by name in descending order', function (done) {
videosUtils.getVideosListSort(server.url, '-name', function (err, res) {
2016-05-17 21:03:00 +02:00
if (err) throw err
const videos = res.body.data
expect(res.body.total).to.equal(6)
2016-05-17 21:03:00 +02:00
expect(videos.length).to.equal(6)
2017-01-12 13:08:47 +01:00
expect(videos[0].name).to.equal('video_short.webm name')
expect(videos[1].name).to.equal('video_short.ogv name')
expect(videos[2].name).to.equal('video_short.mp4 name')
expect(videos[3].name).to.equal('video_short3.webm name')
expect(videos[4].name).to.equal('video_short2.webm name')
expect(videos[5].name).to.equal('video_short1.webm name')
2016-05-17 21:03:00 +02:00
done()
})
})
it('Should search and sort by name in ascending order', function (done) {
videosUtils.searchVideoWithSort(server.url, 'webm', 'name', function (err, res) {
2016-05-17 21:03:00 +02:00
if (err) throw err
const videos = res.body.data
expect(res.body.total).to.equal(4)
2016-05-17 21:03:00 +02:00
expect(videos.length).to.equal(4)
2017-01-12 13:08:47 +01:00
expect(videos[0].name).to.equal('video_short1.webm name')
expect(videos[1].name).to.equal('video_short2.webm name')
expect(videos[2].name).to.equal('video_short3.webm name')
expect(videos[3].name).to.equal('video_short.webm name')
2016-05-17 21:03:00 +02:00
2017-01-12 13:08:47 +01:00
videoId = videos[2].id
2016-12-29 19:07:05 +01:00
2016-05-17 21:03:00 +02:00
done()
})
})
2016-12-29 19:07:05 +01:00
it('Should update a video', function (done) {
const attributes = {
name: 'my super video updated',
category: 4,
2017-03-27 20:53:11 +02:00
licence: 2,
2017-04-07 12:13:37 +02:00
language: 5,
2017-03-28 21:19:46 +02:00
nsfw: false,
description: 'my super description updated',
tags: [ 'tagup1', 'tagup2' ]
}
videosUtils.updateVideo(server.url, server.accessToken, videoId, attributes, done)
2016-12-29 19:07:05 +01:00
})
it('Should have the video updated', function (done) {
this.timeout(60000)
2016-12-29 19:07:05 +01:00
videosUtils.getVideo(server.url, videoId, function (err, res) {
if (err) throw err
const video = res.body
expect(video.name).to.equal('my super video updated')
2017-03-22 21:15:55 +01:00
expect(video.category).to.equal(4)
expect(video.categoryLabel).to.equal('Art')
2017-03-27 20:53:11 +02:00
expect(video.licence).to.equal(2)
expect(video.licenceLabel).to.equal('Attribution - Share Alike')
2017-04-07 12:13:37 +02:00
expect(video.language).to.equal(5)
expect(video.languageLabel).to.equal('Arabic')
2017-03-28 21:19:46 +02:00
expect(video.nsfw).to.be.truthy
2016-12-29 19:07:05 +01:00
expect(video.description).to.equal('my super description updated')
expect(video.podHost).to.equal('localhost:9001')
expect(video.author).to.equal('root')
expect(video.isLocal).to.be.true
expect(video.tags).to.deep.equal([ 'tagup1', 'tagup2' ])
expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
2016-12-29 19:07:05 +01:00
videosUtils.testVideoImage(server.url, 'video_short3.webm', video.thumbnailPath, function (err, test) {
if (err) throw err
expect(test).to.equal(true)
webtorrent.add(video.magnetUri, function (torrent) {
expect(torrent.files).to.exist
expect(torrent.files.length).to.equal(1)
expect(torrent.files[0].path).to.exist.and.to.not.equal('')
done()
})
})
2016-12-29 19:07:05 +01:00
})
})
it('Should update only the tags of a video', function (done) {
const attributes = {
tags: [ 'tag1', 'tag2', 'supertag' ]
}
2016-12-29 19:07:05 +01:00
videosUtils.updateVideo(server.url, server.accessToken, videoId, attributes, function (err) {
2016-12-29 19:07:05 +01:00
if (err) throw err
videosUtils.getVideo(server.url, videoId, function (err, res) {
if (err) throw err
const video = res.body
expect(video.name).to.equal('my super video updated')
2017-03-22 21:15:55 +01:00
expect(video.category).to.equal(4)
expect(video.categoryLabel).to.equal('Art')
2017-03-27 20:53:11 +02:00
expect(video.licence).to.equal(2)
expect(video.licenceLabel).to.equal('Attribution - Share Alike')
2017-04-07 12:13:37 +02:00
expect(video.language).to.equal(5)
expect(video.languageLabel).to.equal('Arabic')
2017-03-28 21:19:46 +02:00
expect(video.nsfw).to.be.truthy
2016-12-29 19:07:05 +01:00
expect(video.description).to.equal('my super description updated')
expect(video.podHost).to.equal('localhost:9001')
expect(video.author).to.equal('root')
expect(video.isLocal).to.be.true
expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'supertag' ])
expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
2016-12-29 19:07:05 +01:00
done()
})
})
})
it('Should update only the description of a video', function (done) {
const attributes = {
description: 'hello everybody'
}
2016-12-29 19:07:05 +01:00
videosUtils.updateVideo(server.url, server.accessToken, videoId, attributes, function (err) {
2016-12-29 19:07:05 +01:00
if (err) throw err
videosUtils.getVideo(server.url, videoId, function (err, res) {
if (err) throw err
const video = res.body
expect(video.name).to.equal('my super video updated')
2017-03-22 21:15:55 +01:00
expect(video.category).to.equal(4)
expect(video.categoryLabel).to.equal('Art')
2017-03-27 20:53:11 +02:00
expect(video.licence).to.equal(2)
expect(video.licenceLabel).to.equal('Attribution - Share Alike')
2017-04-07 12:13:37 +02:00
expect(video.language).to.equal(5)
expect(video.languageLabel).to.equal('Arabic')
2017-03-28 21:19:46 +02:00
expect(video.nsfw).to.be.truthy
2016-12-29 19:07:05 +01:00
expect(video.description).to.equal('hello everybody')
expect(video.podHost).to.equal('localhost:9001')
expect(video.author).to.equal('root')
expect(video.isLocal).to.be.true
expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'supertag' ])
expect(miscsUtils.dateIsValid(video.createdAt)).to.be.true
expect(miscsUtils.dateIsValid(video.updatedAt)).to.be.true
2016-12-29 19:07:05 +01:00
done()
})
})
})
2017-03-08 21:35:43 +01:00
it('Should like a video', function (done) {
videosUtils.rateVideo(server.url, server.accessToken, videoId, 'like', function (err) {
if (err) throw err
videosUtils.getVideo(server.url, videoId, function (err, res) {
if (err) throw err
const video = res.body
expect(video.likes).to.equal(1)
expect(video.dislikes).to.equal(0)
done()
})
})
})
it('Should dislike the same video', function (done) {
videosUtils.rateVideo(server.url, server.accessToken, videoId, 'dislike', function (err) {
if (err) throw err
videosUtils.getVideo(server.url, videoId, function (err, res) {
if (err) throw err
const video = res.body
expect(video.likes).to.equal(0)
expect(video.dislikes).to.equal(1)
done()
})
})
})
after(function (done) {
process.kill(-server.app.pid)
2015-06-09 17:41:40 +02:00
// Keep the logs if the test failed
if (this.ok) {
serversUtils.flushTests(done)
} else {
done()
}
2015-06-09 17:41:40 +02:00
})
})