7 files changed, 456 insertions, 97 deletions

diff --git a/server/tests/api/check-params/config.ts b/server/tests/api/check-params/config.ts
index 6aa31e38d..03855237f 100644
--- a/server/tests/api/check-params/config.ts
+++ b/server/tests/api/check-params/config.ts
@@ -35,6 +35,9 @@ describe('Test config API validators', function () {
     cache: {
       previews: {
         size: 2
+      },
+      captions: {
+        size: 3
       }
     },
     signup: {
diff --git a/server/tests/api/check-params/index.ts b/server/tests/api/check-params/index.ts
index 4c3b372f5..c0e0302df 100644
--- a/server/tests/api/check-params/index.ts
+++ b/server/tests/api/check-params/index.ts
@@ -6,6 +6,7 @@ import './services'
 import './users'
 import './video-abuses'
 import './video-blacklist'
+import './video-captions'
 import './video-channels'
 import './video-comments'
 import './videos'
diff --git a/server/tests/api/check-params/video-captions.ts b/server/tests/api/check-params/video-captions.ts
new file mode 100644
index 000000000..12f890db8
--- /dev/null
+++ b/server/tests/api/check-params/video-captions.ts
@@ -0,0 +1,223 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+  createUser,
+  flushTests,
+  killallServers,
+  makeDeleteRequest,
+  makeGetRequest,
+  makeUploadRequest,
+  runServer,
+  ServerInfo,
+  setAccessTokensToServers,
+  uploadVideo,
+  userLogin
+} from '../../utils'
+import { join } from 'path'
+
+describe('Test video captions API validator', function () {
+  const path = '/api/v1/videos/'
+
+  let server: ServerInfo
+  let userAccessToken: string
+  let videoUUID: string
+
+  // ---------------------------------------------------------------
+
+  before(async function () {
+    this.timeout(30000)
+
+    await flushTests()
+
+    server = await runServer(1)
+
+    await setAccessTokensToServers([ server ])
+
+    {
+      const res = await uploadVideo(server.url, server.accessToken, {})
+      videoUUID = res.body.video.uuid
+    }
+
+    {
+      const user = {
+        username: 'user1',
+        password: 'my super password'
+      }
+      await createUser(server.url, server.accessToken, user.username, user.password)
+      userAccessToken = await userLogin(server, user)
+    }
+  })
+
+  describe('When adding video caption', function () {
+    const fields = { }
+    const attaches = {
+      'captionfile': join(__dirname, '..', '..', 'fixtures', 'subtitle-good1.vtt')
+    }
+
+    it('Should fail without a valid uuid', async function () {
+      await makeUploadRequest({
+        method: 'PUT',
+        url: server.url,
+        path: path + '4da6fde3-88f7-4d16-b119-108df563d0b06/captions',
+        token: server.accessToken,
+        fields,
+        attaches
+      })
+    })
+
+    it('Should fail with an unknown id', async function () {
+      await makeUploadRequest({
+        method: 'PUT',
+        url: server.url,
+        path: path + '4da6fde3-88f7-4d16-b119-108df5630b06/captions',
+        token: server.accessToken,
+        fields,
+        attaches
+      })
+    })
+
+    it('Should fail with a missing language in path', async function () {
+      const captionPath = path + videoUUID + '/captions'
+      await makeUploadRequest({
+        method: 'PUT',
+        url: server.url,
+        path: captionPath,
+        token: server.accessToken,
+        fields,
+        attaches
+      })
+    })
+
+    it('Should fail with an unknown language', async function () {
+      const captionPath = path + videoUUID + '/captions/15'
+      await makeUploadRequest({
+        method: 'PUT',
+        url: server.url,
+        path: captionPath,
+        token: server.accessToken,
+        fields,
+        attaches
+      })
+    })
+
+    it('Should fail without access token', async function () {
+      const captionPath = path + videoUUID + '/captions/fr'
+      await makeUploadRequest({
+        method: 'PUT',
+        url: server.url,
+        path: captionPath,
+        fields,
+        attaches,
+        statusCodeExpected: 401
+      })
+    })
+
+    it('Should fail with a bad access token', async function () {
+      const captionPath = path + videoUUID + '/captions/fr'
+      await makeUploadRequest({
+        method: 'PUT',
+        url: server.url,
+        path: captionPath,
+        token: 'blabla',
+        fields,
+        attaches,
+        statusCodeExpected: 401
+      })
+    })
+
+    it('Should success with the correct parameters', async function () {
+      const captionPath = path + videoUUID + '/captions/fr'
+      await makeUploadRequest({
+        method: 'PUT',
+        url: server.url,
+        path: captionPath,
+        token: server.accessToken,
+        fields,
+        attaches,
+        statusCodeExpected: 204
+      })
+    })
+  })
+
+  describe('When listing video captions', function () {
+    it('Should fail without a valid uuid', async function () {
+      await makeGetRequest({ url: server.url, path: path + '4da6fde3-88f7-4d16-b119-108df563d0b06/captions' })
+    })
+
+    it('Should fail with an unknown id', async function () {
+      await makeGetRequest({ url: server.url, path: path + '4da6fde3-88f7-4d16-b119-108df5630b06/captions', statusCodeExpected: 404 })
+    })
+
+    it('Should success with the correct parameters', async function () {
+      await makeGetRequest({ url: server.url, path: path + videoUUID + '/captions', statusCodeExpected: 200 })
+    })
+  })
+
+  describe('When deleting video caption', function () {
+    it('Should fail without a valid uuid', async function () {
+      await makeDeleteRequest({
+        url: server.url,
+        path: path + '4da6fde3-88f7-4d16-b119-108df563d0b06/captions/fr',
+        token: server.accessToken
+      })
+    })
+
+    it('Should fail with an unknown id', async function () {
+      await makeDeleteRequest({
+        url: server.url,
+        path: path + '4da6fde3-88f7-4d16-b119-108df5630b06/captions/fr',
+        token: server.accessToken,
+        statusCodeExpected: 404
+      })
+    })
+
+    it('Should fail with an invalid language', async function () {
+      await makeDeleteRequest({
+        url: server.url,
+        path: path + '4da6fde3-88f7-4d16-b119-108df5630b06/captions/16',
+        token: server.accessToken
+      })
+    })
+
+    it('Should fail with a missing language', async function () {
+      const captionPath = path + videoUUID + '/captions'
+      await makeDeleteRequest({ url: server.url, path: captionPath, token: server.accessToken })
+    })
+
+    it('Should fail with an unknown language', async function () {
+      const captionPath = path + videoUUID + '/captions/15'
+      await makeDeleteRequest({ url: server.url, path: captionPath, token: server.accessToken })
+    })
+
+    it('Should fail without access token', async function () {
+      const captionPath = path + videoUUID + '/captions/fr'
+      await makeDeleteRequest({ url: server.url, path: captionPath, statusCodeExpected: 401 })
+    })
+
+    it('Should fail with a bad access token', async function () {
+      const captionPath = path + videoUUID + '/captions/fr'
+      await makeDeleteRequest({ url: server.url, path: captionPath, token: 'coucou', statusCodeExpected: 401 })
+    })
+
+    it('Should fail with another user', async function () {
+      const captionPath = path + videoUUID + '/captions/fr'
+      await makeDeleteRequest({ url: server.url, path: captionPath, token: userAccessToken, statusCodeExpected: 403 })
+    })
+
+    it('Should success with the correct parameters', async function () {
+      const captionPath = path + videoUUID + '/captions/fr'
+      await makeDeleteRequest({ url: server.url, path: captionPath, token: server.accessToken, statusCodeExpected: 204 })
+    })
+  })
+
+  after(async function () {
+    killallServers([ server ])
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/index-fast.ts b/server/tests/api/index-fast.ts
index 2454ec2f9..d530dfc06 100644
--- a/server/tests/api/index-fast.ts
+++ b/server/tests/api/index-fast.ts
@@ -4,6 +4,7 @@ import './check-params'
 import './users/users'
 import './videos/single-server'
 import './videos/video-abuse'
+import './videos/video-captions'
 import './videos/video-blacklist'
 import './videos/video-blacklist-management'
 import './videos/video-description'
diff --git a/server/tests/api/server/config.ts b/server/tests/api/server/config.ts
index 4de0d6b10..79b5aaf2d 100644
--- a/server/tests/api/server/config.ts
+++ b/server/tests/api/server/config.ts
@@ -14,6 +14,61 @@ import {
   registerUser, getCustomConfig, setAccessTokensToServers, updateCustomConfig
 } from '../../utils/index'
 
+function checkInitialConfig (data: CustomConfig) {
+  expect(data.instance.name).to.equal('PeerTube')
+  expect(data.instance.shortDescription).to.equal(
+    'PeerTube, a federated (ActivityPub) video streaming platform using P2P (BitTorrent) directly in the web browser ' +
+    'with WebTorrent and Angular.'
+  )
+  expect(data.instance.description).to.equal('Welcome to this PeerTube instance!')
+  expect(data.instance.terms).to.equal('No terms for now.')
+  expect(data.instance.defaultClientRoute).to.equal('/videos/trending')
+  expect(data.instance.defaultNSFWPolicy).to.equal('display')
+  expect(data.instance.customizations.css).to.be.empty
+  expect(data.instance.customizations.javascript).to.be.empty
+  expect(data.services.twitter.username).to.equal('@Chocobozzz')
+  expect(data.services.twitter.whitelisted).to.be.false
+  expect(data.cache.previews.size).to.equal(1)
+  expect(data.cache.captions.size).to.equal(1)
+  expect(data.signup.enabled).to.be.true
+  expect(data.signup.limit).to.equal(4)
+  expect(data.admin.email).to.equal('admin1@example.com')
+  expect(data.user.videoQuota).to.equal(5242880)
+  expect(data.transcoding.enabled).to.be.false
+  expect(data.transcoding.threads).to.equal(2)
+  expect(data.transcoding.resolutions['240p']).to.be.true
+  expect(data.transcoding.resolutions['360p']).to.be.true
+  expect(data.transcoding.resolutions['480p']).to.be.true
+  expect(data.transcoding.resolutions['720p']).to.be.true
+  expect(data.transcoding.resolutions['1080p']).to.be.true
+}
+
+function checkUpdatedConfig (data: CustomConfig) {
+  expect(data.instance.name).to.equal('PeerTube updated')
+  expect(data.instance.shortDescription).to.equal('my short description')
+  expect(data.instance.description).to.equal('my super description')
+  expect(data.instance.terms).to.equal('my super terms')
+  expect(data.instance.defaultClientRoute).to.equal('/videos/recently-added')
+  expect(data.instance.defaultNSFWPolicy).to.equal('blur')
+  expect(data.instance.customizations.javascript).to.equal('alert("coucou")')
+  expect(data.instance.customizations.css).to.equal('body { background-color: red; }')
+  expect(data.services.twitter.username).to.equal('@Kuja')
+  expect(data.services.twitter.whitelisted).to.be.true
+  expect(data.cache.previews.size).to.equal(2)
+  expect(data.cache.captions.size).to.equal(3)
+  expect(data.signup.enabled).to.be.false
+  expect(data.signup.limit).to.equal(5)
+  expect(data.admin.email).to.equal('superadmin1@example.com')
+  expect(data.user.videoQuota).to.equal(5242881)
+  expect(data.transcoding.enabled).to.be.true
+  expect(data.transcoding.threads).to.equal(1)
+  expect(data.transcoding.resolutions['240p']).to.be.false
+  expect(data.transcoding.resolutions['360p']).to.be.true
+  expect(data.transcoding.resolutions['480p']).to.be.true
+  expect(data.transcoding.resolutions['720p']).to.be.false
+  expect(data.transcoding.resolutions['1080p']).to.be.false
+}
+
 describe('Test config', function () {
   let server = null
 
@@ -51,35 +106,11 @@ describe('Test config', function () {
     const res = await getCustomConfig(server.url, server.accessToken)
     const data = res.body as CustomConfig
 
-    expect(data.instance.name).to.equal('PeerTube')
-    expect(data.instance.shortDescription).to.equal(
-      'PeerTube, a federated (ActivityPub) video streaming platform using P2P (BitTorrent) directly in the web browser ' +
-      'with WebTorrent and Angular.'
-    )
-    expect(data.instance.description).to.equal('Welcome to this PeerTube instance!')
-    expect(data.instance.terms).to.equal('No terms for now.')
-    expect(data.instance.defaultClientRoute).to.equal('/videos/trending')
-    expect(data.instance.defaultNSFWPolicy).to.equal('display')
-    expect(data.instance.customizations.css).to.be.empty
-    expect(data.instance.customizations.javascript).to.be.empty
-    expect(data.services.twitter.username).to.equal('@Chocobozzz')
-    expect(data.services.twitter.whitelisted).to.be.false
-    expect(data.cache.previews.size).to.equal(1)
-    expect(data.signup.enabled).to.be.true
-    expect(data.signup.limit).to.equal(4)
-    expect(data.admin.email).to.equal('admin1@example.com')
-    expect(data.user.videoQuota).to.equal(5242880)
-    expect(data.transcoding.enabled).to.be.false
-    expect(data.transcoding.threads).to.equal(2)
-    expect(data.transcoding.resolutions['240p']).to.be.true
-    expect(data.transcoding.resolutions['360p']).to.be.true
-    expect(data.transcoding.resolutions['480p']).to.be.true
-    expect(data.transcoding.resolutions['720p']).to.be.true
-    expect(data.transcoding.resolutions['1080p']).to.be.true
+    checkInitialConfig(data)
   })
 
   it('Should update the customized configuration', async function () {
-    const newCustomConfig = {
+    const newCustomConfig: CustomConfig = {
       instance: {
         name: 'PeerTube updated',
         shortDescription: 'my short description',
@@ -101,6 +132,9 @@ describe('Test config', function () {
       cache: {
         previews: {
           size: 2
+        },
+        captions: {
+          size: 3
         }
       },
       signup: {
@@ -130,28 +164,7 @@ describe('Test config', function () {
     const res = await getCustomConfig(server.url, server.accessToken)
     const data = res.body
 
-    expect(data.instance.name).to.equal('PeerTube updated')
-    expect(data.instance.shortDescription).to.equal('my short description')
-    expect(data.instance.description).to.equal('my super description')
-    expect(data.instance.terms).to.equal('my super terms')
-    expect(data.instance.defaultClientRoute).to.equal('/videos/recently-added')
-    expect(data.instance.defaultNSFWPolicy).to.equal('blur')
-    expect(data.instance.customizations.javascript).to.equal('alert("coucou")')
-    expect(data.instance.customizations.css).to.equal('body { background-color: red; }')
-    expect(data.services.twitter.username).to.equal('@Kuja')
-    expect(data.services.twitter.whitelisted).to.be.true
-    expect(data.cache.previews.size).to.equal(2)
-    expect(data.signup.enabled).to.be.false
-    expect(data.signup.limit).to.equal(5)
-    expect(data.admin.email).to.equal('superadmin1@example.com')
-    expect(data.user.videoQuota).to.equal(5242881)
-    expect(data.transcoding.enabled).to.be.true
-    expect(data.transcoding.threads).to.equal(1)
-    expect(data.transcoding.resolutions['240p']).to.be.false
-    expect(data.transcoding.resolutions['360p']).to.be.true
-    expect(data.transcoding.resolutions['480p']).to.be.true
-    expect(data.transcoding.resolutions['720p']).to.be.false
-    expect(data.transcoding.resolutions['1080p']).to.be.false
+    checkUpdatedConfig(data)
   })
 
   it('Should have the configuration updated after a restart', async function () {
@@ -164,28 +177,7 @@ describe('Test config', function () {
     const res = await getCustomConfig(server.url, server.accessToken)
     const data = res.body
 
-    expect(data.instance.name).to.equal('PeerTube updated')
-    expect(data.instance.shortDescription).to.equal('my short description')
-    expect(data.instance.description).to.equal('my super description')
-    expect(data.instance.terms).to.equal('my super terms')
-    expect(data.instance.defaultClientRoute).to.equal('/videos/recently-added')
-    expect(data.instance.defaultNSFWPolicy).to.equal('blur')
-    expect(data.instance.customizations.javascript).to.equal('alert("coucou")')
-    expect(data.instance.customizations.css).to.equal('body { background-color: red; }')
-    expect(data.services.twitter.username).to.equal('@Kuja')
-    expect(data.services.twitter.whitelisted).to.be.true
-    expect(data.cache.previews.size).to.equal(2)
-    expect(data.signup.enabled).to.be.false
-    expect(data.signup.limit).to.equal(5)
-    expect(data.admin.email).to.equal('superadmin1@example.com')
-    expect(data.user.videoQuota).to.equal(5242881)
-    expect(data.transcoding.enabled).to.be.true
-    expect(data.transcoding.threads).to.equal(1)
-    expect(data.transcoding.resolutions['240p']).to.be.false
-    expect(data.transcoding.resolutions['360p']).to.be.true
-    expect(data.transcoding.resolutions['480p']).to.be.true
-    expect(data.transcoding.resolutions['720p']).to.be.false
-    expect(data.transcoding.resolutions['1080p']).to.be.false
+    checkUpdatedConfig(data)
   })
 
   it('Should fetch the about information', async function () {
@@ -206,31 +198,7 @@ describe('Test config', function () {
     const res = await getCustomConfig(server.url, server.accessToken)
     const data = res.body
 
-    expect(data.instance.name).to.equal('PeerTube')
-    expect(data.instance.shortDescription).to.equal(
-      'PeerTube, a federated (ActivityPub) video streaming platform using P2P (BitTorrent) directly in the web browser ' +
-      'with WebTorrent and Angular.'
-    )
-    expect(data.instance.description).to.equal('Welcome to this PeerTube instance!')
-    expect(data.instance.terms).to.equal('No terms for now.')
-    expect(data.instance.defaultClientRoute).to.equal('/videos/trending')
-    expect(data.instance.defaultNSFWPolicy).to.equal('display')
-    expect(data.instance.customizations.css).to.be.empty
-    expect(data.instance.customizations.javascript).to.be.empty
-    expect(data.services.twitter.username).to.equal('@Chocobozzz')
-    expect(data.services.twitter.whitelisted).to.be.false
-    expect(data.cache.previews.size).to.equal(1)
-    expect(data.signup.enabled).to.be.true
-    expect(data.signup.limit).to.equal(4)
-    expect(data.admin.email).to.equal('admin1@example.com')
-    expect(data.user.videoQuota).to.equal(5242880)
-    expect(data.transcoding.enabled).to.be.false
-    expect(data.transcoding.threads).to.equal(2)
-    expect(data.transcoding.resolutions['240p']).to.be.true
-    expect(data.transcoding.resolutions['360p']).to.be.true
-    expect(data.transcoding.resolutions['480p']).to.be.true
-    expect(data.transcoding.resolutions['720p']).to.be.true
-    expect(data.transcoding.resolutions['1080p']).to.be.true
+    checkInitialConfig(data)
   })
 
   after(async function () {
diff --git a/server/tests/api/server/follows.ts b/server/tests/api/server/follows.ts
index ce42df0a6..a19b47509 100644
--- a/server/tests/api/server/follows.ts
+++ b/server/tests/api/server/follows.ts
@@ -26,6 +26,8 @@ import {
 } from '../../utils/videos/video-comments'
 import { rateVideo } from '../../utils/videos/videos'
 import { waitJobs } from '../../utils/server/jobs'
+import { createVideoCaption, listVideoCaptions, testCaptionFile } from '../../utils/videos/video-captions'
+import { VideoCaption } from '../../../../shared/models/videos/video-caption.model'
 
 const expect = chai.expect
 
@@ -244,6 +246,16 @@ describe('Test follows', function () {
           const text3 = 'my second answer to thread 1'
           await addVideoCommentReply(servers[ 2 ].url, servers[ 2 ].accessToken, video4.id, threadId, text3)
         }
+
+        {
+          await createVideoCaption({
+            url: servers[2].url,
+            accessToken: servers[2].accessToken,
+            language: 'ar',
+            videoId: video4.id,
+            fixture: 'subtitle-good2.vtt'
+          })
+        }
       }
 
       await waitJobs(servers)
@@ -266,7 +278,7 @@ describe('Test follows', function () {
       await expectAccountFollows(servers[2].url, 'peertube@localhost:9003', 1, 0)
     })
 
-    it('Should propagate videos', async function () {
+    it('Should have propagated videos', async function () {
       const res = await getVideosList(servers[ 0 ].url)
       expect(res.body.total).to.equal(7)
 
@@ -314,7 +326,7 @@ describe('Test follows', function () {
       await completeVideoCheck(servers[ 0 ].url, video4, checkAttributes)
     })
 
-    it('Should propagate comments', async function () {
+    it('Should have propagated comments', async function () {
       const res1 = await getVideoCommentThreads(servers[0].url, video4.id, 0, 5)
 
       expect(res1.body.total).to.equal(1)
@@ -353,6 +365,18 @@ describe('Test follows', function () {
       expect(secondChild.children).to.have.lengthOf(0)
     })
 
+    it('Should have propagated captions', async function () {
+      const res = await listVideoCaptions(servers[0].url, video4.id)
+      expect(res.body.total).to.equal(1)
+      expect(res.body.data).to.have.lengthOf(1)
+
+      const caption1: VideoCaption = res.body.data[0]
+      expect(caption1.language.id).to.equal('ar')
+      expect(caption1.language.label).to.equal('Arabic')
+      expect(caption1.captionPath).to.equal('/static/video-captions/' + video4.uuid + '-ar.vtt')
+      await testCaptionFile(servers[0].url, caption1.captionPath, 'Subtitle good 2.')
+    })
+
     it('Should unfollow server 3 on server 1 and does not list server 3 videos', async function () {
       this.timeout(5000)
 
diff --git a/server/tests/api/videos/video-captions.ts b/server/tests/api/videos/video-captions.ts
new file mode 100644
index 000000000..cbf5268f0
--- /dev/null
+++ b/server/tests/api/videos/video-captions.ts
@@ -0,0 +1,139 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import { doubleFollow, flushAndRunMultipleServers, uploadVideo } from '../../utils'
+import { flushTests, killallServers, ServerInfo, setAccessTokensToServers } from '../../utils/index'
+import { waitJobs } from '../../utils/server/jobs'
+import { createVideoCaption, deleteVideoCaption, listVideoCaptions, testCaptionFile } from '../../utils/videos/video-captions'
+import { VideoCaption } from '../../../../shared/models/videos/video-caption.model'
+
+const expect = chai.expect
+
+describe('Test video captions', function () {
+  let servers: ServerInfo[]
+  let videoUUID: string
+
+  before(async function () {
+    this.timeout(30000)
+
+    await flushTests()
+
+    servers = await flushAndRunMultipleServers(2)
+
+    await setAccessTokensToServers(servers)
+    await doubleFollow(servers[0], servers[1])
+
+    await waitJobs(servers)
+
+    const res = await uploadVideo(servers[ 0 ].url, servers[ 0 ].accessToken, { name: 'my video name' })
+    videoUUID = res.body.video.uuid
+
+    await waitJobs(servers)
+  })
+
+  it('Should list the captions and return an empty list', async function () {
+    for (const server of servers) {
+      const res = await listVideoCaptions(server.url, videoUUID)
+      expect(res.body.total).to.equal(0)
+      expect(res.body.data).to.have.lengthOf(0)
+    }
+  })
+
+  it('Should create two new captions', async function () {
+    this.timeout(30000)
+
+    await createVideoCaption({
+      url: servers[0].url,
+      accessToken: servers[0].accessToken,
+      language: 'ar',
+      videoId: videoUUID,
+      fixture: 'subtitle-good1.vtt'
+    })
+
+    await createVideoCaption({
+      url: servers[0].url,
+      accessToken: servers[0].accessToken,
+      language: 'zh',
+      videoId: videoUUID,
+      fixture: 'subtitle-good2.vtt'
+    })
+
+    await waitJobs(servers)
+  })
+
+  it('Should list these uploaded captions', async function () {
+    for (const server of servers) {
+      const res = await listVideoCaptions(server.url, videoUUID)
+      expect(res.body.total).to.equal(2)
+      expect(res.body.data).to.have.lengthOf(2)
+
+      const caption1: VideoCaption = res.body.data[0]
+      expect(caption1.language.id).to.equal('ar')
+      expect(caption1.language.label).to.equal('Arabic')
+      expect(caption1.captionPath).to.equal('/static/video-captions/' + videoUUID + '-ar.vtt')
+      await testCaptionFile(server.url, caption1.captionPath, 'Subtitle good 1.')
+
+      const caption2: VideoCaption = res.body.data[1]
+      expect(caption2.language.id).to.equal('zh')
+      expect(caption2.language.label).to.equal('Chinese')
+      expect(caption2.captionPath).to.equal('/static/video-captions/' + videoUUID + '-zh.vtt')
+      await testCaptionFile(server.url, caption2.captionPath, 'Subtitle good 2.')
+    }
+  })
+
+  it('Should replace an existing caption', async function () {
+    this.timeout(30000)
+
+    await createVideoCaption({
+      url: servers[0].url,
+      accessToken: servers[0].accessToken,
+      language: 'ar',
+      videoId: videoUUID,
+      fixture: 'subtitle-good2.vtt'
+    })
+
+    await waitJobs(servers)
+  })
+
+  it('Should have this caption updated', async function () {
+    for (const server of servers) {
+      const res = await listVideoCaptions(server.url, videoUUID)
+      expect(res.body.total).to.equal(2)
+      expect(res.body.data).to.have.lengthOf(2)
+
+      const caption1: VideoCaption = res.body.data[0]
+      expect(caption1.language.id).to.equal('ar')
+      expect(caption1.language.label).to.equal('Arabic')
+      expect(caption1.captionPath).to.equal('/static/video-captions/' + videoUUID + '-ar.vtt')
+      await testCaptionFile(server.url, caption1.captionPath, 'Subtitle good 2.')
+    }
+  })
+
+  it('Should remove one caption', async function () {
+    this.timeout(30000)
+
+    await deleteVideoCaption(servers[0].url, servers[0].accessToken, videoUUID, 'ar')
+
+    await waitJobs(servers)
+  })
+
+  it('Should only list the caption that was not deleted', async function () {
+    for (const server of servers) {
+      const res = await listVideoCaptions(server.url, videoUUID)
+      expect(res.body.total).to.equal(1)
+      expect(res.body.data).to.have.lengthOf(1)
+
+      const caption: VideoCaption = res.body.data[0]
+
+      expect(caption.language.id).to.equal('zh')
+      expect(caption.language.label).to.equal('Chinese')
+      expect(caption.captionPath).to.equal('/static/video-captions/' + videoUUID + '-zh.vtt')
+      await testCaptionFile(server.url, caption.captionPath, 'Subtitle good 2.')
+    }
+  })
+
+  after(async function () {
+    killallServers(servers)
+  })
+})