Merge branch 'feature/design' into develop

6 files changed, 157 insertions, 129 deletions

diff --git a/server/tests/api/check-params/videos.ts b/server/tests/api/check-params/videos.ts
index 2962f5640..0aaa6e7c9 100644
--- a/server/tests/api/check-params/videos.ts
+++ b/server/tests/api/check-params/videos.ts
@@ -189,14 +189,6 @@ describe('Test videos API validator', function () {
       await makePostUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
     })
 
-    it('Should fail without a category', async function () {
-      const fields = getCompleteVideoUploadAttributes()
-      delete fields.category
-
-      const attaches = getVideoUploadAttaches
-      await makePostUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
-    })
-
     it('Should fail with a bad category', async function () {
       const fields = getCompleteVideoUploadAttributes()
       fields.category = 125
@@ -205,14 +197,6 @@ describe('Test videos API validator', function () {
       await makePostUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
     })
 
-    it('Should fail without a licence', async function () {
-      const fields = getCompleteVideoUploadAttributes()
-      delete fields.licence
-
-      const attaches = getVideoUploadAttaches()
-      await makePostUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
-    })
-
     it('Should fail with a bad licence', async function () {
       const fields = getCompleteVideoUploadAttributes()
       fields.licence = 125
@@ -245,14 +229,6 @@ describe('Test videos API validator', function () {
       await makePostUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
     })
 
-    it('Should fail without description', async function () {
-      const fields = getCompleteVideoUploadAttributes()
-      delete fields.description
-
-      const attaches = getVideoUploadAttaches()
-      await makePostUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
-    })
-
     it('Should fail with a long description', async function () {
       const fields = getCompleteVideoUploadAttributes()
       fields.description = 'my super description which is very very very very very very very very very very very very long'.repeat(35)
@@ -345,7 +321,7 @@ describe('Test videos API validator', function () {
         token: server.accessToken,
         fields,
         attaches,
-        statusCodeExpected: 204
+        statusCodeExpected: 200
       })
 
       attaches.videofile = join(__dirname, '..', 'fixtures', 'video_short.mp4')
@@ -355,7 +331,7 @@ describe('Test videos API validator', function () {
         token: server.accessToken,
         fields,
         attaches,
-        statusCodeExpected: 204
+        statusCodeExpected: 200
       })
 
       attaches.videofile = join(__dirname, '..', 'fixtures', 'video_short.ogv')
@@ -365,7 +341,7 @@ describe('Test videos API validator', function () {
         token: server.accessToken,
         fields,
         attaches,
-        statusCodeExpected: 204
+        statusCodeExpected: 200
       })
     })
   })
diff --git a/server/tests/api/follows.ts b/server/tests/api/follows.ts
index aadae3cce..dcb4c8bd9 100644
--- a/server/tests/api/follows.ts
+++ b/server/tests/api/follows.ts
@@ -227,7 +227,7 @@ describe('Test follows', function () {
     expect(videoDetails.nsfw).to.be.ok
     expect(videoDetails.description).to.equal('my super description')
     expect(videoDetails.serverHost).to.equal('localhost:9003')
-    expect(videoDetails.account).to.equal('root')
+    expect(videoDetails.accountName).to.equal('root')
     expect(videoDetails.likes).to.equal(1)
     expect(videoDetails.dislikes).to.equal(1)
     expect(videoDetails.isLocal).to.be.false
diff --git a/server/tests/api/multiple-servers.ts b/server/tests/api/multiple-servers.ts
index c80ded862..2f17f017a 100644
--- a/server/tests/api/multiple-servers.ts
+++ b/server/tests/api/multiple-servers.ts
@@ -2,6 +2,8 @@
 
 import 'mocha'
 import * as chai from 'chai'
+import { join } from 'path'
+import * as request from 'supertest'
 
 import {
   dateIsValid,
@@ -111,13 +113,14 @@ describe('Test multiple servers', function () {
         expect(video.tags).to.deep.equal([ 'tag1p1', 'tag2p1' ])
         expect(dateIsValid(video.createdAt)).to.be.true
         expect(dateIsValid(video.updatedAt)).to.be.true
-        expect(video.account).to.equal('root')
+        expect(video.accountName).to.equal('root')
 
         const res2 = await getVideo(server.url, video.uuid)
         const videoDetails = res2.body
 
         expect(videoDetails.channel.name).to.equal('my channel')
         expect(videoDetails.channel.description).to.equal('super channel')
+        expect(videoDetails.account.name).to.equal('root')
         expect(dateIsValid(videoDetails.channel.createdAt)).to.be.true
         expect(dateIsValid(videoDetails.channel.updatedAt)).to.be.true
         expect(videoDetails.files).to.have.lengthOf(1)
@@ -201,7 +204,7 @@ describe('Test multiple servers', function () {
         expect(video.tags).to.deep.equal([ 'tag1p2', 'tag2p2', 'tag3p2' ])
         expect(dateIsValid(video.createdAt)).to.be.true
         expect(dateIsValid(video.updatedAt)).to.be.true
-        expect(video.account).to.equal('user1')
+        expect(video.accountName).to.equal('user1')
 
         if (server.url !== 'http://localhost:9002') {
           expect(video.isLocal).to.be.false
@@ -316,7 +319,7 @@ describe('Test multiple servers', function () {
         expect(video1.serverHost).to.equal('localhost:9003')
         expect(video1.duration).to.equal(5)
         expect(video1.tags).to.deep.equal([ 'tag1p3' ])
-        expect(video1.account).to.equal('root')
+        expect(video1.accountName).to.equal('root')
         expect(dateIsValid(video1.createdAt)).to.be.true
         expect(dateIsValid(video1.updatedAt)).to.be.true
 
@@ -342,7 +345,7 @@ describe('Test multiple servers', function () {
         expect(video2.serverHost).to.equal('localhost:9003')
         expect(video2.duration).to.equal(5)
         expect(video2.tags).to.deep.equal([ 'tag2p3', 'tag3p3', 'tag4p3' ])
-        expect(video2.account).to.equal('root')
+        expect(video2.accountName).to.equal('root')
         expect(dateIsValid(video2.createdAt)).to.be.true
         expect(dateIsValid(video2.updatedAt)).to.be.true
 
@@ -690,7 +693,7 @@ describe('Test multiple servers', function () {
         expect(baseVideo.licence).to.equal(video.licence)
         expect(baseVideo.category).to.equal(video.category)
         expect(baseVideo.nsfw).to.equal(video.nsfw)
-        expect(baseVideo.account).to.equal(video.account)
+        expect(baseVideo.accountName).to.equal(video.accountName)
         expect(baseVideo.tags).to.deep.equal(video.tags)
       }
     })
@@ -706,6 +709,50 @@ describe('Test multiple servers', function () {
     })
   })
 
+  describe('With minimum parameters', function () {
+    it('Should upload and propagate the video', async function () {
+      this.timeout(50000)
+
+      const path = '/api/v1/videos/upload'
+
+      const req = request(servers[1].url)
+        .post(path)
+        .set('Accept', 'application/json')
+        .set('Authorization', 'Bearer ' + servers[1].accessToken)
+        .field('name', 'minimum parameters')
+        .field('privacy', '1')
+        .field('nsfw', 'false')
+        .field('channelId', '1')
+
+      const filePath = join(__dirname, '..', 'api', 'fixtures', 'video_short.webm')
+
+      await req.attach('videofile', filePath)
+        .expect(200)
+
+      await wait(25000)
+
+      for (const server of servers) {
+        const res = await getVideosList(server.url)
+        const video = res.body.data.find(v => v.name === 'minimum parameters')
+
+        expect(video.name).to.equal('minimum parameters')
+        expect(video.category).to.equal(null)
+        expect(video.categoryLabel).to.equal('Misc')
+        expect(video.licence).to.equal(null)
+        expect(video.licenceLabel).to.equal('Unknown')
+        expect(video.language).to.equal(null)
+        expect(video.languageLabel).to.equal('Unknown')
+        expect(video.nsfw).to.not.be.ok
+        expect(video.description).to.equal(null)
+        expect(video.serverHost).to.equal('localhost:9002')
+        expect(video.accountName).to.equal('root')
+        expect(video.tags).to.deep.equal([ ])
+        expect(dateIsValid(video.createdAt)).to.be.true
+        expect(dateIsValid(video.updatedAt)).to.be.true
+      }
+    })
+  })
+
   after(async function () {
     killallServers(servers)
 
diff --git a/server/tests/api/services.ts b/server/tests/api/services.ts
index 8d96ccc5e..4d480c305 100644
--- a/server/tests/api/services.ts
+++ b/server/tests/api/services.ts
@@ -46,7 +46,7 @@ describe('Test services', function () {
 
     expect(res.body.html).to.equal(expectedHtml)
     expect(res.body.title).to.equal(server.video.name)
-    expect(res.body.author_name).to.equal(server.video.account)
+    expect(res.body.author_name).to.equal(server.video.accountName)
     expect(res.body.width).to.equal(560)
     expect(res.body.height).to.equal(315)
     expect(res.body.thumbnail_url).to.equal(expectedThumbnailUrl)
@@ -66,7 +66,7 @@ describe('Test services', function () {
 
     expect(res.body.html).to.equal(expectedHtml)
     expect(res.body.title).to.equal(server.video.name)
-    expect(res.body.author_name).to.equal(server.video.account)
+    expect(res.body.author_name).to.equal(server.video.accountName)
     expect(res.body.height).to.equal(50)
     expect(res.body.width).to.equal(50)
     expect(res.body).to.not.have.property('thumbnail_url')
diff --git a/server/tests/api/single-server.ts b/server/tests/api/single-server.ts
index 041d13225..174fb480d 100644
--- a/server/tests/api/single-server.ts
+++ b/server/tests/api/single-server.ts
@@ -1,40 +1,40 @@
 /* tslint:disable:no-unused-expression */
 
+import * as chai from 'chai'
 import { keyBy } from 'lodash'
-import { join } from 'path'
 import 'mocha'
-import * as chai from 'chai'
-const expect = chai.expect
-
+import { join } from 'path'
 import {
-  ServerInfo,
-  flushTests,
-  runServer,
-  uploadVideo,
-  getVideosList,
-  rateVideo,
-  removeVideo,
-  wait,
-  setAccessTokensToServers,
-  searchVideo,
-  killallServers,
   dateIsValid,
+  flushTests,
+  getVideo,
   getVideoCategories,
-  getVideoLicences,
   getVideoLanguages,
+  getVideoLicences,
   getVideoPrivacies,
-  testVideoImage,
-  webtorrentAdd,
-  getVideo,
-  readdirPromise,
+  getVideosList,
   getVideosListPagination,
-  searchVideoWithPagination,
   getVideosListSort,
+  killallServers,
+  rateVideo,
+  readdirPromise,
+  removeVideo,
+  runServer,
+  searchVideo,
+  searchVideoWithPagination,
   searchVideoWithSort,
-  updateVideo
+  ServerInfo,
+  setAccessTokensToServers,
+  testVideoImage,
+  updateVideo,
+  uploadVideo,
+  wait,
+  webtorrentAdd
 } from '../utils'
 import { viewVideo } from '../utils/videos'
 
+const expect = chai.expect
+
 describe('Test a single server', function () {
   let server: ServerInfo = null
   let videoId = -1
@@ -103,7 +103,10 @@ describe('Test a single server', function () {
       licence: 6,
       tags: [ 'tag1', 'tag2', 'tag3' ]
     }
-    await uploadVideo(server.url, server.accessToken, videoAttributes)
+    const res = await uploadVideo(server.url, server.accessToken, videoAttributes)
+    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)
   })
 
   it('Should seed the uploaded video', async function () {
@@ -127,7 +130,7 @@ describe('Test a single server', function () {
     expect(video.nsfw).to.be.ok
     expect(video.description).to.equal('my super description')
     expect(video.serverHost).to.equal('localhost:9001')
-    expect(video.account).to.equal('root')
+    expect(video.accountName).to.equal('root')
     expect(video.isLocal).to.be.true
     expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
     expect(dateIsValid(video.createdAt)).to.be.true
@@ -176,7 +179,7 @@ describe('Test a single server', function () {
     expect(video.nsfw).to.be.ok
     expect(video.description).to.equal('my super description')
     expect(video.serverHost).to.equal('localhost:9001')
-    expect(video.account).to.equal('root')
+    expect(video.accountName).to.equal('root')
     expect(video.isLocal).to.be.true
     expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
     expect(dateIsValid(video.createdAt)).to.be.true
@@ -225,7 +228,7 @@ describe('Test a single server', function () {
     expect(video.views).to.equal(3)
   })
 
-  it('Should search the video by name by default', async function () {
+  it('Should search the video by name', async function () {
     const res = await searchVideo(server.url, 'my')
 
     expect(res.body.total).to.equal(1)
@@ -243,7 +246,7 @@ describe('Test a single server', function () {
     expect(video.nsfw).to.be.ok
     expect(video.description).to.equal('my super description')
     expect(video.serverHost).to.equal('localhost:9001')
-    expect(video.account).to.equal('root')
+    expect(video.accountName).to.equal('root')
     expect(video.isLocal).to.be.true
     expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
     expect(dateIsValid(video.createdAt)).to.be.true
@@ -279,35 +282,36 @@ describe('Test a single server', function () {
   //   })
   // })
 
-  it('Should search the video by tag', async function () {
-    const res = await searchVideo(server.url, 'tag1', 'tags')
-
-    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.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.account).to.equal('root')
-    expect(video.isLocal).to.be.true
-    expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
-    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
+  // it('Should search the video by tag', async function () {
+  //   const res = await searchVideo(server.url, 'tag1')
+  //
+  //   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.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(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
+  //   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)
+  // })
 
-  it('Should not find a search by name by default', async function () {
+  it('Should not find a search by name', async function () {
     const res = await searchVideo(server.url, 'hello')
 
     expect(res.body.total).to.equal(0)
@@ -315,21 +319,23 @@ describe('Test a single server', function () {
     expect(res.body.data.length).to.equal(0)
   })
 
-  it('Should not find a search by author', async function () {
-    const res = await searchVideo(server.url, 'hello', 'account')
-
-    expect(res.body.total).to.equal(0)
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data.length).to.equal(0)
-  })
-
-  it('Should not find a search by tag', async function () {
-    const res = await searchVideo(server.url, 'hello', 'tags')
-
-    expect(res.body.total).to.equal(0)
-    expect(res.body.data).to.be.an('array')
-    expect(res.body.data.length).to.equal(0)
-  })
+  // Not implemented yet
+  // it('Should not find a search by author', async function () {
+  //   const res = await searchVideo(server.url, 'hello')
+  //
+  //   expect(res.body.total).to.equal(0)
+  //   expect(res.body.data).to.be.an('array')
+  //   expect(res.body.data.length).to.equal(0)
+  // })
+  //
+  // Not implemented yet
+  // it('Should not find a search by tag', async function () {
+  //   const res = await searchVideo(server.url, 'hello')
+  //
+  //   expect(res.body.total).to.equal(0)
+  //   expect(res.body.data).to.be.an('array')
+  //   expect(res.body.data.length).to.equal(0)
+  // })
 
   it('Should remove the video', async function () {
     await removeVideo(server.url, server.accessToken, videoId)
@@ -357,7 +363,7 @@ describe('Test a single server', function () {
       'video_short1.webm', 'video_short2.webm', 'video_short3.webm'
     ]
 
-    // const tasks: Promise<any>[] = []
+    const tasks: Promise<any>[] = []
     for (const video of videos) {
       const videoAttributes = {
         name: video + ' name',
@@ -371,13 +377,10 @@ describe('Test a single server', function () {
       }
 
       const p = uploadVideo(server.url, server.accessToken, videoAttributes)
-      await p
+      tasks.push(p)
     }
-    // FIXME: concurrent uploads does not work :(
-    //   tasks.push(p)
-    // }
-    //
-    // await Promise.all(tasks)
+
+    await Promise.all(tasks)
   })
 
   it('Should have the correct durations', async function () {
@@ -443,7 +446,7 @@ describe('Test a single server', function () {
   })
 
   it('Should search the first video', async function () {
-    const res = await searchVideoWithPagination(server.url, 'webm', 'name', 0, 1, 'name')
+    const res = await searchVideoWithPagination(server.url, 'webm', 0, 1, 'name')
 
     const videos = res.body.data
     expect(res.body.total).to.equal(4)
@@ -452,7 +455,7 @@ describe('Test a single server', function () {
   })
 
   it('Should search the last two videos', async function () {
-    const res = await searchVideoWithPagination(server.url, 'webm', 'name', 2, 2, 'name')
+    const res = await searchVideoWithPagination(server.url, 'webm', 2, 2, 'name')
 
     const videos = res.body.data
     expect(res.body.total).to.equal(4)
@@ -462,20 +465,21 @@ describe('Test a single server', function () {
   })
 
   it('Should search all the webm videos', async function () {
-    const res = await searchVideoWithPagination(server.url, 'webm', 'name', 0, 15)
+    const res = await searchVideoWithPagination(server.url, 'webm', 0, 15)
 
     const videos = res.body.data
     expect(res.body.total).to.equal(4)
     expect(videos.length).to.equal(4)
   })
 
-  it('Should search all the root author videos', async function () {
-    const res = await searchVideoWithPagination(server.url, 'root', 'account', 0, 15)
-
-    const videos = res.body.data
-    expect(res.body.total).to.equal(6)
-    expect(videos.length).to.equal(6)
-  })
+  // Not implemented yet
+  // it('Should search all the root author videos', async function () {
+  //   const res = await searchVideoWithPagination(server.url, 'root', 0, 15)
+  //
+  //   const videos = res.body.data
+  //   expect(res.body.total).to.equal(6)
+  //   expect(videos.length).to.equal(6)
+  // })
 
   // Not implemented yet
   // it('Should search all the 9001 port videos', async function () {
@@ -559,7 +563,8 @@ describe('Test a single server', function () {
     expect(video.nsfw).to.be.ok
     expect(video.description).to.equal('my super description updated')
     expect(video.serverHost).to.equal('localhost:9001')
-    expect(video.account).to.equal('root')
+    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
@@ -608,7 +613,7 @@ describe('Test a single server', function () {
     expect(video.nsfw).to.be.ok
     expect(video.description).to.equal('my super description updated')
     expect(video.serverHost).to.equal('localhost:9001')
-    expect(video.account).to.equal('root')
+    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
@@ -648,7 +653,7 @@ describe('Test a single server', function () {
     expect(video.nsfw).to.be.ok
     expect(video.description).to.equal('hello everybody')
     expect(video.serverHost).to.equal('localhost:9001')
-    expect(video.account).to.equal('root')
+    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
diff --git a/server/tests/api/users.ts b/server/tests/api/users.ts
index 33646e84f..b3163b1e1 100644
--- a/server/tests/api/users.ts
+++ b/server/tests/api/users.ts
@@ -113,11 +113,11 @@ describe('Test users', function () {
 
   it('Should upload the video with the correct token', async function () {
     const videoAttributes = {}
-    await uploadVideo(server.url, accessToken, videoAttributes, 204)
+    await uploadVideo(server.url, accessToken, videoAttributes)
     const res = await getVideosList(server.url)
     const video = res.body.data[ 0 ]
 
-    expect(video.account)
+    expect(video.accountName)
       .to
       .equal('root')
     videoId = video.id
@@ -125,7 +125,7 @@ describe('Test users', function () {
 
   it('Should upload the video again with the correct token', async function () {
     const videoAttributes = {}
-    await uploadVideo(server.url, accessToken, videoAttributes, 204)
+    await uploadVideo(server.url, accessToken, videoAttributes)
   })
 
   it('Should retrieve a video rating', async function () {
@@ -487,7 +487,7 @@ describe('Test users', function () {
       .equal(1)
 
     const video = res.body.data[ 0 ]
-    expect(video.account)
+    expect(video.accountName)
       .to
       .equal('root')
   })