Refractor single server test

server/tests/api/videos/single-server.ts

@@ -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
+  webtorrentAdd,
-} from '../../utils/index'
+  viewVideo, completeVideoCheck, immutableAssign
-import { viewVideo } from '../../utils/videos/videos'
+} 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')
+    await completeVideoCheck(server.url, video, getCheckAttributes)
-    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)
   })
 
   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')
+    await completeVideoCheck(server.url, video, getCheckAttributes)
-
-    // Wait the async views increment
-    await wait(500)
   })
 
   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')
+    await completeVideoCheck(server.url, video, getCheckAttributes)
-    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)
   })
 
   // 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')
+    await completeVideoCheck(server.url, video, updateCheckAttributes)
-    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('')
   })
 
   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')
+    await completeVideoCheck(server.url, video, Object.assign(updateCheckAttributes, attributes))
-    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)
   })
 
   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')
+    await completeVideoCheck(server.url, video, Object.assign(updateCheckAttributes, attributes))
-    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)
   })
 
   it('Should like a video', async function () {

server/tests/utils/videos/videos.ts

@@ -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
 }