Add video chapters support

8 files changed, 559 insertions, 10 deletions

diff --git a/packages/tests/fixtures/video_chapters.mp4 b/packages/tests/fixtures/video_chapters.mp4
new file mode 100644
index 000000000..46cbaf624
--- /dev/null
+++ b/packages/tests/fixtures/video_chapters.mp4
diff --git a/packages/tests/src/api/check-params/index.ts b/packages/tests/src/api/check-params/index.ts
index ed5fe6b06..d7867e8a5 100644
--- a/packages/tests/src/api/check-params/index.ts
+++ b/packages/tests/src/api/check-params/index.ts
@@ -30,6 +30,7 @@ import './video-blacklist.js'
 import './video-captions.js'
 import './video-channel-syncs.js'
 import './video-channels.js'
+import './video-chapters.js'
 import './video-comments.js'
 import './video-files.js'
 import './video-imports.js'
diff --git a/packages/tests/src/api/check-params/video-captions.ts b/packages/tests/src/api/check-params/video-captions.ts
index 4150b095f..ac4e85068 100644
--- a/packages/tests/src/api/check-params/video-captions.ts
+++ b/packages/tests/src/api/check-params/video-captions.ts
@@ -31,15 +31,7 @@ describe('Test video captions API validator', function () {
 
     video = await server.videos.upload()
     privateVideo = await server.videos.upload({ attributes: { privacy: VideoPrivacy.PRIVATE } })
-
-    {
-      const user = {
-        username: 'user1',
-        password: 'my super password'
-      }
-      await server.users.create({ username: user.username, password: user.password })
-      userAccessToken = await server.login.getAccessToken(user)
-    }
+    userAccessToken = await server.users.generateUserAndToken('user1')
   })
 
   describe('When adding video caption', function () {
@@ -120,6 +112,19 @@ describe('Test video captions API validator', function () {
       })
     })
 
