X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Ftests%2Fapi%2Fsingle-pod.js;h=fe388698f9b24407719a350eded938f06078dc09;hb=fce897f326af14406ced2f71a00ae89ff297a550;hp=66b762f82a7766f7bbc2eadbfc29a5e098eb8a10;hpb=7920c273a204e2469416a30b752b12ccd3160102;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/tests/api/single-pod.js b/server/tests/api/single-pod.js
index 66b762f82..fe388698f 100644
--- a/server/tests/api/single-pod.js
+++ b/server/tests/api/single-pod.js
@@ -1,3 +1,5 @@
+/* eslint-disable no-unused-expressions */
+
 'use strict'
 
 const chai = require('chai')
@@ -42,6 +44,45 @@ describe('Test a single pod', function () {
     ], done)
   })
 
+  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()
+    })
+  })
+
+  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()
+    })
+  })
+
+  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
@@ -55,12 +96,14 @@ describe('Test a single pod', function () {
   })
 
   it('Should upload the video', function (done) {
-    this.timeout(5000)
-    const name = 'my super name'
-    const description = 'my super description'
-    const tags = [ 'tag1', 'tag2', 'tag3' ]
-    const file = 'video_short.webm'
-    videosUtils.uploadVideo(server.url, server.accessToken, name, description, tags, file, done)
+    const videoAttributes = {
+      name: 'my super name',
+      category: 2,
+      nsfw: true,
+      licence: 6,
+      tags: [ 'tag1', 'tag2', 'tag3' ]
+    }
+    videosUtils.uploadVideo(server.url, server.accessToken, videoAttributes, done)
   })
 
   it('Should seed the uploaded video', function (done) {
@@ -76,6 +119,13 @@ describe('Test a single pod', function () {
 
       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.truthy
       expect(video.description).to.equal('my super description')
       expect(video.podHost).to.equal('localhost:9001')
       expect(video.magnetUri).to.exist
@@ -83,6 +133,7 @@ describe('Test a single pod', function () {
       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
 
       videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
         if (err) throw err
@@ -110,6 +161,13 @@ describe('Test a single pod', function () {
 
       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.truthy
       expect(video.description).to.equal('my super description')
       expect(video.podHost).to.equal('localhost:9001')
       expect(video.magnetUri).to.exist
@@ -117,6 +175,7 @@ describe('Test a single pod', function () {
       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
 
       videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
         if (err) throw err
@@ -127,6 +186,17 @@ describe('Test a single pod', function () {
     })
   })
 
+  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
@@ -137,12 +207,20 @@ describe('Test a single pod', function () {
 
       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.truthy
       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
 
       videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
         if (err) throw err
@@ -170,6 +248,7 @@ describe('Test a single pod', function () {
   //     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
 
   //     videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
   //       if (err) throw err
@@ -190,12 +269,20 @@ describe('Test a single pod', function () {
 
       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.truthy
       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
 
       videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
         if (err) throw err
@@ -246,12 +333,12 @@ describe('Test a single pod', function () {
     videosUtils.removeVideo(server.url, server.accessToken, videoId, function (err) {
       if (err) throw err
 
-      fs.readdir(pathUtils.join(__dirname, '../../../test1/videos/'), function (err, files) {
+      fs.readdir(pathUtils.join(__dirname, '..', '..', '..', 'test1/videos/'), function (err, files) {
         if (err) throw err
 
         expect(files.length).to.equal(0)
 
-        fs.readdir(pathUtils.join(__dirname, '../../../test1/thumbnails/'), function (err, files) {
+        fs.readdir(pathUtils.join(__dirname, '..', '..', '..', 'test1/thumbnails/'), function (err, files) {
           if (err) throw err
 
           expect(files.length).to.equal(0)
@@ -281,11 +368,18 @@ describe('Test a single pod', function () {
       'video_short1.webm', 'video_short2.webm', 'video_short3.webm'
     ]
     each(videos, function (video, callbackEach) {
-      const name = video + ' name'
-      const description = video + ' description'
-      const tags = [ 'tag1', 'tag2', 'tag3' ]
+      const videoAttributes = {
+        name: video + ' name',
+        description: video + ' description',
+        category: 2,
+        licence: 1,
+        language: 1,
+        nsfw: true,
+        tags: [ 'tag1', 'tag2', 'tag3' ],
+        fixture: video
+      }
 
-      videosUtils.uploadVideo(server.url, server.accessToken, name, description, tags, video, callbackEach)
+      videosUtils.uploadVideo(server.url, server.accessToken, videoAttributes, callbackEach)
     }, done)
   })
 
@@ -333,69 +427,69 @@ describe('Test a single pod', function () {
   })
 
   it('Should list only the two first videos', function (done) {
-    videosUtils.getVideosListPagination(server.url, 0, 2, function (err, res) {
+    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)
-      expect(videos[0].name === videosListBase[0].name)
-      expect(videos[1].name === videosListBase[1].name)
+      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) {
-    videosUtils.getVideosListPagination(server.url, 2, 3, function (err, res) {
+    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)
-      expect(videos[0].name === videosListBase[2].name)
-      expect(videos[1].name === videosListBase[3].name)
-      expect(videos[2].name === videosListBase[4].name)
+      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) {
-    videosUtils.getVideosListPagination(server.url, 5, 6, function (err, res) {
+    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)
-      expect(videos[0].name === videosListBase[5].name)
+      expect(videos[0].name).to.equal(videosListBase[5].name)
 
       done()
     })
   })
 
   it('Should search the first video', function (done) {
-    videosUtils.searchVideoWithPagination(server.url, 'webm', 'name', 0, 1, function (err, res) {
+    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)
-      expect(videos[0].name === 'video_short.webm name')
+      expect(videos[0].name).to.equal('video_short1.webm name')
 
       done()
     })
   })
 
   it('Should search the last two videos', function (done) {
-    videosUtils.searchVideoWithPagination(server.url, 'webm', 'name', 2, 2, function (err, res) {
+    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)
-      expect(videos[0].name === 'video_short2.webm name')
-      expect(videos[1].name === 'video_short3.webm name')
+      expect(videos[0].name).to.equal('video_short3.webm name')
+      expect(videos[1].name).to.equal('video_short.webm name')
 
       done()
     })
@@ -450,7 +544,7 @@ describe('Test a single pod', function () {
   //   })
   // })
 
-  it('Should search the good magnetUri video', function (done) {
+  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
@@ -471,12 +565,12 @@ describe('Test a single pod', function () {
       const videos = res.body.data
       expect(res.body.total).to.equal(6)
       expect(videos.length).to.equal(6)
-      expect(videos[5].name === 'video_short.mp4 name')
-      expect(videos[4].name === 'video_short.ogv name')
-      expect(videos[3].name === 'video_short.webm name')
-      expect(videos[2].name === 'video_short1.webm name')
-      expect(videos[1].name === 'video_short2.webm name')
-      expect(videos[0].name === 'video_short3.webm name')
+      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')
 
       done()
     })
@@ -490,15 +584,171 @@ describe('Test a single pod', function () {
       expect(res.body.total).to.equal(4)
       expect(videos.length).to.equal(4)
 
-      expect(videos[0].name === 'video_short.webm name')
-      expect(videos[1].name === 'video_short1.webm name')
-      expect(videos[2].name === 'video_short2.webm name')
-      expect(videos[3].name === 'video_short3.webm name')
+      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')
+
+      videoId = videos[2].id
 
       done()
     })
   })
 
+  it('Should update a video', function (done) {
+    const attributes = {
+      name: 'my super video updated',
+      category: 4,
+      licence: 2,
+      language: 5,
+      nsfw: false,
+      description: 'my super description updated',
+      tags: [ 'tagup1', 'tagup2' ]
+    }
+    videosUtils.updateVideo(server.url, server.accessToken, videoId, attributes, done)
+  })
+
+  it('Should have the video updated', function (done) {
+    this.timeout(60000)
+
+    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')
+      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.truthy
+      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
+
+      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()
+        })
+      })
+    })
+  })
+
+  it('Should update only the tags of a video', function (done) {
+    const attributes = {
+      tags: [ 'tag1', 'tag2', 'supertag' ]
+    }
+
+    videosUtils.updateVideo(server.url, server.accessToken, videoId, attributes, function (err) {
+      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')
+        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.truthy
+        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
+
+        done()
+      })
+    })
+  })
+
+  it('Should update only the description of a video', function (done) {
+    const attributes = {
+      description: 'hello everybody'
+    }
+
+    videosUtils.updateVideo(server.url, server.accessToken, videoId, attributes, function (err) {
+      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')
+        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.truthy
+        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
+
+        done()
+      })
+    })
+  })
+
+  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)