1 /* tslint:disable:no-unused-expression */
3 import * as chai from 'chai'
4 import { keyBy } from 'lodash'
6 import { VideoPrivacy } from '../../../../shared/models/videos'
8 checkVideoFilesWereRemoved,
17 getVideosListPagination,
25 setAccessTokensToServers,
33 const expect = chai.expect
35 describe('Test a single server', function () {
36 let server: ServerInfo = null
39 let videosListBase: any[] = null
41 const getCheckAttributes = {
42 name: 'my super name',
47 description: 'my super description',
48 support: 'my super support text',
51 host: 'localhost:9001'
55 tags: [ 'tag1', 'tag2', 'tag3' ],
56 privacy: VideoPrivacy.PUBLIC,
57 commentsEnabled: true,
59 displayName: 'Main root channel',
64 fixture: 'video_short.webm',
73 const updateCheckAttributes = {
74 name: 'my super video updated',
79 description: 'my super description updated',
80 support: 'my super support text updated',
83 host: 'localhost:9001'
86 tags: [ 'tagup1', 'tagup2' ],
87 privacy: VideoPrivacy.PUBLIC,
89 commentsEnabled: false,
92 displayName: 'Main root channel',
96 fixture: 'video_short3.webm',
105 before(async function () {
110 server = await runServer(1)
112 await setAccessTokensToServers([ server ])
115 it('Should list video categories', async function () {
116 const res = await getVideoCategories(server.url)
118 const categories = res.body
119 expect(Object.keys(categories)).to.have.length.above(10)
121 expect(categories[11]).to.equal('News')
124 it('Should list video licences', async function () {
125 const res = await getVideoLicences(server.url)
127 const licences = res.body
128 expect(Object.keys(licences)).to.have.length.above(5)
130 expect(licences[3]).to.equal('Attribution - No Derivatives')
133 it('Should list video languages', async function () {
134 const res = await getVideoLanguages(server.url)
136 const languages = res.body
137 expect(Object.keys(languages)).to.have.length.above(5)
139 expect(languages['ru']).to.equal('Russian')
142 it('Should list video privacies', async function () {
143 const res = await getVideoPrivacies(server.url)
145 const privacies = res.body
146 expect(Object.keys(privacies)).to.have.length.at.least(3)
148 expect(privacies[3]).to.equal('Private')
151 it('Should not have videos', async function () {
152 const res = await getVideosList(server.url)
154 expect(res.body.total).to.equal(0)
155 expect(res.body.data).to.be.an('array')
156 expect(res.body.data.length).to.equal(0)
159 it('Should upload the video', async function () {
160 const videoAttributes = {
161 name: 'my super name',
165 tags: [ 'tag1', 'tag2', 'tag3' ]
167 const res = await uploadVideo(server.url, server.accessToken, videoAttributes)
168 expect(res.body.video).to.not.be.undefined
169 expect(res.body.video.id).to.equal(1)
170 expect(res.body.video.uuid).to.have.length.above(5)
172 videoId = res.body.video.id
173 videoUUID = res.body.video.uuid
176 it('Should get and seed the uploaded video', async function () {
179 const res = await getVideosList(server.url)
181 expect(res.body.total).to.equal(1)
182 expect(res.body.data).to.be.an('array')
183 expect(res.body.data.length).to.equal(1)
185 const video = res.body.data[0]
186 await completeVideoCheck(server.url, video, getCheckAttributes)
189 it('Should get the video by UUID', async function () {
192 const res = await getVideo(server.url, videoUUID)
194 const video = res.body
195 await completeVideoCheck(server.url, video, getCheckAttributes)
198 it('Should have the views updated', async function () {
201 await viewVideo(server.url, videoId)
202 await viewVideo(server.url, videoId)
203 await viewVideo(server.url, videoId)
207 await viewVideo(server.url, videoId)
208 await viewVideo(server.url, videoId)
212 await viewVideo(server.url, videoId)
213 await viewVideo(server.url, videoId)
215 const res = await getVideo(server.url, videoId)
217 const video = res.body
218 expect(video.views).to.equal(3)
221 it('Should remove the video', async function () {
222 await removeVideo(server.url, server.accessToken, videoId)
224 await checkVideoFilesWereRemoved(videoUUID, 1)
227 it('Should not have videos', async function () {
228 const res = await getVideosList(server.url)
230 expect(res.body.total).to.equal(0)
231 expect(res.body.data).to.be.an('array')
232 expect(res.body.data).to.have.lengthOf(0)
235 it('Should upload 6 videos', async function () {
239 'video_short.mp4', 'video_short.ogv', 'video_short.webm',
240 'video_short1.webm', 'video_short2.webm', 'video_short3.webm'
243 const tasks: Promise<any>[] = []
244 for (const video of videos) {
245 const videoAttributes = {
246 name: video + ' name',
247 description: video + ' description',
252 tags: [ 'tag1', 'tag2', 'tag3' ],
256 const p = uploadVideo(server.url, server.accessToken, videoAttributes)
260 await Promise.all(tasks)
263 it('Should have the correct durations', async function () {
264 const res = await getVideosList(server.url)
266 expect(res.body.total).to.equal(6)
267 const videos = res.body.data
268 expect(videos).to.be.an('array')
269 expect(videos).to.have.lengthOf(6)
271 const videosByName = keyBy<{ duration: number }>(videos, 'name')
272 expect(videosByName['video_short.mp4 name'].duration).to.equal(5)
273 expect(videosByName['video_short.ogv name'].duration).to.equal(5)
274 expect(videosByName['video_short.webm name'].duration).to.equal(5)
275 expect(videosByName['video_short1.webm name'].duration).to.equal(10)
276 expect(videosByName['video_short2.webm name'].duration).to.equal(5)
277 expect(videosByName['video_short3.webm name'].duration).to.equal(5)
280 it('Should have the correct thumbnails', async function () {
281 const res = await getVideosList(server.url)
283 const videos = res.body.data
285 videosListBase = videos
287 for (const video of videos) {
288 const videoName = video.name.replace(' name', '')
289 await testImage(server.url, videoName, video.thumbnailPath)
293 it('Should list only the two first videos', async function () {
294 const res = await getVideosListPagination(server.url, 0, 2, 'name')
296 const videos = res.body.data
297 expect(res.body.total).to.equal(6)
298 expect(videos.length).to.equal(2)
299 expect(videos[0].name).to.equal(videosListBase[0].name)
300 expect(videos[1].name).to.equal(videosListBase[1].name)
303 it('Should list only the next three videos', async function () {
304 const res = await getVideosListPagination(server.url, 2, 3, 'name')
306 const videos = res.body.data
307 expect(res.body.total).to.equal(6)
308 expect(videos.length).to.equal(3)
309 expect(videos[0].name).to.equal(videosListBase[2].name)
310 expect(videos[1].name).to.equal(videosListBase[3].name)
311 expect(videos[2].name).to.equal(videosListBase[4].name)
314 it('Should list the last video', async function () {
315 const res = await getVideosListPagination(server.url, 5, 6, 'name')
317 const videos = res.body.data
318 expect(res.body.total).to.equal(6)
319 expect(videos.length).to.equal(1)
320 expect(videos[0].name).to.equal(videosListBase[5].name)
323 it('Should list and sort by name in descending order', async function () {
324 const res = await getVideosListSort(server.url, '-name')
326 const videos = res.body.data
327 expect(res.body.total).to.equal(6)
328 expect(videos.length).to.equal(6)
329 expect(videos[0].name).to.equal('video_short.webm name')
330 expect(videos[1].name).to.equal('video_short.ogv name')
331 expect(videos[2].name).to.equal('video_short.mp4 name')
332 expect(videos[3].name).to.equal('video_short3.webm name')
333 expect(videos[4].name).to.equal('video_short2.webm name')
334 expect(videos[5].name).to.equal('video_short1.webm name')
336 videoId = videos[3].uuid
339 it('Should update a video', async function () {
341 name: 'my super video updated',
346 description: 'my super description updated',
347 commentsEnabled: false,
348 tags: [ 'tagup1', 'tagup2' ]
350 await updateVideo(server.url, server.accessToken, videoId, attributes)
353 it('Should filter by tags and category', async function () {
354 const res1 = await getVideosWithFilters(server.url, { tagsAllOf: [ 'tagup1', 'tagup2' ], categoryOneOf: 4 })
355 expect(res1.body.total).to.equal(1)
356 expect(res1.body.data[0].name).to.equal('my super video updated')
358 const res2 = await getVideosWithFilters(server.url, { tagsAllOf: [ 'tagup1', 'tagup2' ], categoryOneOf: 3 })
359 expect(res2.body.total).to.equal(0)
362 it('Should have the video updated', async function () {
365 const res = await getVideo(server.url, videoId)
366 const video = res.body
368 await completeVideoCheck(server.url, video, updateCheckAttributes)
371 it('Should update only the tags of a video', async function () {
373 tags: [ 'supertag', 'tag1', 'tag2' ]
375 await updateVideo(server.url, server.accessToken, videoId, attributes)
377 const res = await getVideo(server.url, videoId)
378 const video = res.body
380 await completeVideoCheck(server.url, video, Object.assign(updateCheckAttributes, attributes))
383 it('Should update only the description of a video', async function () {
385 description: 'hello everybody'
387 await updateVideo(server.url, server.accessToken, videoId, attributes)
389 const res = await getVideo(server.url, videoId)
390 const video = res.body
392 await completeVideoCheck(server.url, video, Object.assign(updateCheckAttributes, attributes))
395 it('Should like a video', async function () {
396 await rateVideo(server.url, server.accessToken, videoId, 'like')
398 const res = await getVideo(server.url, videoId)
399 const video = res.body
401 expect(video.likes).to.equal(1)
402 expect(video.dislikes).to.equal(0)
405 it('Should dislike the same video', async function () {
406 await rateVideo(server.url, server.accessToken, videoId, 'dislike')
408 const res = await getVideo(server.url, videoId)
409 const video = res.body
411 expect(video.likes).to.equal(0)
412 expect(video.dislikes).to.equal(1)
415 after(async function () {
416 killallServers([ server ])
418 // Keep the logs if the test failed