+    it('Should fail with another user token', async function () {
+      const captionPath = path + video.uuid + '/captions/fr'
+      await makeUploadRequest({
+        method: 'PUT',
+        url: server.url,
+        path: captionPath,
+        token: userAccessToken,
+        fields,
+        attaches,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
     // We accept any file now
     // it('Should fail with an invalid captionfile extension', async function () {
     //   const attaches = {
diff --git a/packages/tests/src/api/check-params/video-chapters.ts b/packages/tests/src/api/check-params/video-chapters.ts
new file mode 100644
index 000000000..c59f88e79
--- /dev/null
+++ b/packages/tests/src/api/check-params/video-chapters.ts
@@ -0,0 +1,172 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { HttpStatusCode, Video, VideoCreateResult, VideoPrivacy } from '@peertube/peertube-models'
+import {
+  PeerTubeServer,
+  cleanupTests,
+  createSingleServer,
+  setAccessTokensToServers,
+  setDefaultVideoChannel
+} from '@peertube/peertube-server-commands'
+
+describe('Test videos chapters API validator', function () {
+  let server: PeerTubeServer
+  let video: VideoCreateResult
+  let live: Video
+  let privateVideo: VideoCreateResult
+  let userAccessToken: string
+
+  // ---------------------------------------------------------------
+
+  before(async function () {
+    this.timeout(30000)
+
+    server = await createSingleServer(1)
+
+    await setAccessTokensToServers([ server ])
+    await setDefaultVideoChannel([ server ])
+
+    video = await server.videos.upload()
+    privateVideo = await server.videos.upload({ attributes: { privacy: VideoPrivacy.PRIVATE } })
+    userAccessToken = await server.users.generateUserAndToken('user1')
+
+    await server.config.enableLive({ allowReplay: false })
+
+    const res = await server.live.quickCreate({ saveReplay: false, permanentLive: false })
+    live = res.video
+  })
+
+  describe('When updating chapters', function () {
+
+    it('Should fail without a valid uuid', async function () {
+      await server.chapters.update({ videoId: '4da6fd', chapters: [], expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
+
+    it('Should fail with an unknown id', async function () {
+      await server.chapters.update({
+        videoId: 'ce0801ef-7124-48df-9b22-b473ace78797',
+        chapters: [],
+        expectedStatus: HttpStatusCode.NOT_FOUND_404
+      })
+    })
+
+    it('Should fail without access token', async function () {
+      await server.chapters.update({
+        videoId: video.id,
+        chapters: [],
+        token: null,
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
+      })
+    })
+
+    it('Should fail with a bad access token', async function () {
+      await server.chapters.update({
+        videoId: video.id,
+        chapters: [],
+        token: 'toto',
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
+      })
+    })
+
+    it('Should fail with a another user access token', async function () {
+      await server.chapters.update({
+        videoId: video.id,
+        chapters: [],
+        token: userAccessToken,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should fail with a wrong chapters param', async function () {
+      await server.chapters.update({
+        videoId: video.id,
+        chapters: 'hello' as any,
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
+      })
+    })
+
+    it('Should fail with a bad chapter title', async function () {
+      await server.chapters.update({
+        videoId: video.id,
+        chapters: [ { title: 'hello', timecode: 21 }, { title: '', timecode: 21 } ],
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
+      })
+
+      await server.chapters.update({
+        videoId: video.id,
+        chapters: [ { title: 'hello', timecode: 21 }, { title: 'a'.repeat(150), timecode: 21 } ],
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
+      })
+    })
+
+    it('Should fail with a bad timecode', async function () {
+      await server.chapters.update({
+        videoId: video.id,
+        chapters: [ { title: 'hello', timecode: 21 }, { title: 'title', timecode: -5 } ],
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
+      })
+
+      await server.chapters.update({
+        videoId: video.id,
+        chapters: [ { title: 'hello', timecode: 21 }, { title: 'title', timecode: 'hi' as any } ],
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
+      })
+    })
+
+    it('Should fail with non unique timecodes', async function () {
+      await server.chapters.update({
+        videoId: video.id,
+        chapters: [ { title: 'hello', timecode: 21 }, { title: 'title', timecode: 22 }, { title: 'hello', timecode: 21 } ],
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
+      })
+    })
+
+    it('Should fail to create chapters on a live', async function () {
+      await server.chapters.update({
+        videoId: live.id,
+        chapters: [],
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
+      })
+    })
+
+    it('Should succeed with the correct params', async function () {
+      await server.chapters.update({
+        videoId: video.id,
+        chapters: []
+      })
+
+      await server.chapters.update({
+        videoId: video.id,
+        chapters: [ { title: 'hello', timecode: 21 }, { title: 'hello 2', timecode: 35 } ]
+      })
+    })
+  })
+
+  describe('When listing chapters', function () {
+
+    it('Should fail without a valid uuid', async function () {
+      await server.chapters.list({ videoId: '4da6fd', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
+
+    it('Should fail with an unknown id', async function () {
+      await server.chapters.list({ videoId: '4da6fde3-88f7-4d16-b119-108df5630b06', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+    })
+
+    it('Should not list private chapters to anyone', async function () {
+      await server.chapters.list({ videoId: privateVideo.uuid, token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+    })
+
+    it('Should not list private chapters to another user', async function () {
+      await server.chapters.list({ videoId: privateVideo.uuid, token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+    })
+
+    it('Should list chapters', async function () {
+      await server.chapters.list({ videoId: privateVideo.uuid })
+      await server.chapters.list({ videoId: video.uuid })
+    })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/api/videos/index.ts b/packages/tests/src/api/videos/index.ts
index fcb1d5a81..a4bcd9741 100644
--- a/packages/tests/src/api/videos/index.ts
+++ b/packages/tests/src/api/videos/index.ts
@@ -4,6 +4,7 @@ import './single-server.js'
 import './video-captions.js'
 import './video-change-ownership.js'
 import './video-channels.js'
+import './video-chapters.js'
 import './channel-import-videos.js'
 import './video-channel-syncs.js'
 import './video-comments.js'
diff --git a/packages/tests/src/api/videos/video-chapters.ts b/packages/tests/src/api/videos/video-chapters.ts
new file mode 100644
index 000000000..2f3dbcd2e
--- /dev/null
+++ b/packages/tests/src/api/videos/video-chapters.ts
@@ -0,0 +1,342 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { VideoChapter, VideoCreateResult, VideoPrivacy } from '@peertube/peertube-models'
+import { areHttpImportTestsDisabled } from '@peertube/peertube-node-utils'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow, PeerTubeServer, setAccessTokensToServers,
+  setDefaultVideoChannel,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+import { FIXTURE_URLS } from '@tests/shared/tests.js'
+import { expect } from 'chai'
+
+describe('Test video chapters', function () {
+  let servers: PeerTubeServer[]
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await createMultipleServers(2)
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  describe('Common tests', function () {
+    let video: VideoCreateResult
+
+    before(async function () {
+      this.timeout(120000)
+
+      video = await servers[0].videos.quickUpload({ name: 'video' })
+      await waitJobs(servers)
+    })
+
+    it('Should not have chapters', async function () {
+      for (const server of servers) {
+        const { chapters } = await server.chapters.list({ videoId: video.uuid })
+
+        expect(chapters).to.deep.equal([])
+      }
+    })
+
+    it('Should set chaptets', async function () {
+      await servers[0].chapters.update({
+        videoId: video.uuid,
+        chapters: [
+          { title: 'chapter 1', timecode: 45 },
+          { title: 'chapter 2', timecode: 58 }
+        ]
+      })
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { chapters } = await server.chapters.list({ videoId: video.uuid })
+
+        expect(chapters).to.deep.equal([
+          { title: 'chapter 1', timecode: 45 },
+          { title: 'chapter 2', timecode: 58 }
+        ])
+      }
+    })
+
+    it('Should add new chapters', async function () {
+      await servers[0].chapters.update({
+        videoId: video.uuid,
+        chapters: [
+          { title: 'chapter 1', timecode: 45 },
+          { title: 'chapter 2', timecode: 46 },
+          { title: 'chapter 3', timecode: 58 }
+        ]
+      })
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { chapters } = await server.chapters.list({ videoId: video.uuid })
+
+        expect(chapters).to.deep.equal([
+          { title: 'chapter 1', timecode: 45 },
+          { title: 'chapter 2', timecode: 46 },
+          { title: 'chapter 3', timecode: 58 }
+        ])
+      }
+    })
+
+    it('Should delete all chapters', async function () {
+      await servers[0].chapters.update({ videoId: video.uuid, chapters: [] })
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { chapters } = await server.chapters.list({ videoId: video.uuid })
+
+        expect(chapters).to.deep.equal([])
+      }
+    })
+  })
+
+  describe('With chapters in description', function () {
+    const description = 'this is a super description\n' +
+      '00:00 chapter 1\n' +
+      '00:03 chapter 2\n' +
+      '00:04 chapter 3\n'
+
+    function checkChapters (chapters: VideoChapter[]) {
+      expect(chapters).to.deep.equal([
+        {
+          timecode: 0,
+          title: 'chapter 1'
+        },
+        {
+          timecode: 3,
+          title: 'chapter 2'
+        },
+        {
+          timecode: 4,
+          title: 'chapter 3'
+        }
+      ])
+    }
+
+    it('Should upload a video with chapters in description', async function () {
+      const video = await servers[0].videos.upload({ attributes: { name: 'description', description } })
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { chapters } = await server.chapters.list({ videoId: video.uuid })
+
+        checkChapters(chapters)
+      }
+    })
+
+    it('Should update a video description and automatically add chapters', async function () {
+      const video = await servers[0].videos.quickUpload({ name: 'update description' })
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { chapters } = await server.chapters.list({ videoId: video.uuid })
+
+        expect(chapters).to.deep.equal([])
+      }
+
+      await servers[0].videos.update({ id: video.uuid, attributes: { description } })
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { chapters } = await server.chapters.list({ videoId: video.uuid })
+
+        checkChapters(chapters)
+      }
+    })
+
+    it('Should update a video description but not automatically add chapters since the video already has chapters', async function () {
+      const video = await servers[0].videos.quickUpload({ name: 'update description' })
+
+      await servers[0].chapters.update({ videoId: video.uuid, chapters: [ { timecode: 5, title: 'chapter 1' } ] })
+      await servers[0].videos.update({ id: video.uuid, attributes: { description } })
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { chapters } = await server.chapters.list({ videoId: video.uuid })
+
+        expect(chapters).to.deep.equal([ { timecode: 5, title: 'chapter 1' } ])
+      }
+    })
+
+    it('Should update multiple times chapters from description', async function () {
+      const video = await servers[0].videos.quickUpload({ name: 'update description' })
+
+      await servers[0].videos.update({ id: video.uuid, attributes: { description } })
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { chapters } = await server.chapters.list({ videoId: video.uuid })
+
+        checkChapters(chapters)
+      }
+
+      await servers[0].videos.update({ id: video.uuid, attributes: { description: '00:01 chapter 1' } })
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { chapters } = await server.chapters.list({ videoId: video.uuid })
+
+        expect(chapters).to.deep.equal([ { timecode: 1, title: 'chapter 1' } ])
+      }
+
+      await servers[0].videos.update({ id: video.uuid, attributes: { description: 'null description' } })
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { chapters } = await server.chapters.list({ videoId: video.uuid })
+
+        expect(chapters).to.deep.equal([])
+      }
+    })
+  })
+
+  describe('With upload', function () {
+
+    it('Should upload a mp4 containing chapters and automatically add them', async function () {
+      const video = await servers[0].videos.quickUpload({ fixture: 'video_chapters.mp4', name: 'chapters' })
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { chapters } = await server.chapters.list({ videoId: video.uuid })
+
+        expect(chapters).to.deep.equal([
+          {
+            timecode: 0,
+            title: 'Chapter 1'
+          },
+          {
+            timecode: 2,
+            title: 'Chapter 2'
+          },
+          {
+            timecode: 4,
+            title: 'Chapter 3'
+          }
+        ])
+      }
+    })
+  })
+
+  describe('With URL import', function () {
+    if (areHttpImportTestsDisabled()) return
+
+    it('Should detect chapters from youtube URL import', async function () {
+      this.timeout(120000)
+
+      const attributes = {
+        channelId: servers[0].store.channel.id,
+        privacy: VideoPrivacy.PUBLIC,
+        targetUrl: FIXTURE_URLS.youtubeChapters,
+        description: 'this is a super description\n'
+      }
+      const { video } = await servers[0].imports.importVideo({ attributes })
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { chapters } = await server.chapters.list({ videoId: video.uuid })
+
+        expect(chapters).to.deep.equal([
+          {
+            timecode: 0,
+            title: 'chapter 1'
+          },
+          {
+            timecode: 15,
+            title: 'chapter 2'
+          },
+          {
+            timecode: 35,
+            title: 'chapter 3'
+          },
+          {
+            timecode: 40,
+            title: 'chapter 4'
+          }
+        ])
+      }
+    })
+
+    it('Should have overriden description priority from youtube URL import', async function () {
+      this.timeout(120000)
+
+      const attributes = {
+        channelId: servers[0].store.channel.id,
+        privacy: VideoPrivacy.PUBLIC,
+        targetUrl: FIXTURE_URLS.youtubeChapters,
+        description: 'this is a super description\n' +
+          '00:00 chapter 1\n' +
+          '00:03 chapter 2\n' +
+          '00:04 chapter 3\n'
+      }
+      const { video } = await servers[0].imports.importVideo({ attributes })
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { chapters } = await server.chapters.list({ videoId: video.uuid })
+
+        expect(chapters).to.deep.equal([
+          {
+            timecode: 0,
+            title: 'chapter 1'
+          },
+          {
+            timecode: 3,
+            title: 'chapter 2'
+          },
+          {
+            timecode: 4,
+            title: 'chapter 3'
+          }
+        ])
+      }
+    })
+
+    it('Should detect chapters from raw URL import', async function () {
+      this.timeout(120000)
+
+      const attributes = {
+        channelId: servers[0].store.channel.id,
+        privacy: VideoPrivacy.PUBLIC,
+        targetUrl: FIXTURE_URLS.chatersVideo
+      }
+      const { video } = await servers[0].imports.importVideo({ attributes })
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const { chapters } = await server.chapters.list({ videoId: video.uuid })
+
+        expect(chapters).to.deep.equal([
+          {
+            timecode: 0,
+            title: 'Chapter 1'
+          },
+          {
+            timecode: 2,
+            title: 'Chapter 2'
+          },
+          {
+            timecode: 4,
+            title: 'Chapter 3'
+          }
+        ])
+      }
+    })
+  })
+
+  // TODO: test torrent import too
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/server-helpers/core-utils.ts b/packages/tests/src/server-helpers/core-utils.ts
index d61cae855..0df238e88 100644
--- a/packages/tests/src/server-helpers/core-utils.ts
+++ b/packages/tests/src/server-helpers/core-utils.ts
@@ -3,7 +3,7 @@
 import { expect } from 'chai'
 import snakeCase from 'lodash-es/snakeCase.js'
 import validator from 'validator'
-import { getAverageTheoreticalBitrate, getMaxTheoreticalBitrate } from '@peertube/peertube-core-utils'
+import { getAverageTheoreticalBitrate, getMaxTheoreticalBitrate, parseChapters } from '@peertube/peertube-core-utils'
 import { VideoResolution } from '@peertube/peertube-models'
 import { objectConverter, parseBytes, parseDurationToMs, parseSemVersion } from '@peertube/peertube-server/server/helpers/core-utils.js'
 
@@ -199,3 +199,28 @@ describe('Parse semantic version string', function () {
     expect(actual.patch).to.equal(0)
   })
 })
+
+describe('Extract chapters', function () {
+
+  it('Should not extract chapters', function () {
+    expect(parseChapters('my super description\nno?')).to.deep.equal([])
+    expect(parseChapters('m00:00 super description\nno?')).to.deep.equal([])
+    expect(parseChapters('00:00super description\nno?')).to.deep.equal([])
+  })
+
+  it('Should extract chapters', function () {
+    expect(parseChapters('00:00 coucou')).to.deep.equal([ { timecode: 0, title: 'coucou' } ])
+    expect(parseChapters('my super description\n\n00:01:30 chapter 1\n00:01:35 chapter 2')).to.deep.equal([
+      { timecode: 90, title: 'chapter 1' },
+      { timecode: 95, title: 'chapter 2' }
+    ])
+    expect(parseChapters('hi\n\n00:01:30 chapter 1\n00:01:35 chapter 2\nhi')).to.deep.equal([
+      { timecode: 90, title: 'chapter 1' },
+      { timecode: 95, title: 'chapter 2' }
+    ])
+    expect(parseChapters('hi\n\n00:01:30 chapter 1\n00:01:35 chapter 2\nhi\n00:01:40 chapter 3')).to.deep.equal([
+      { timecode: 90, title: 'chapter 1' },
+      { timecode: 95, title: 'chapter 2' }
+    ])
+  })
+})
diff --git a/packages/tests/src/shared/tests.ts b/packages/tests/src/shared/tests.ts
index d2cb040fb..554ed0e1f 100644
--- a/packages/tests/src/shared/tests.ts
+++ b/packages/tests/src/shared/tests.ts
@@ -3,6 +3,7 @@ const FIXTURE_URLS = {
   peertube_short: 'https://peertube2.cpy.re/w/3fbif9S3WmtTP8gGsC5HBd',
 
   youtube: 'https://www.youtube.com/watch?v=msX3jv1XdvM',
+  youtubeChapters: 'https://www.youtube.com/watch?v=TL9P-Er7ils',
 
   /**
    * The video is used to check format-selection correctness wrt. HDR,
@@ -26,6 +27,8 @@ const FIXTURE_URLS = {
   goodVideo: 'https://download.cpy.re/peertube/good_video.mp4',
   goodVideo720: 'https://download.cpy.re/peertube/good_video_720.mp4',
 
+  chatersVideo: 'https://download.cpy.re/peertube/video_chapters.mp4',
+
   file4K: 'https://download.cpy.re/peertube/4k_file.txt'
 }