8 files changed, 2017 insertions, 0 deletions
diff --git a/packages/tests/src/api/search/index.ts b/packages/tests/src/api/search/index.ts
new file mode 100644
index 000000000..f4420261d
--- /dev/null
+++ b/packages/tests/src/api/search/index.ts
@@ -0,0 +1,7 @@
+import './search-activitypub-video-playlists.js'
+import './search-activitypub-video-channels.js'
+import './search-activitypub-videos.js'
+import './search-channels.js'
+import './search-index.js'
+import './search-playlists.js'
+import './search-videos.js'
diff --git a/packages/tests/src/api/search/search-activitypub-video-channels.ts b/packages/tests/src/api/search/search-activitypub-video-channels.ts
new file mode 100644
index 000000000..b63f45b18
--- /dev/null
+++ b/packages/tests/src/api/search/search-activitypub-video-channels.ts
@@ -0,0 +1,255 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+import { expect } from 'chai'
+import { wait } from '@peertube/peertube-core-utils'
+import { VideoChannel } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  PeerTubeServer,
+  SearchCommand,
+  setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultVideoChannel,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+describe('Test ActivityPub video channels search', function () {
+  let servers: PeerTubeServer[]
+  let userServer2Token: string
+  let videoServer2UUID: string
+  let channelIdServer2: number
+  let command: SearchCommand
+  before(async function () {
+    this.timeout(120000)
+    servers = await createMultipleServers(2)
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+    await setDefaultAccountAvatar(servers)
+    {
+      await servers[0].users.create({ username: 'user1_server1', password: 'password' })
+      const channel = {
+        name: 'channel1_server1',
+        displayName: 'Channel 1 server 1'
+      }
+      await servers[0].channels.create({ attributes: channel })
+    }
+    {
+      const user = { username: 'user1_server2', password: 'password' }
+      await servers[1].users.create({ username: user.username, password: user.password })
+      userServer2Token = await servers[1].login.getAccessToken(user)
+      const channel = {
+        name: 'channel1_server2',
+        displayName: 'Channel 1 server 2'
+      }
+      const created = await servers[1].channels.create({ token: userServer2Token, attributes: channel })
+      channelIdServer2 = created.id
+      const attributes = { name: 'video 1 server 2', channelId: channelIdServer2 }
+      const { uuid } = await servers[1].videos.upload({ token: userServer2Token, attributes })
+      videoServer2UUID = uuid
+    }
+    await waitJobs(servers)
+    command = servers[0].search
+  })
+  it('Should not find a remote video channel', async function () {
+    this.timeout(15000)
+    {
+      const search = servers[1].url + '/video-channels/channel1_server3'
+      const body = await command.searchChannels({ search, token: servers[0].accessToken })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
+    }
+    {
+      // Without token
+      const search = servers[1].url + '/video-channels/channel1_server2'
+      const body = await command.searchChannels({ search })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
+    }
+  })
+  it('Should search a local video channel', async function () {
+    const searches = [
+      servers[0].url + '/video-channels/channel1_server1',
+      'channel1_server1@' + servers[0].host
+    ]
+    for (const search of searches) {
+      const body = await command.searchChannels({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].name).to.equal('channel1_server1')
+      expect(body.data[0].displayName).to.equal('Channel 1 server 1')
+    }
+  })
+  it('Should search a local video channel with an alternative URL', async function () {
+    const search = servers[0].url + '/c/channel1_server1'
+    for (const token of [ undefined, servers[0].accessToken ]) {
+      const body = await command.searchChannels({ search, token })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].name).to.equal('channel1_server1')
+      expect(body.data[0].displayName).to.equal('Channel 1 server 1')
+    }
+  })
+  it('Should search a local video channel with a query in URL', async function () {
+    const searches = [
+      servers[0].url + '/video-channels/channel1_server1',
+      servers[0].url + '/c/channel1_server1'
+    ]
+    for (const search of searches) {
+      for (const token of [ undefined, servers[0].accessToken ]) {
+        const body = await command.searchChannels({ search: search + '?param=2', token })
+        expect(body.total).to.equal(1)
+        expect(body.data).to.be.an('array')
+        expect(body.data).to.have.lengthOf(1)
+        expect(body.data[0].name).to.equal('channel1_server1')
+        expect(body.data[0].displayName).to.equal('Channel 1 server 1')
+      }
+    }
+  })
+  it('Should search a remote video channel with URL or handle', async function () {
+    const searches = [
+      servers[1].url + '/video-channels/channel1_server2',
+      servers[1].url + '/c/channel1_server2',
+      servers[1].url + '/c/channel1_server2/videos',
+      'channel1_server2@' + servers[1].host
+    ]
+    for (const search of searches) {
+      const body = await command.searchChannels({ search, token: servers[0].accessToken })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].name).to.equal('channel1_server2')
+      expect(body.data[0].displayName).to.equal('Channel 1 server 2')
+    }
+  })
+  it('Should not list this remote video channel', async function () {
+    const body = await servers[0].channels.list()
+    expect(body.total).to.equal(3)
+    expect(body.data).to.have.lengthOf(3)
+    expect(body.data[0].name).to.equal('channel1_server1')
+    expect(body.data[1].name).to.equal('user1_server1_channel')
+    expect(body.data[2].name).to.equal('root_channel')
+  })
+  it('Should list video channel videos of server 2 without token', async function () {
+    this.timeout(30000)
+    await waitJobs(servers)
+    const { total, data } = await servers[0].videos.listByChannel({
+      token: null,
+      handle: 'channel1_server2@' + servers[1].host
+    })
+    expect(total).to.equal(0)
+    expect(data).to.have.lengthOf(0)
+  })
+  it('Should list video channel videos of server 2 with token', async function () {
+    const { total, data } = await servers[0].videos.listByChannel({
+      handle: 'channel1_server2@' + servers[1].host
+    })
+    expect(total).to.equal(1)
+    expect(data[0].name).to.equal('video 1 server 2')
+  })
+  it('Should update video channel of server 2, and refresh it on server 1', async function () {
+    this.timeout(120000)
+    await servers[1].channels.update({
+      token: userServer2Token,
+      channelName: 'channel1_server2',
+      attributes: { displayName: 'channel updated' }
+    })
+    await servers[1].users.updateMe({ token: userServer2Token, displayName: 'user updated' })
+    await waitJobs(servers)
+    // Expire video channel
+    await wait(10000)
+    const search = servers[1].url + '/video-channels/channel1_server2'
+    const body = await command.searchChannels({ search, token: servers[0].accessToken })
+    expect(body.total).to.equal(1)
+    expect(body.data).to.have.lengthOf(1)
+    const videoChannel: VideoChannel = body.data[0]
+    expect(videoChannel.displayName).to.equal('channel updated')
+    // We don't return the owner account for now
+    // expect(videoChannel.ownerAccount.displayName).to.equal('user updated')
+  })
+  it('Should update and add a video on server 2, and update it on server 1 after a search', async function () {
+    this.timeout(120000)
+    await servers[1].videos.update({ token: userServer2Token, id: videoServer2UUID, attributes: { name: 'video 1 updated' } })
+    await servers[1].videos.upload({ token: userServer2Token, attributes: { name: 'video 2 server 2', channelId: channelIdServer2 } })
+    await waitJobs(servers)
+    // Expire video channel
+    await wait(10000)
+    const search = servers[1].url + '/video-channels/channel1_server2'
+    await command.searchChannels({ search, token: servers[0].accessToken })
+    await waitJobs(servers)
+    const handle = 'channel1_server2@' + servers[1].host
+    const { total, data } = await servers[0].videos.listByChannel({ handle, sort: '-createdAt' })
+    expect(total).to.equal(2)
+    expect(data[0].name).to.equal('video 2 server 2')
+    expect(data[1].name).to.equal('video 1 updated')
+  })
+  it('Should delete video channel of server 2, and delete it on server 1', async function () {
+    this.timeout(120000)
+    await servers[1].channels.delete({ token: userServer2Token, channelName: 'channel1_server2' })
+    await waitJobs(servers)
+    // Expire video
+    await wait(10000)
+    const search = servers[1].url + '/video-channels/channel1_server2'
+    const body = await command.searchChannels({ search, token: servers[0].accessToken })
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
+  })
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/search/search-activitypub-video-playlists.ts b/packages/tests/src/api/search/search-activitypub-video-playlists.ts
new file mode 100644
index 000000000..33ecfd8e7
--- /dev/null
+++ b/packages/tests/src/api/search/search-activitypub-video-playlists.ts
@@ -0,0 +1,214 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+import { expect } from 'chai'
+import { wait } from '@peertube/peertube-core-utils'
+import { VideoPlaylistPrivacy } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  PeerTubeServer,
+  SearchCommand,
+  setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultVideoChannel,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+describe('Test ActivityPub playlists search', function () {
+  let servers: PeerTubeServer[]
+  let playlistServer1UUID: string
+  let playlistServer2UUID: string
+  let video2Server2: string
+  let command: SearchCommand
+  before(async function () {
+    this.timeout(240000)
+    servers = await createMultipleServers(2)
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+    await setDefaultAccountAvatar(servers)
+    {
+      const video1 = (await servers[0].videos.quickUpload({ name: 'video 1' })).uuid
+      const video2 = (await servers[0].videos.quickUpload({ name: 'video 2' })).uuid
+      const attributes = {
+        displayName: 'playlist 1 on server 1',
+        privacy: VideoPlaylistPrivacy.PUBLIC,
+        videoChannelId: servers[0].store.channel.id
+      }
+      const created = await servers[0].playlists.create({ attributes })
+      playlistServer1UUID = created.uuid
+      for (const videoId of [ video1, video2 ]) {
+        await servers[0].playlists.addElement({ playlistId: playlistServer1UUID, attributes: { videoId } })
+      }
+    }
+    {
+      const videoId = (await servers[1].videos.quickUpload({ name: 'video 1' })).uuid
+      video2Server2 = (await servers[1].videos.quickUpload({ name: 'video 2' })).uuid
+      const attributes = {
+        displayName: 'playlist 1 on server 2',
+        privacy: VideoPlaylistPrivacy.PUBLIC,
+        videoChannelId: servers[1].store.channel.id
+      }
+      const created = await servers[1].playlists.create({ attributes })
+      playlistServer2UUID = created.uuid
+      await servers[1].playlists.addElement({ playlistId: playlistServer2UUID, attributes: { videoId } })
+    }
+    await waitJobs(servers)
+    command = servers[0].search
+  })
+  it('Should not find a remote playlist', async function () {
+    {
+      const search = servers[1].url + '/video-playlists/43'
+      const body = await command.searchPlaylists({ search, token: servers[0].accessToken })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
+    }
+    {
+      // Without token
+      const search = servers[1].url + '/video-playlists/' + playlistServer2UUID
+      const body = await command.searchPlaylists({ search })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
+    }
+  })
+  it('Should search a local playlist', async function () {
+    const search = servers[0].url + '/video-playlists/' + playlistServer1UUID
+    const body = await command.searchPlaylists({ search })
+    expect(body.total).to.equal(1)
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(1)
+    expect(body.data[0].displayName).to.equal('playlist 1 on server 1')
+    expect(body.data[0].videosLength).to.equal(2)
+  })
+  it('Should search a local playlist with an alternative URL', async function () {
+    const searches = [
+      servers[0].url + '/videos/watch/playlist/' + playlistServer1UUID,
+      servers[0].url + '/w/p/' + playlistServer1UUID
+    ]
+    for (const search of searches) {
+      for (const token of [ undefined, servers[0].accessToken ]) {
+        const body = await command.searchPlaylists({ search, token })
+        expect(body.total).to.equal(1)
+        expect(body.data).to.be.an('array')
+        expect(body.data).to.have.lengthOf(1)
+        expect(body.data[0].displayName).to.equal('playlist 1 on server 1')
+        expect(body.data[0].videosLength).to.equal(2)
+      }
+    }
+  })
+  it('Should search a local playlist with a query in URL', async function () {
+    const searches = [
+      servers[0].url + '/videos/watch/playlist/' + playlistServer1UUID,
+      servers[0].url + '/w/p/' + playlistServer1UUID
+    ]
+    for (const search of searches) {
+      for (const token of [ undefined, servers[0].accessToken ]) {
+        const body = await command.searchPlaylists({ search: search + '?param=1', token })
+        expect(body.total).to.equal(1)
+        expect(body.data).to.be.an('array')
+        expect(body.data).to.have.lengthOf(1)
+        expect(body.data[0].displayName).to.equal('playlist 1 on server 1')
+        expect(body.data[0].videosLength).to.equal(2)
+      }
+    }
+  })
+  it('Should search a remote playlist', async function () {
+    const searches = [
+      servers[1].url + '/video-playlists/' + playlistServer2UUID,
+      servers[1].url + '/videos/watch/playlist/' + playlistServer2UUID,
+      servers[1].url + '/w/p/' + playlistServer2UUID
+    ]
+    for (const search of searches) {
+      const body = await command.searchPlaylists({ search, token: servers[0].accessToken })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].displayName).to.equal('playlist 1 on server 2')
+      expect(body.data[0].videosLength).to.equal(1)
+    }
+  })
+  it('Should not list this remote playlist', async function () {
+    const body = await servers[0].playlists.list({ start: 0, count: 10 })
+    expect(body.total).to.equal(1)
+    expect(body.data).to.have.lengthOf(1)
+    expect(body.data[0].displayName).to.equal('playlist 1 on server 1')
+  })
+  it('Should update the playlist of server 2, and refresh it on server 1', async function () {
+    this.timeout(60000)
+    await servers[1].playlists.addElement({ playlistId: playlistServer2UUID, attributes: { videoId: video2Server2 } })
+    await waitJobs(servers)
+    // Expire playlist
+    await wait(10000)
+    // Will run refresh async
+    const search = servers[1].url + '/video-playlists/' + playlistServer2UUID
+    await command.searchPlaylists({ search, token: servers[0].accessToken })
+    // Wait refresh
+    await wait(5000)
+    const body = await command.searchPlaylists({ search, token: servers[0].accessToken })
+    expect(body.total).to.equal(1)
+    expect(body.data).to.have.lengthOf(1)
+    const playlist = body.data[0]
+    expect(playlist.videosLength).to.equal(2)
+  })
+  it('Should delete playlist of server 2, and delete it on server 1', async function () {
+    this.timeout(60000)
+    await servers[1].playlists.delete({ playlistId: playlistServer2UUID })
+    await waitJobs(servers)
+    // Expiration
+    await wait(10000)
+    // Will run refresh async
+    const search = servers[1].url + '/video-playlists/' + playlistServer2UUID
+    await command.searchPlaylists({ search, token: servers[0].accessToken })
+    // Wait refresh
+    await wait(5000)
+    const body = await command.searchPlaylists({ search, token: servers[0].accessToken })
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
+  })
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/search/search-activitypub-videos.ts b/packages/tests/src/api/search/search-activitypub-videos.ts
new file mode 100644
index 000000000..72759f21e
--- /dev/null
+++ b/packages/tests/src/api/search/search-activitypub-videos.ts
@@ -0,0 +1,196 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+import { expect } from 'chai'
+import { wait } from '@peertube/peertube-core-utils'
+import { VideoPrivacy } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  PeerTubeServer,
+  SearchCommand,
+  setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultVideoChannel,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+describe('Test ActivityPub videos search', function () {
+  let servers: PeerTubeServer[]
+  let videoServer1UUID: string
+  let videoServer2UUID: string
+  let command: SearchCommand
+  before(async function () {
+    this.timeout(120000)
+    servers = await createMultipleServers(2)
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+    await setDefaultAccountAvatar(servers)
+    {
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video 1 on server 1' } })
+      videoServer1UUID = uuid
+    }
+    {
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'video 1 on server 2' } })
+      videoServer2UUID = uuid
+    }
+    await waitJobs(servers)
+    command = servers[0].search
+  })
+  it('Should not find a remote video', async function () {
+    {
+      const search = servers[1].url + '/videos/watch/43'
+      const body = await command.searchVideos({ search, token: servers[0].accessToken })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
+    }
+    {
+      // Without token
+      const search = servers[1].url + '/videos/watch/' + videoServer2UUID
+      const body = await command.searchVideos({ search })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(0)
+    }
+  })
+  it('Should search a local video', async function () {
+    const search = servers[0].url + '/videos/watch/' + videoServer1UUID
+    const body = await command.searchVideos({ search })
+    expect(body.total).to.equal(1)
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(1)
+    expect(body.data[0].name).to.equal('video 1 on server 1')
+  })
+  it('Should search a local video with an alternative URL', async function () {
+    const search = servers[0].url + '/w/' + videoServer1UUID
+    const body1 = await command.searchVideos({ search })
+    const body2 = await command.searchVideos({ search, token: servers[0].accessToken })
+    for (const body of [ body1, body2 ]) {
+      expect(body.total).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].name).to.equal('video 1 on server 1')
+    }
+  })
+  it('Should search a local video with a query in URL', async function () {
+    const searches = [
+      servers[0].url + '/w/' + videoServer1UUID,
+      servers[0].url + '/videos/watch/' + videoServer1UUID
+    ]
+    for (const search of searches) {
+      for (const token of [ undefined, servers[0].accessToken ]) {
+        const body = await command.searchVideos({ search: search + '?startTime=4', token })
+        expect(body.total).to.equal(1)
+        expect(body.data).to.be.an('array')
+        expect(body.data).to.have.lengthOf(1)
+        expect(body.data[0].name).to.equal('video 1 on server 1')
+      }
+    }
+  })
+  it('Should search a remote video', async function () {
+    const searches = [
+      servers[1].url + '/w/' + videoServer2UUID,
+      servers[1].url + '/videos/watch/' + videoServer2UUID
+    ]
+    for (const search of searches) {
+      const body = await command.searchVideos({ search, token: servers[0].accessToken })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].name).to.equal('video 1 on server 2')
+    }
+  })
+  it('Should not list this remote video', async function () {
+    const { total, data } = await servers[0].videos.list()
+    expect(total).to.equal(1)
+    expect(data).to.have.lengthOf(1)
+    expect(data[0].name).to.equal('video 1 on server 1')
+  })
+  it('Should update video of server 2, and refresh it on server 1', async function () {
+    this.timeout(120000)
+    const channelAttributes = {
+      name: 'super_channel',
+      displayName: 'super channel'
+    }
+    const created = await servers[1].channels.create({ attributes: channelAttributes })
+    const videoChannelId = created.id
+    const attributes = {
+      name: 'updated',
+      tag: [ 'tag1', 'tag2' ],
+      privacy: VideoPrivacy.UNLISTED,
+      channelId: videoChannelId
+    }
+    await servers[1].videos.update({ id: videoServer2UUID, attributes })
+    await waitJobs(servers)
+    // Expire video
+    await wait(10000)
+    // Will run refresh async
+    const search = servers[1].url + '/videos/watch/' + videoServer2UUID
+    await command.searchVideos({ search, token: servers[0].accessToken })
+    // Wait refresh
+    await wait(5000)
+    const body = await command.searchVideos({ search, token: servers[0].accessToken })
+    expect(body.total).to.equal(1)
+    expect(body.data).to.have.lengthOf(1)
+    const video = body.data[0]
+    expect(video.name).to.equal('updated')
+    expect(video.channel.name).to.equal('super_channel')
+    expect(video.privacy.id).to.equal(VideoPrivacy.UNLISTED)
+  })
+  it('Should delete video of server 2, and delete it on server 1', async function () {
+    this.timeout(120000)
+    await servers[1].videos.remove({ id: videoServer2UUID })
+    await waitJobs(servers)
+    // Expire video
+    await wait(10000)
+    // Will run refresh async
+    const search = servers[1].url + '/videos/watch/' + videoServer2UUID
+    await command.searchVideos({ search, token: servers[0].accessToken })
+    // Wait refresh
+    await wait(5000)
+    const body = await command.searchVideos({ search, token: servers[0].accessToken })
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
+  })
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/search/search-channels.ts b/packages/tests/src/api/search/search-channels.ts
new file mode 100644
index 000000000..36596e036
--- /dev/null
+++ b/packages/tests/src/api/search/search-channels.ts
@@ -0,0 +1,159 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+import { expect } from 'chai'
+import { VideoChannel } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createSingleServer,
+  doubleFollow,
+  PeerTubeServer,
+  SearchCommand,
+  setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar
+} from '@peertube/peertube-server-commands'
+describe('Test channels search', function () {
+  let server: PeerTubeServer
+  let remoteServer: PeerTubeServer
+  let command: SearchCommand
+  before(async function () {
+    this.timeout(120000)
+    const servers = await Promise.all([
+      createSingleServer(1),
+      createSingleServer(2)
+    ])
+    server = servers[0]
+    remoteServer = servers[1]
+    await setAccessTokensToServers([ server, remoteServer ])
+    await setDefaultChannelAvatar(server)
+    await setDefaultAccountAvatar(server)
+    await servers[1].config.disableTranscoding()
+    {
+      await server.users.create({ username: 'user1' })
+      const channel = {
+        name: 'squall_channel',
+        displayName: 'Squall channel'
+      }
+      await server.channels.create({ attributes: channel })
+    }
+    {
+      await remoteServer.users.create({ username: 'user1' })
+      const channel = {
+        name: 'zell_channel',
+        displayName: 'Zell channel'
+      }
+      const { id } = await remoteServer.channels.create({ attributes: channel })
+      await remoteServer.videos.upload({ attributes: { channelId: id } })
+    }
+    await doubleFollow(server, remoteServer)
+    command = server.search
+  })
+  it('Should make a simple search and not have results', async function () {
+    const body = await command.searchChannels({ search: 'abc' })
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
+  })
+  it('Should make a search and have results', async function () {
+    {
+      const search = {
+        search: 'Squall',
+        start: 0,
+        count: 1
+      }
+      const body = await command.advancedChannelSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+      const channel: VideoChannel = body.data[0]
+      expect(channel.name).to.equal('squall_channel')
+      expect(channel.displayName).to.equal('Squall channel')
+    }
+    {
+      const search = {
+        search: 'Squall',
+        start: 1,
+        count: 1
+      }
+      const body = await command.advancedChannelSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(0)
+    }
+  })
+  it('Should filter by host', async function () {
+    {
+      const search = { search: 'channel', host: remoteServer.host }
+      const body = await command.advancedChannelSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].displayName).to.equal('Zell channel')
+    }
+    {
+      const search = { search: 'Sq', host: server.host }
+      const body = await command.advancedChannelSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].displayName).to.equal('Squall channel')
+    }
+    {
+      const search = { search: 'Squall', host: 'example.com' }
+      const body = await command.advancedChannelSearch({ search })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    }
+  })
+  it('Should filter by names', async function () {
+    {
+      const body = await command.advancedChannelSearch({ search: { handles: [ 'squall_channel', 'zell_channel' ] } })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].displayName).to.equal('Squall channel')
+    }
+    {
+      const body = await command.advancedChannelSearch({ search: { handles: [ 'squall_channel@' + server.host ] } })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+      expect(body.data[0].displayName).to.equal('Squall channel')
+    }
+    {
+      const body = await command.advancedChannelSearch({ search: { handles: [ 'chocobozzz_channel' ] } })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    }
+    {
+      const body = await command.advancedChannelSearch({ search: { handles: [ 'squall_channel', 'zell_channel@' + remoteServer.host ] } })
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(2)
+      expect(body.data[0].displayName).to.equal('Squall channel')
+      expect(body.data[1].displayName).to.equal('Zell channel')
+    }
+  })
+  after(async function () {
+    await cleanupTests([ server, remoteServer ])
+  })
+})
diff --git a/packages/tests/src/api/search/search-index.ts b/packages/tests/src/api/search/search-index.ts
new file mode 100644
index 000000000..4bac7ea94
--- /dev/null
+++ b/packages/tests/src/api/search/search-index.ts
@@ -0,0 +1,438 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+import { expect } from 'chai'
+import {
+  BooleanBothQuery,
+  VideoChannelsSearchQuery,
+  VideoPlaylistPrivacy,
+  VideoPlaylistsSearchQuery,
+  VideoPlaylistType,
+  VideosSearchQuery
+} from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createSingleServer,
+  PeerTubeServer,
+  SearchCommand,
+  setAccessTokensToServers
+} from '@peertube/peertube-server-commands'
+describe('Test index search', function () {
+  const localVideoName = 'local video' + new Date().toISOString()
+  let server: PeerTubeServer = null
+  let command: SearchCommand
+  before(async function () {
+    this.timeout(30000)
+    server = await createSingleServer(1)
+    await setAccessTokensToServers([ server ])
+    await server.videos.upload({ attributes: { name: localVideoName } })
+    command = server.search
+  })
+  describe('Default search', async function () {
+    it('Should make a local videos search by default', async function () {
+      await server.config.updateCustomSubConfig({
+        newConfig: {
+          search: {
+            searchIndex: {
+              enabled: true,
+              isDefaultSearch: false,
+              disableLocalSearch: false
+            }
+          }
+        }
+      })
+      const body = await command.searchVideos({ search: 'local video' })
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal(localVideoName)
+    })
+    it('Should make a local channels search by default', async function () {
+      const body = await command.searchChannels({ search: 'root' })
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('root_channel')
+      expect(body.data[0].host).to.equal(server.host)
+    })
+    it('Should make an index videos search by default', async function () {
+      await server.config.updateCustomSubConfig({
+        newConfig: {
+          search: {
+            searchIndex: {
+              enabled: true,
+              isDefaultSearch: true,
+              disableLocalSearch: false
+            }
+          }
+        }
+      })
+      const body = await command.searchVideos({ search: 'local video' })
+      expect(body.total).to.be.greaterThan(2)
+    })
+    it('Should make an index channels search by default', async function () {
+      const body = await command.searchChannels({ search: 'root' })
+      expect(body.total).to.be.greaterThan(2)
+    })
+  })
+  describe('Videos search', async function () {
+    async function check (search: VideosSearchQuery, exists = true) {
+      const body = await command.advancedVideoSearch({ search })
+      if (exists === false) {
+        expect(body.total).to.equal(0)
+        expect(body.data).to.have.lengthOf(0)
+        return
+      }
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+      const video = body.data[0]
+      expect(video.name).to.equal('What is PeerTube?')
+      expect(video.category.label).to.equal('Science & Technology')
+      expect(video.licence.label).to.equal('Attribution - Share Alike')
+      expect(video.privacy.label).to.equal('Public')
+      expect(video.duration).to.equal(113)
+      expect(video.thumbnailUrl.startsWith('https://framatube.org/static/thumbnails')).to.be.true
+      expect(video.account.host).to.equal('framatube.org')
+      expect(video.account.name).to.equal('framasoft')
+      expect(video.account.url).to.equal('https://framatube.org/accounts/framasoft')
+      expect(video.account.avatars.length).to.equal(2, 'Account should have one avatar image')
+      expect(video.channel.host).to.equal('framatube.org')
+      expect(video.channel.name).to.equal('joinpeertube')
+      expect(video.channel.url).to.equal('https://framatube.org/video-channels/joinpeertube')
+      expect(video.channel.avatars.length).to.equal(2, 'Channel should have one avatar image')
+    }
+    const baseSearch: VideosSearchQuery = {
+      search: 'what is peertube',
+      start: 0,
+      count: 2,
+      categoryOneOf: [ 15 ],
+      licenceOneOf: [ 2 ],
+      tagsAllOf: [ 'framasoft', 'peertube' ],
+      startDate: '2018-10-01T10:50:46.396Z',
+      endDate: '2018-10-01T10:55:46.396Z'
+    }
+    it('Should make a simple search and not have results', async function () {
+      const body = await command.searchVideos({ search: 'djidane'.repeat(50) })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    })
+    it('Should make a simple search and have results', async function () {
+      const body = await command.searchVideos({ search: 'What is PeerTube' })
+      expect(body.total).to.be.greaterThan(1)
+    })
+    it('Should make a simple search', async function () {
+      await check(baseSearch)
+    })
+    it('Should search by start date', async function () {
+      const search = { ...baseSearch, startDate: '2018-10-01T10:54:46.396Z' }
+      await check(search, false)
+    })
+    it('Should search by tags', async function () {
+      const search = { ...baseSearch, tagsAllOf: [ 'toto', 'framasoft' ] }
+      await check(search, false)
+    })
+    it('Should search by duration', async function () {
+      const search = { ...baseSearch, durationMin: 2000 }
+      await check(search, false)
+    })
+    it('Should search by nsfw attribute', async function () {
+      {
+        const search = { ...baseSearch, nsfw: 'true' as BooleanBothQuery }
+        await check(search, false)
+      }
+      {
+        const search = { ...baseSearch, nsfw: 'false' as BooleanBothQuery }
+        await check(search, true)
+      }
+      {
+        const search = { ...baseSearch, nsfw: 'both' as BooleanBothQuery }
+        await check(search, true)
+      }
+    })
+    it('Should search by host', async function () {
+      {
+        const search = { ...baseSearch, host: 'example.com' }
+        await check(search, false)
+      }
+      {
+        const search = { ...baseSearch, host: 'framatube.org' }
+        await check(search, true)
+      }
+    })
+    it('Should search by uuids', async function () {
+      const goodUUID = '9c9de5e8-0a1e-484a-b099-e80766180a6d'
+      const goodShortUUID = 'kkGMgK9ZtnKfYAgnEtQxbv'
+      const badUUID = 'c29c5b77-4a04-493d-96a9-2e9267e308f0'
+      const badShortUUID = 'rP5RgUeX9XwTSrspCdkDej'
+      {
+        const uuidsMatrix = [
+          [ goodUUID ],
+          [ goodUUID, badShortUUID ],
+          [ badShortUUID, goodShortUUID ],
+          [ goodUUID, goodShortUUID ]
+        ]
+        for (const uuids of uuidsMatrix) {
+          const search = { ...baseSearch, uuids }
+          await check(search, true)
+        }
+      }
+      {
+        const uuidsMatrix = [
+          [ badUUID ],
+          [ badShortUUID ]
+        ]
+        for (const uuids of uuidsMatrix) {
+          const search = { ...baseSearch, uuids }
+          await check(search, false)
+        }
+      }
+    })
+    it('Should have a correct pagination', async function () {
+      const search = {
+        search: 'video',
+        start: 0,
+        count: 5
+      }
+      const body = await command.advancedVideoSearch({ search })
+      expect(body.total).to.be.greaterThan(5)
+      expect(body.data).to.have.lengthOf(5)
+    })
+    it('Should use the nsfw instance policy as default', async function () {
+      let nsfwUUID: string
+      {
+        await server.config.updateCustomSubConfig({
+          newConfig: {
+            instance: { defaultNSFWPolicy: 'display' }
+          }
+        })
+        const body = await command.searchVideos({ search: 'NSFW search index', sort: '-match' })
+        expect(body.data).to.have.length.greaterThan(0)
+        const video = body.data[0]
+        expect(video.nsfw).to.be.true
+        nsfwUUID = video.uuid
+      }
+      {
+        await server.config.updateCustomSubConfig({
+          newConfig: {
+            instance: { defaultNSFWPolicy: 'do_not_list' }
+          }
+        })
+        const body = await command.searchVideos({ search: 'NSFW search index', sort: '-match' })
+        try {
+          expect(body.data).to.have.lengthOf(0)
+        } catch {
+          const video = body.data[0]
+          expect(video.uuid).not.equal(nsfwUUID)
+        }
+      }
+    })
+  })
+  describe('Channels search', async function () {
+    async function check (search: VideoChannelsSearchQuery, exists = true) {
+      const body = await command.advancedChannelSearch({ search })
+      if (exists === false) {
+        expect(body.total).to.equal(0)
+        expect(body.data).to.have.lengthOf(0)
+        return
+      }
+      expect(body.total).to.be.greaterThan(0)
+      expect(body.data).to.have.length.greaterThan(0)
+      const videoChannel = body.data[0]
+      expect(videoChannel.url).to.equal('https://framatube.org/video-channels/bf54d359-cfad-4935-9d45-9d6be93f63e8')
+      expect(videoChannel.host).to.equal('framatube.org')
+      expect(videoChannel.avatars.length).to.equal(2, 'Channel should have two avatar images')
+      expect(videoChannel.displayName).to.exist
+      expect(videoChannel.ownerAccount.url).to.equal('https://framatube.org/accounts/framasoft')
+      expect(videoChannel.ownerAccount.name).to.equal('framasoft')
+      expect(videoChannel.ownerAccount.host).to.equal('framatube.org')
+      expect(videoChannel.ownerAccount.avatars.length).to.equal(2, 'Account should have two avatar images')
+    }
+    it('Should make a simple search and not have results', async function () {
+      const body = await command.searchChannels({ search: 'a'.repeat(500) })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    })
+    it('Should make a search and have results', async function () {
+      await check({ search: 'Framasoft', sort: 'createdAt' }, true)
+    })
+    it('Should make host search and have appropriate results', async function () {
+      await check({ search: 'Framasoft videos', host: 'example.com' }, false)
+      await check({ search: 'Framasoft videos', host: 'framatube.org' }, true)
+    })
+    it('Should make handles search and have appropriate results', async function () {
+      await check({ handles: [ 'bf54d359-cfad-4935-9d45-9d6be93f63e8@framatube.org' ] }, true)
+      await check({ handles: [ 'jeanine', 'bf54d359-cfad-4935-9d45-9d6be93f63e8@framatube.org' ] }, true)
+      await check({ handles: [ 'jeanine', 'chocobozzz_channel2@peertube2.cpy.re' ] }, false)
+    })
+    it('Should have a correct pagination', async function () {
+      const body = await command.advancedChannelSearch({ search: { search: 'root', start: 0, count: 2 } })
+      expect(body.total).to.be.greaterThan(2)
+      expect(body.data).to.have.lengthOf(2)
+    })
+  })
+  describe('Playlists search', async function () {
+    async function check (search: VideoPlaylistsSearchQuery, exists = true) {
+      const body = await command.advancedPlaylistSearch({ search })
+      if (exists === false) {
+        expect(body.total).to.equal(0)
+        expect(body.data).to.have.lengthOf(0)
+        return
+      }
+      expect(body.total).to.be.greaterThan(0)
+      expect(body.data).to.have.length.greaterThan(0)
+      const videoPlaylist = body.data[0]
+      expect(videoPlaylist.url).to.equal('https://peertube2.cpy.re/videos/watch/playlist/73804a40-da9a-40c2-b1eb-2c6d9eec8f0a')
+      expect(videoPlaylist.thumbnailUrl).to.exist
+      expect(videoPlaylist.embedUrl).to.equal('https://peertube2.cpy.re/video-playlists/embed/73804a40-da9a-40c2-b1eb-2c6d9eec8f0a')
+      expect(videoPlaylist.type.id).to.equal(VideoPlaylistType.REGULAR)
+      expect(videoPlaylist.privacy.id).to.equal(VideoPlaylistPrivacy.PUBLIC)
+      expect(videoPlaylist.videosLength).to.exist
+      expect(videoPlaylist.createdAt).to.exist
+      expect(videoPlaylist.updatedAt).to.exist
+      expect(videoPlaylist.uuid).to.equal('73804a40-da9a-40c2-b1eb-2c6d9eec8f0a')
+      expect(videoPlaylist.displayName).to.exist
+      expect(videoPlaylist.ownerAccount.url).to.equal('https://peertube2.cpy.re/accounts/chocobozzz')
+      expect(videoPlaylist.ownerAccount.name).to.equal('chocobozzz')
+      expect(videoPlaylist.ownerAccount.host).to.equal('peertube2.cpy.re')
+      expect(videoPlaylist.ownerAccount.avatars.length).to.equal(2, 'Account should have two avatar images')
+      expect(videoPlaylist.videoChannel.url).to.equal('https://peertube2.cpy.re/video-channels/chocobozzz_channel')
+      expect(videoPlaylist.videoChannel.name).to.equal('chocobozzz_channel')
+      expect(videoPlaylist.videoChannel.host).to.equal('peertube2.cpy.re')
+      expect(videoPlaylist.videoChannel.avatars.length).to.equal(2, 'Channel should have two avatar images')
+    }
+    it('Should make a simple search and not have results', async function () {
+      const body = await command.searchPlaylists({ search: 'a'.repeat(500) })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    })
+    it('Should make a search and have results', async function () {
+      await check({ search: 'E2E playlist', sort: '-match' }, true)
+    })
+    it('Should make host search and have appropriate results', async function () {
+      await check({ search: 'E2E playlist', host: 'example.com' }, false)
+      await check({ search: 'E2E playlist', host: 'peertube2.cpy.re', sort: '-match' }, true)
+    })
+    it('Should make a search by uuids and have appropriate results', async function () {
+      const goodUUID = '73804a40-da9a-40c2-b1eb-2c6d9eec8f0a'
+      const goodShortUUID = 'fgei1ws1oa6FCaJ2qZPG29'
+      const badUUID = 'c29c5b77-4a04-493d-96a9-2e9267e308f0'
+      const badShortUUID = 'rP5RgUeX9XwTSrspCdkDej'
+      {
+        const uuidsMatrix = [
+          [ goodUUID ],
+          [ goodUUID, badShortUUID ],
+          [ badShortUUID, goodShortUUID ],
+          [ goodUUID, goodShortUUID ]
+        ]
+        for (const uuids of uuidsMatrix) {
+          const search = { search: 'E2E playlist', sort: '-match', uuids }
+          await check(search, true)
+        }
+      }
+      {
+        const uuidsMatrix = [
+          [ badUUID ],
+          [ badShortUUID ]
+        ]
+        for (const uuids of uuidsMatrix) {
+          const search = { search: 'E2E playlist', sort: '-match', uuids }
+          await check(search, false)
+        }
+      }
+    })
+    it('Should have a correct pagination', async function () {
+      const body = await command.advancedChannelSearch({ search: { search: 'root', start: 0, count: 2 } })
+      expect(body.total).to.be.greaterThan(2)
+      expect(body.data).to.have.lengthOf(2)
+    })
+  })
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/api/search/search-playlists.ts b/packages/tests/src/api/search/search-playlists.ts
new file mode 100644
index 000000000..cd16e202e
--- /dev/null
+++ b/packages/tests/src/api/search/search-playlists.ts
@@ -0,0 +1,180 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+import { expect } from 'chai'
+import { VideoPlaylistPrivacy } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createSingleServer,
+  doubleFollow,
+  PeerTubeServer,
+  SearchCommand,
+  setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar,
+  setDefaultVideoChannel
+} from '@peertube/peertube-server-commands'
+describe('Test playlists search', function () {
+  let server: PeerTubeServer
+  let remoteServer: PeerTubeServer
+  let command: SearchCommand
+  let playlistUUID: string
+  let playlistShortUUID: string
+  before(async function () {
+    this.timeout(120000)
+    const servers = await Promise.all([
+      createSingleServer(1),
+      createSingleServer(2)
+    ])
+    server = servers[0]
+    remoteServer = servers[1]
+    await setAccessTokensToServers([ remoteServer, server ])
+    await setDefaultVideoChannel([ remoteServer, server ])
+    await setDefaultChannelAvatar([ remoteServer, server ])
+    await setDefaultAccountAvatar([ remoteServer, server ])
+    await servers[1].config.disableTranscoding()
+    {
+      const videoId = (await server.videos.upload()).uuid
+      const attributes = {
+        displayName: 'Dr. Kenzo Tenma hospital videos',
+        privacy: VideoPlaylistPrivacy.PUBLIC,
+        videoChannelId: server.store.channel.id
+      }
+      const created = await server.playlists.create({ attributes })
+      playlistUUID = created.uuid
+      playlistShortUUID = created.shortUUID
+      await server.playlists.addElement({ playlistId: created.id, attributes: { videoId } })
+    }
+    {
+      const videoId = (await remoteServer.videos.upload()).uuid
+      const attributes = {
+        displayName: 'Johan & Anna Libert music videos',
+        privacy: VideoPlaylistPrivacy.PUBLIC,
+        videoChannelId: remoteServer.store.channel.id
+      }
+      const created = await remoteServer.playlists.create({ attributes })
+      await remoteServer.playlists.addElement({ playlistId: created.id, attributes: { videoId } })
+    }
+    {
+      const attributes = {
+        displayName: 'Inspector Lunge playlist',
+        privacy: VideoPlaylistPrivacy.PUBLIC,
+        videoChannelId: server.store.channel.id
+      }
+      await server.playlists.create({ attributes })
+    }
+    await doubleFollow(server, remoteServer)
+    command = server.search
+  })
+  it('Should make a simple search and not have results', async function () {
+    const body = await command.searchPlaylists({ search: 'abc' })
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
+  })
+  it('Should make a search and have results', async function () {
+    {
+      const search = {
+        search: 'tenma',
+        start: 0,
+        count: 1
+      }
+      const body = await command.advancedPlaylistSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+      const playlist = body.data[0]
+      expect(playlist.displayName).to.equal('Dr. Kenzo Tenma hospital videos')
+      expect(playlist.url).to.equal(server.url + '/video-playlists/' + playlist.uuid)
+    }
+    {
+      const search = {
+        search: 'Anna Livert music',
+        start: 0,
+        count: 1
+      }
+      const body = await command.advancedPlaylistSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+      const playlist = body.data[0]
+      expect(playlist.displayName).to.equal('Johan & Anna Libert music videos')
+    }
+  })
+  it('Should filter by host', async function () {
+    {
+      const search = { search: 'tenma', host: server.host }
+      const body = await command.advancedPlaylistSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+      const playlist = body.data[0]
+      expect(playlist.displayName).to.equal('Dr. Kenzo Tenma hospital videos')
+    }
+    {
+      const search = { search: 'Anna', host: 'example.com' }
+      const body = await command.advancedPlaylistSearch({ search })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    }
+    {
+      const search = { search: 'video', host: remoteServer.host }
+      const body = await command.advancedPlaylistSearch({ search })
+      expect(body.total).to.equal(1)
+      expect(body.data).to.have.lengthOf(1)
+      const playlist = body.data[0]
+      expect(playlist.displayName).to.equal('Johan & Anna Libert music videos')
+    }
+  })
+  it('Should filter by UUIDs', async function () {
+    for (const uuid of [ playlistUUID, playlistShortUUID ]) {
+      const body = await command.advancedPlaylistSearch({ search: { uuids: [ uuid ] } })
+      expect(body.total).to.equal(1)
+      expect(body.data[0].displayName).to.equal('Dr. Kenzo Tenma hospital videos')
+    }
+    {
+      const body = await command.advancedPlaylistSearch({ search: { uuids: [ 'dfd70b83-639f-4980-94af-304a56ab4b35' ] } })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    }
+  })
+  it('Should not display playlists without videos', async function () {
+    const search = {
+      search: 'Lunge',
+      start: 0,
+      count: 1
+    }
+    const body = await command.advancedPlaylistSearch({ search })
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
+  })
+  after(async function () {
+    await cleanupTests([ server, remoteServer ])
+  })
+})
diff --git a/packages/tests/src/api/search/search-videos.ts b/packages/tests/src/api/search/search-videos.ts
new file mode 100644
index 000000000..0739f0886
--- /dev/null
+++ b/packages/tests/src/api/search/search-videos.ts
@@ -0,0 +1,568 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+import { expect } from 'chai'
+import { wait } from '@peertube/peertube-core-utils'
+import { VideoPrivacy } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createSingleServer,
+  doubleFollow,
+  PeerTubeServer,
+  SearchCommand,
+  setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar,
+  setDefaultVideoChannel,
+  stopFfmpeg
+} from '@peertube/peertube-server-commands'
+describe('Test videos search', function () {
+  let server: PeerTubeServer
+  let remoteServer: PeerTubeServer
+  let startDate: string
+  let videoUUID: string
+  let videoShortUUID: string
+  let command: SearchCommand
+  before(async function () {
+    this.timeout(360000)
+    const servers = await Promise.all([
+      createSingleServer(1),
+      createSingleServer(2)
+    ])
+    server = servers[0]
+    remoteServer = servers[1]
+    await setAccessTokensToServers([ server, remoteServer ])
+    await setDefaultVideoChannel([ server, remoteServer ])
+    await setDefaultChannelAvatar(server)
+    await setDefaultAccountAvatar(servers)
+    {
+      const attributes1 = {
+        name: '1111 2222 3333',
+        fixture: '60fps_720p_small.mp4', // 2 seconds
+        category: 1,
+        licence: 1,
+        nsfw: false,
+        language: 'fr'
+      }
+      await server.videos.upload({ attributes: attributes1 })
+      const attributes2 = { ...attributes1, name: attributes1.name + ' - 2', fixture: 'video_short.mp4' }
+      await server.videos.upload({ attributes: attributes2 })
+      {
+        const attributes3 = { ...attributes1, name: attributes1.name + ' - 3', language: undefined }
+        const { id, uuid, shortUUID } = await server.videos.upload({ attributes: attributes3 })
+        videoUUID = uuid
+        videoShortUUID = shortUUID
+        await server.captions.add({
+          language: 'en',
+          videoId: id,
+          fixture: 'subtitle-good2.vtt',
+          mimeType: 'application/octet-stream'
+        })
+        await server.captions.add({
+          language: 'aa',
+          videoId: id,
+          fixture: 'subtitle-good2.vtt',
+          mimeType: 'application/octet-stream'
+        })
+      }
+      const attributes4 = { ...attributes1, name: attributes1.name + ' - 4', language: 'pl', nsfw: true }
+      await server.videos.upload({ attributes: attributes4 })
+      await wait(1000)
+      startDate = new Date().toISOString()
+      const attributes5 = { ...attributes1, name: attributes1.name + ' - 5', licence: 2, language: undefined }
+      await server.videos.upload({ attributes: attributes5 })
+      const attributes6 = { ...attributes1, name: attributes1.name + ' - 6', tags: [ 't1', 't2' ] }
+      await server.videos.upload({ attributes: attributes6 })
+      const attributes7 = { ...attributes1, name: attributes1.name + ' - 7', originallyPublishedAt: '2019-02-12T09:58:08.286Z' }
+      await server.videos.upload({ attributes: attributes7 })
+      const attributes8 = { ...attributes1, name: attributes1.name + ' - 8', licence: 4 }
+      await server.videos.upload({ attributes: attributes8 })
+    }
+    {
+      const attributes = {
+        name: '3333 4444 5555',
+        fixture: 'video_short.mp4',
+        category: 2,
+        licence: 2,
+        language: 'en'
+      }
+      await server.videos.upload({ attributes })
+      await server.videos.upload({ attributes: { ...attributes, name: attributes.name + ' duplicate' } })
+    }
+    {
+      const attributes = {
+        name: '6666 7777 8888',
+        fixture: 'video_short.mp4',
+        category: 3,
+        licence: 3,
+        language: 'pl'
+      }
+      await server.videos.upload({ attributes })
+    }
+    {
+      const attributes1 = {
+        name: '9999',
+        tags: [ 'aaaa', 'bbbb', 'cccc' ],
+        category: 1
+      }
+      await server.videos.upload({ attributes: attributes1 })
+      await server.videos.upload({ attributes: { ...attributes1, category: 2 } })
+      await server.videos.upload({ attributes: { ...attributes1, tags: [ 'cccc', 'dddd' ] } })
+      await server.videos.upload({ attributes: { ...attributes1, tags: [ 'eeee', 'ffff' ] } })
+    }
+    {
+      const attributes1 = {
+        name: 'aaaa 2',
+        category: 1
+      }
+      await server.videos.upload({ attributes: attributes1 })
+      await server.videos.upload({ attributes: { ...attributes1, category: 2 } })
+    }
+    {
+      await remoteServer.videos.upload({ attributes: { name: 'remote video 1' } })
+      await remoteServer.videos.upload({ attributes: { name: 'remote video 2' } })
+    }
+    await doubleFollow(server, remoteServer)
+    command = server.search
+  })
+  it('Should make a simple search and not have results', async function () {
+    const body = await command.searchVideos({ search: 'abc' })
+    expect(body.total).to.equal(0)
+    expect(body.data).to.have.lengthOf(0)
+  })
+  it('Should make a simple search and have results', async function () {
+    const body = await command.searchVideos({ search: '4444 5555 duplicate' })
+    expect(body.total).to.equal(2)
+    const videos = body.data
+    expect(videos).to.have.lengthOf(2)
+    // bestmatch
+    expect(videos[0].name).to.equal('3333 4444 5555 duplicate')
+    expect(videos[1].name).to.equal('3333 4444 5555')
+  })
+  it('Should make a search on tags too, and have results', async function () {
+    const search = {
+      search: 'aaaa',
+      categoryOneOf: [ 1 ]
+    }
+    const body = await command.advancedVideoSearch({ search })
+    expect(body.total).to.equal(2)
+    const videos = body.data
+    expect(videos).to.have.lengthOf(2)
+    // bestmatch
+    expect(videos[0].name).to.equal('aaaa 2')
+    expect(videos[1].name).to.equal('9999')
+  })
+  it('Should filter on tags without a search', async function () {
+    const search = {
+      tagsAllOf: [ 'bbbb' ]
+    }
+    const body = await command.advancedVideoSearch({ search })
+    expect(body.total).to.equal(2)
+    const videos = body.data
+    expect(videos).to.have.lengthOf(2)
+    expect(videos[0].name).to.equal('9999')
+    expect(videos[1].name).to.equal('9999')
+  })
+  it('Should filter on category without a search', async function () {
+    const search = {
+      categoryOneOf: [ 3 ]
+    }
+    const body = await command.advancedVideoSearch({ search })
+    expect(body.total).to.equal(1)
+    const videos = body.data
+    expect(videos).to.have.lengthOf(1)
+    expect(videos[0].name).to.equal('6666 7777 8888')
+  })
+  it('Should search by tags (one of)', async function () {
+    const query = {
+      search: '9999',
+      categoryOneOf: [ 1 ],
+      tagsOneOf: [ 'aAaa', 'ffff' ]
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(2)
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: { ...query, tagsOneOf: [ 'blabla' ] } })
+      expect(body.total).to.equal(0)
+    }
+  })
+  it('Should search by tags (all of)', async function () {
+    const query = {
+      search: '9999',
+      categoryOneOf: [ 1 ],
+      tagsAllOf: [ 'CCcc' ]
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(2)
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: { ...query, tagsAllOf: [ 'blAbla' ] } })
+      expect(body.total).to.equal(0)
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: { ...query, tagsAllOf: [ 'bbbb', 'CCCC' ] } })
+      expect(body.total).to.equal(1)
+    }
+  })
+  it('Should search by category', async function () {
+    const query = {
+      search: '6666',
+      categoryOneOf: [ 3 ]
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('6666 7777 8888')
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: { ...query, categoryOneOf: [ 2 ] } })
+      expect(body.total).to.equal(0)
+    }
+  })
+  it('Should search by licence', async function () {
+    const query = {
+      search: '4444 5555',
+      licenceOneOf: [ 2 ]
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(2)
+      expect(body.data[0].name).to.equal('3333 4444 5555')
+      expect(body.data[1].name).to.equal('3333 4444 5555 duplicate')
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: { ...query, licenceOneOf: [ 3 ] } })
+      expect(body.total).to.equal(0)
+    }
+  })
+  it('Should search by languages', async function () {
+    const query = {
+      search: '1111 2222 3333',
+      languageOneOf: [ 'pl', 'en' ]
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(2)
+      expect(body.data[0].name).to.equal('1111 2222 3333 - 3')
+      expect(body.data[1].name).to.equal('1111 2222 3333 - 4')
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: { ...query, languageOneOf: [ 'pl', 'en', '_unknown' ] } })
+      expect(body.total).to.equal(3)
+      expect(body.data[0].name).to.equal('1111 2222 3333 - 3')
+      expect(body.data[1].name).to.equal('1111 2222 3333 - 4')
+      expect(body.data[2].name).to.equal('1111 2222 3333 - 5')
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: { ...query, languageOneOf: [ 'eo' ] } })
+      expect(body.total).to.equal(0)
+    }
+  })
+  it('Should search by start date', async function () {
+    const query = {
+      search: '1111 2222 3333',
+      startDate
+    }
+    const body = await command.advancedVideoSearch({ search: query })
+    expect(body.total).to.equal(4)
+    const videos = body.data
+    expect(videos[0].name).to.equal('1111 2222 3333 - 5')
+    expect(videos[1].name).to.equal('1111 2222 3333 - 6')
+    expect(videos[2].name).to.equal('1111 2222 3333 - 7')
+    expect(videos[3].name).to.equal('1111 2222 3333 - 8')
+  })
+  it('Should make an advanced search', async function () {
+    const query = {
+      search: '1111 2222 3333',
+      languageOneOf: [ 'pl', 'fr' ],
+      durationMax: 4,
+      nsfw: 'false' as 'false',
+      licenceOneOf: [ 1, 4 ]
+    }
+    const body = await command.advancedVideoSearch({ search: query })
+    expect(body.total).to.equal(4)
+    const videos = body.data
+    expect(videos[0].name).to.equal('1111 2222 3333')
+    expect(videos[1].name).to.equal('1111 2222 3333 - 6')
+    expect(videos[2].name).to.equal('1111 2222 3333 - 7')
+    expect(videos[3].name).to.equal('1111 2222 3333 - 8')
+  })
+  it('Should make an advanced search and sort results', async function () {
+    const query = {
+      search: '1111 2222 3333',
+      languageOneOf: [ 'pl', 'fr' ],
+      durationMax: 4,
+      nsfw: 'false' as 'false',
+      licenceOneOf: [ 1, 4 ],
+      sort: '-name'
+    }
+    const body = await command.advancedVideoSearch({ search: query })
+    expect(body.total).to.equal(4)
+    const videos = body.data
+    expect(videos[0].name).to.equal('1111 2222 3333 - 8')
+    expect(videos[1].name).to.equal('1111 2222 3333 - 7')
+    expect(videos[2].name).to.equal('1111 2222 3333 - 6')
+    expect(videos[3].name).to.equal('1111 2222 3333')
+  })
+  it('Should make an advanced search and only show the first result', async function () {
+    const query = {
+      search: '1111 2222 3333',
+      languageOneOf: [ 'pl', 'fr' ],
+      durationMax: 4,
+      nsfw: 'false' as 'false',
+      licenceOneOf: [ 1, 4 ],
+      sort: '-name',
+      start: 0,
+      count: 1
+    }
+    const body = await command.advancedVideoSearch({ search: query })
+    expect(body.total).to.equal(4)
+    const videos = body.data
+    expect(videos[0].name).to.equal('1111 2222 3333 - 8')
+  })
+  it('Should make an advanced search and only show the last result', async function () {
+    const query = {
+      search: '1111 2222 3333',
+      languageOneOf: [ 'pl', 'fr' ],
+      durationMax: 4,
+      nsfw: 'false' as 'false',
+      licenceOneOf: [ 1, 4 ],
+      sort: '-name',
+      start: 3,
+      count: 1
+    }
+    const body = await command.advancedVideoSearch({ search: query })
+    expect(body.total).to.equal(4)
+    const videos = body.data
+    expect(videos[0].name).to.equal('1111 2222 3333')
+  })
+  it('Should search on originally published date', async function () {
+    const baseQuery = {
+      search: '1111 2222 3333',
+      languageOneOf: [ 'pl', 'fr' ],
+      durationMax: 4,
+      nsfw: 'false' as 'false',
+      licenceOneOf: [ 1, 4 ]
+    }
+    {
+      const query = { ...baseQuery, originallyPublishedStartDate: '2019-02-11T09:58:08.286Z' }
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('1111 2222 3333 - 7')
+    }
+    {
+      const query = { ...baseQuery, originallyPublishedEndDate: '2019-03-11T09:58:08.286Z' }
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('1111 2222 3333 - 7')
+    }
+    {
+      const query = { ...baseQuery, originallyPublishedEndDate: '2019-01-11T09:58:08.286Z' }
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(0)
+    }
+    {
+      const query = { ...baseQuery, originallyPublishedStartDate: '2019-03-11T09:58:08.286Z' }
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(0)
+    }
+    {
+      const query = {
+        ...baseQuery,
+        originallyPublishedStartDate: '2019-01-11T09:58:08.286Z',
+        originallyPublishedEndDate: '2019-01-10T09:58:08.286Z'
+      }
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(0)
+    }
+    {
+      const query = {
+        ...baseQuery,
+        originallyPublishedStartDate: '2019-01-11T09:58:08.286Z',
+        originallyPublishedEndDate: '2019-04-11T09:58:08.286Z'
+      }
+      const body = await command.advancedVideoSearch({ search: query })
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('1111 2222 3333 - 7')
+    }
+  })
+  it('Should search by UUID', async function () {
+    const search = videoUUID
+    const body = await command.advancedVideoSearch({ search: { search } })
+    expect(body.total).to.equal(1)
+    expect(body.data[0].name).to.equal('1111 2222 3333 - 3')
+  })
+  it('Should filter by UUIDs', async function () {
+    for (const uuid of [ videoUUID, videoShortUUID ]) {
+      const body = await command.advancedVideoSearch({ search: { uuids: [ uuid ] } })
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('1111 2222 3333 - 3')
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: { uuids: [ 'dfd70b83-639f-4980-94af-304a56ab4b35' ] } })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    }
+  })
+  it('Should search by host', async function () {
+    {
+      const body = await command.advancedVideoSearch({ search: { search: '6666 7777 8888', host: server.host } })
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('6666 7777 8888')
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: { search: '1111', host: 'example.com' } })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: { search: 'remote', host: remoteServer.host } })
+      expect(body.total).to.equal(2)
+      expect(body.data).to.have.lengthOf(2)
+      expect(body.data[0].name).to.equal('remote video 1')
+      expect(body.data[1].name).to.equal('remote video 2')
+    }
+  })
+  it('Should search by live', async function () {
+    this.timeout(120000)
+    {
+      const newConfig = {
+        search: {
+          searchIndex: { enabled: false }
+        },
+        live: { enabled: true }
+      }
+      await server.config.updateCustomSubConfig({ newConfig })
+    }
+    {
+      const body = await command.advancedVideoSearch({ search: { isLive: true } })
+      expect(body.total).to.equal(0)
+      expect(body.data).to.have.lengthOf(0)
+    }
+    {
+      const liveCommand = server.live
+      const liveAttributes = { name: 'live', privacy: VideoPrivacy.PUBLIC, channelId: server.store.channel.id }
+      const live = await liveCommand.create({ fields: liveAttributes })
+      const ffmpegCommand = await liveCommand.sendRTMPStreamInVideo({ videoId: live.id })
+      await liveCommand.waitUntilPublished({ videoId: live.id })
+      const body = await command.advancedVideoSearch({ search: { isLive: true } })
+      expect(body.total).to.equal(1)
+      expect(body.data[0].name).to.equal('live')
+      await stopFfmpeg(ffmpegCommand)
+    }
+  })
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})