-import 'mocha'
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
import { expect } from 'chai'
-import { FIXTURE_URLS } from '@server/tests/shared'
+import { FIXTURE_URLS, SQLCommand } from '@server/tests/shared'
import { areHttpImportTestsDisabled } from '@shared/core-utils'
-import { HttpStatusCode, VideoChannelSyncState, VideoInclude, VideoPrivacy } from '@shared/models'
+import { VideoChannelSyncState, VideoInclude, VideoPrivacy } from '@shared/models'
import {
- ChannelSyncsCommand,
- createSingleServer,
+ cleanupTests,
+ createMultipleServers,
getServerImportConfig,
PeerTubeServer,
setAccessTokensToServers,
function runSuite (mode: 'youtube-dl' | 'yt-dlp') {
describe('Sync using ' + mode, function () {
- let server: PeerTubeServer
- let command: ChannelSyncsCommand
+ let servers: PeerTubeServer[]
+ let sqlCommands: SQLCommand[]
let startTestDate: Date
}
async function changeDateForSync (channelSyncId: number, newDate: string) {
- await server.sql.updateQuery(
+ await sqlCommands[0].updateQuery(
`UPDATE "videoChannelSync" ` +
`SET "createdAt"='${newDate}', "lastSyncAt"='${newDate}' ` +
`WHERE id=${channelSyncId}`
)
}
+ async function listAllVideosOfChannel (channelName: string) {
+ return servers[0].videos.listByChannel({
+ handle: channelName,
+ include: VideoInclude.NOT_PUBLISHED_STATE
+ })
+ }
+
+ async function forceSyncAll (videoChannelSyncId: number, fromDate = '1970-01-01') {
+ await changeDateForSync(videoChannelSyncId, fromDate)
+
+ await servers[0].debug.sendCommand({
+ body: {
+ command: 'process-video-channel-sync-latest'
+ }
+ })
+
+ await waitJobs(servers)
+ }
+
before(async function () {
- this.timeout(120_000)
+ this.timeout(240_000)
startTestDate = new Date()
- server = await createSingleServer(1, getServerImportConfig(mode))
+ servers = await createMultipleServers(2, getServerImportConfig(mode))
- await setAccessTokensToServers([ server ])
- await setDefaultVideoChannel([ server ])
- await setDefaultChannelAvatar([ server ])
- await setDefaultAccountAvatar([ server ])
+ await setAccessTokensToServers(servers)
+ await setDefaultVideoChannel(servers)
+ await setDefaultChannelAvatar(servers)
+ await setDefaultAccountAvatar(servers)
- await server.config.enableChannelSync()
-
- command = server.channelSyncs
+ await servers[0].config.enableChannelSync()
{
- userInfo.accessToken = await server.users.generateUserAndToken(userInfo.username)
+ userInfo.accessToken = await servers[0].users.generateUserAndToken(userInfo.username)
- const { videoChannels } = await server.users.getMyInfo({ token: userInfo.accessToken })
+ const { videoChannels } = await servers[0].users.getMyInfo({ token: userInfo.accessToken })
userInfo.channelId = videoChannels[0].id
}
+
+ sqlCommands = servers.map(s => new SQLCommand(s))
})
it('Should fetch the latest channel videos of a remote channel', async function () {
this.timeout(120_000)
{
- const { video } = await server.imports.importVideo({
+ const { video } = await servers[0].imports.importVideo({
attributes: {
- channelId: server.store.channel.id,
+ channelId: servers[0].store.channel.id,
privacy: VideoPrivacy.PUBLIC,
targetUrl: FIXTURE_URLS.youtube
}
})
expect(video.name).to.equal('small video - youtube')
+ expect(video.waitTranscoding).to.be.true
- const { total } = await server.videos.listByChannel({ handle: 'root_channel', include: VideoInclude.NOT_PUBLISHED_STATE })
+ const { total } = await listAllVideosOfChannel('root_channel')
expect(total).to.equal(1)
}
- const { videoChannelSync } = await command.create({
+ const { videoChannelSync } = await servers[0].channelSyncs.create({
attributes: {
externalChannelUrl: FIXTURE_URLS.youtubeChannel,
- videoChannelId: server.store.channel.id
- },
- token: server.accessToken,
- expectedStatus: HttpStatusCode.OK_200
+ videoChannelId: servers[0].store.channel.id
+ }
})
rootChannelSyncId = videoChannelSync.id
- // Ensure any missing video not already fetched will be considered as new
- await changeDateForSync(videoChannelSync.id, '1970-01-01')
-
- await server.debug.sendCommand({
- body: {
- command: 'process-video-channel-sync-latest'
- }
- })
+ await forceSyncAll(rootChannelSyncId)
{
- await waitJobs(server)
-
- const { total, data } = await server.videos.listByChannel({ handle: 'root_channel', include: VideoInclude.NOT_PUBLISHED_STATE })
+ const { total, data } = await listAllVideosOfChannel('root_channel')
expect(total).to.equal(2)
expect(data[0].name).to.equal('test')
+ expect(data[0].waitTranscoding).to.be.true
}
})
it('Should add another synchronization', async function () {
const externalChannelUrl = FIXTURE_URLS.youtubeChannel + '?foo=bar'
- const { videoChannelSync } = await command.create({
+ const { videoChannelSync } = await servers[0].channelSyncs.create({
attributes: {
externalChannelUrl,
- videoChannelId: server.store.channel.id
- },
- token: server.accessToken,
- expectedStatus: HttpStatusCode.OK_200
+ videoChannelId: servers[0].store.channel.id
+ }
})
expect(videoChannelSync.externalChannelUrl).to.equal(externalChannelUrl)
- expect(videoChannelSync.channel).to.include({
- id: server.store.channel.id,
- name: 'root_channel'
- })
+ expect(videoChannelSync.channel.id).to.equal(servers[0].store.channel.id)
+ expect(videoChannelSync.channel.name).to.equal('root_channel')
expect(videoChannelSync.state.id).to.equal(VideoChannelSyncState.WAITING_FIRST_RUN)
expect(new Date(videoChannelSync.createdAt)).to.be.above(startTestDate).and.to.be.at.most(new Date())
})
it('Should add a synchronization for another user', async function () {
- const { videoChannelSync } = await command.create({
+ const { videoChannelSync } = await servers[0].channelSyncs.create({
attributes: {
externalChannelUrl: FIXTURE_URLS.youtubeChannel + '?baz=qux',
videoChannelId: userInfo.channelId
})
it('Should not import a channel if not asked', async function () {
- await waitJobs(server)
+ await waitJobs(servers)
- const { data } = await command.listByAccount({ accountName: userInfo.username })
+ const { data } = await servers[0].channelSyncs.listByAccount({ accountName: userInfo.username })
expect(data[0].state).to.contain({
id: VideoChannelSyncState.WAITING_FIRST_RUN,
it('Should only fetch the videos newer than the creation date', async function () {
this.timeout(120_000)
- await changeDateForSync(userInfo.syncId, '2019-03-01')
+ await forceSyncAll(userInfo.syncId, '2019-03-01')
- await server.debug.sendCommand({
- body: {
- command: 'process-video-channel-sync-latest'
- }
- })
-
- await waitJobs(server)
-
- const { data, total } = await server.videos.listByChannel({
- handle: userInfo.channelName,
- include: VideoInclude.NOT_PUBLISHED_STATE
- })
+ const { data, total } = await listAllVideosOfChannel(userInfo.channelName)
expect(total).to.equal(1)
expect(data[0].name).to.equal('test')
it('Should list channel synchronizations', async function () {
// Root
{
- const { total, data } = await command.listByAccount({ accountName: 'root' })
+ const { total, data } = await servers[0].channelSyncs.listByAccount({ accountName: 'root' })
expect(total).to.equal(2)
expect(data[0]).to.deep.contain({
expect(new Date(data[0].lastSyncAt)).to.be.greaterThan(startTestDate)
- expect(data[0].channel).to.contain({ id: server.store.channel.id })
+ expect(data[0].channel).to.contain({ id: servers[0].store.channel.id })
expect(data[1]).to.contain({ externalChannelUrl: FIXTURE_URLS.youtubeChannel + '?foo=bar' })
}
// User
{
- const { total, data } = await command.listByAccount({ accountName: userInfo.username })
+ const { total, data } = await servers[0].channelSyncs.listByAccount({ accountName: userInfo.username })
expect(total).to.equal(1)
expect(data[0]).to.deep.contain({
externalChannelUrl: FIXTURE_URLS.youtubeChannel + '?baz=qux',
})
it('Should list imports of a channel synchronization', async function () {
- const { total, data } = await server.imports.getMyVideoImports({ videoChannelSyncId: rootChannelSyncId })
+ const { total, data } = await servers[0].imports.getMyVideoImports({ videoChannelSyncId: rootChannelSyncId })
expect(total).to.equal(1)
expect(data).to.have.lengthOf(1)
})
it('Should remove user\'s channel synchronizations', async function () {
- await command.delete({ channelSyncId: userInfo.syncId })
+ await servers[0].channelSyncs.delete({ channelSyncId: userInfo.syncId })
- const { total } = await command.listByAccount({ accountName: userInfo.username })
+ const { total } = await servers[0].channelSyncs.listByAccount({ accountName: userInfo.username })
expect(total).to.equal(0)
})
+ // FIXME: youtube-dl/yt-dlp doesn't work when speicifying a port after the hostname
+ // it('Should import a remote PeerTube channel', async function () {
+ // this.timeout(240_000)
+
+ // await servers[1].videos.quickUpload({ name: 'remote 1' })
+ // await waitJobs(servers)
+
+ // const { videoChannelSync } = await servers[0].channelSyncs.create({
+ // attributes: {
+ // externalChannelUrl: servers[1].url + '/c/root_channel',
+ // videoChannelId: userInfo.channelId
+ // },
+ // token: userInfo.accessToken
+ // })
+ // await servers[0].channels.importVideos({
+ // channelName: userInfo.channelName,
+ // externalChannelUrl: servers[1].url + '/c/root_channel',
+ // videoChannelSyncId: videoChannelSync.id,
+ // token: userInfo.accessToken
+ // })
+
+ // await waitJobs(servers)
+
+ // const { data, total } = await servers[0].videos.listByChannel({
+ // handle: userInfo.channelName,
+ // include: VideoInclude.NOT_PUBLISHED_STATE
+ // })
+
+ // expect(total).to.equal(2)
+ // expect(data[0].name).to.equal('remote 1')
+ // })
+
+ // it('Should keep synced a remote PeerTube channel', async function () {
+ // this.timeout(240_000)
+
+ // await servers[1].videos.quickUpload({ name: 'remote 2' })
+ // await waitJobs(servers)
+
+ // await servers[0].debug.sendCommand({
+ // body: {
+ // command: 'process-video-channel-sync-latest'
+ // }
+ // })
+
+ // await waitJobs(servers)
+
+ // const { data, total } = await servers[0].videos.listByChannel({
+ // handle: userInfo.channelName,
+ // include: VideoInclude.NOT_PUBLISHED_STATE
+ // })
+ // expect(total).to.equal(2)
+ // expect(data[0].name).to.equal('remote 2')
+ // })
+
+ it('Should fetch the latest videos of a youtube playlist', async function () {
+ this.timeout(120_000)
+
+ const { id: channelId } = await servers[0].channels.create({
+ attributes: {
+ name: 'channel2'
+ }
+ })
+
+ const { videoChannelSync: { id: videoChannelSyncId } } = await servers[0].channelSyncs.create({
+ attributes: {
+ externalChannelUrl: FIXTURE_URLS.youtubePlaylist,
+ videoChannelId: channelId
+ }
+ })
+
+ await forceSyncAll(videoChannelSyncId)
+
+ {
+
+ const { total, data } = await listAllVideosOfChannel('channel2')
+ expect(total).to.equal(2)
+ expect(data[0].name).to.equal('test')
+ expect(data[1].name).to.equal('small video - youtube')
+ }
+ })
+
after(async function () {
- await server?.kill()
+ for (const sqlCommand of sqlCommands) {
+ await sqlCommand.cleanup()
+ }
+
+ await cleanupTests(servers)
})
})
}
- runSuite('youtube-dl')
+ // FIXME: suite is broken with youtube-dl
+ // runSuite('youtube-dl')
runSuite('yt-dlp')
})
projects / github / Chocobozzz / PeerTube.git / blobdiff