mirror of https://github.com/Chocobozzz/PeerTube
643 lines
22 KiB
TypeScript
643 lines
22 KiB
TypeScript
/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
|
|
|
|
import {
|
|
HttpStatusCode,
|
|
LiveVideoLatencyMode,
|
|
UserImportState,
|
|
UserNotificationSettingValue,
|
|
VideoCreateResult,
|
|
VideoPlaylistPrivacy,
|
|
VideoPlaylistType,
|
|
VideoPrivacy,
|
|
VideoState
|
|
} from '@peertube/peertube-models'
|
|
import { areMockObjectStorageTestsDisabled } from '@peertube/peertube-node-utils'
|
|
import {
|
|
ObjectStorageCommand,
|
|
PeerTubeServer,
|
|
cleanupTests,
|
|
waitJobs
|
|
} from '@peertube/peertube-server-commands'
|
|
import { testAvatarSize, testImage } from '@tests/shared/checks.js'
|
|
import { prepareImportExportTests } from '@tests/shared/import-export.js'
|
|
import { MockSmtpServer } from '@tests/shared/mock-servers/index.js'
|
|
import { completeCheckHlsPlaylist } from '@tests/shared/streaming-playlists.js'
|
|
import { completeVideoCheck } from '@tests/shared/videos.js'
|
|
import { expect } from 'chai'
|
|
import { join } from 'path'
|
|
|
|
function runTest (withObjectStorage: boolean) {
|
|
let server: PeerTubeServer
|
|
let remoteServer: PeerTubeServer
|
|
let blockedServer: PeerTubeServer
|
|
|
|
let noahToken: string
|
|
|
|
let noahId: number
|
|
|
|
const emails: object[] = []
|
|
|
|
let externalVideo: VideoCreateResult
|
|
let noahVideo: VideoCreateResult
|
|
let mouskaVideo: VideoCreateResult
|
|
|
|
let remoteNoahToken: string
|
|
let remoteNoahId: number
|
|
|
|
let archivePath: string
|
|
|
|
let objectStorage: ObjectStorageCommand
|
|
|
|
let latestImportId: number
|
|
|
|
before(async function () {
|
|
this.timeout(240000)
|
|
|
|
objectStorage = withObjectStorage
|
|
? new ObjectStorageCommand()
|
|
: undefined;
|
|
|
|
({
|
|
noahId,
|
|
externalVideo,
|
|
noahVideo,
|
|
noahToken,
|
|
server,
|
|
remoteNoahId,
|
|
remoteNoahToken,
|
|
remoteServer,
|
|
mouskaVideo,
|
|
blockedServer
|
|
} = await prepareImportExportTests({ emails, objectStorage, withBlockedServer: true }))
|
|
|
|
await blockedServer.videos.quickUpload({ name: 'blocked video' })
|
|
await waitJobs([ blockedServer ])
|
|
|
|
// Also add some blocks
|
|
const blocks = [
|
|
{ account: 'mouska' },
|
|
{ account: 'root@' + blockedServer.host },
|
|
{ server: blockedServer.host }
|
|
]
|
|
|
|
for (const toBlock of blocks) {
|
|
await server.blocklist.addToMyBlocklist({ token: noahToken, ...toBlock })
|
|
}
|
|
|
|
// Add avatars
|
|
await server.users.updateMyAvatar({ token: noahToken, fixture: 'avatar.png' })
|
|
|
|
// Add password protected video
|
|
await server.videos.upload({
|
|
token: noahToken,
|
|
attributes: {
|
|
name: 'noah password video',
|
|
privacy: VideoPrivacy.PASSWORD_PROTECTED,
|
|
videoPasswords: [ 'password1', 'password2' ]
|
|
}
|
|
})
|
|
|
|
// Add a video in watch later playlist
|
|
await server.playlists.addElement({
|
|
playlistId: (await server.playlists.getWatchLater({ token: noahToken, handle: 'noah' })).id,
|
|
attributes: { videoId: noahVideo.uuid }
|
|
})
|
|
|
|
await remoteServer.playlists.addElement({
|
|
playlistId: (await remoteServer.playlists.getWatchLater({ token: remoteNoahToken, handle: 'noah_remote' })).id,
|
|
attributes: { videoId: mouskaVideo.uuid }
|
|
})
|
|
|
|
await waitJobs([ server, remoteServer, blockedServer ])
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
await server.userExports.request({ userId: noahId, withVideoFiles: true })
|
|
await server.userExports.waitForCreation({ userId: noahId })
|
|
|
|
archivePath = join(server.getDirectoryPath('tmp'), 'archive.zip')
|
|
await server.userExports.downloadLatestArchive({ userId: noahId, destination: archivePath })
|
|
})
|
|
|
|
it('Should import an archive with video files', async function () {
|
|
this.timeout(240000)
|
|
|
|
const { userImport } = await remoteServer.userImports.importArchive({ fixture: archivePath, userId: remoteNoahId })
|
|
latestImportId = userImport.id
|
|
|
|
await waitJobs([ server, remoteServer ])
|
|
})
|
|
|
|
it('Should have a valid import status', async function () {
|
|
const userImport = await remoteServer.userImports.getLatestImport({ userId: remoteNoahId, token: remoteNoahToken })
|
|
|
|
expect(userImport.id).to.equal(latestImportId)
|
|
expect(userImport.state.id).to.equal(UserImportState.COMPLETED)
|
|
expect(userImport.state.label).to.equal('Completed')
|
|
})
|
|
|
|
it('Should have correctly imported blocklist', async function () {
|
|
{
|
|
const { data } = await remoteServer.blocklist.listMyAccountBlocklist({ start: 0, count: 5, token: remoteNoahToken })
|
|
|
|
expect(data).to.have.lengthOf(2)
|
|
expect(data.find(a => a.blockedAccount.host === server.host && a.blockedAccount.name === 'mouska')).to.exist
|
|
expect(data.find(a => a.blockedAccount.host === blockedServer.host && a.blockedAccount.name === 'root')).to.exist
|
|
}
|
|
|
|
{
|
|
const { data } = await remoteServer.blocklist.listMyServerBlocklist({ start: 0, count: 5, token: remoteNoahToken })
|
|
|
|
expect(data).to.have.lengthOf(1)
|
|
expect(data.find(a => a.blockedServer.host === blockedServer.host)).to.exist
|
|
}
|
|
})
|
|
|
|
it('Should have correctly imported account', async function () {
|
|
const me = await remoteServer.users.getMyInfo({ token: remoteNoahToken })
|
|
|
|
expect(me.account.displayName).to.equal('noah')
|
|
expect(me.username).to.equal('noah_remote')
|
|
expect(me.account.description).to.equal('super noah description')
|
|
expect(me.account.avatars).to.have.lengthOf(4)
|
|
|
|
for (const avatar of me.account.avatars) {
|
|
await testAvatarSize({ url: remoteServer.url, avatar, imageName: `avatar-resized-${avatar.width}x${avatar.width}` })
|
|
}
|
|
})
|
|
|
|
it('Should have correctly imported user settings', async function () {
|
|
{
|
|
const me = await remoteServer.users.getMyInfo({ token: remoteNoahToken })
|
|
|
|
expect(me.p2pEnabled).to.be.false
|
|
|
|
const settings = me.notificationSettings
|
|
|
|
expect(settings.newVideoFromSubscription).to.equal(UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL)
|
|
expect(settings.myVideoPublished).to.equal(UserNotificationSettingValue.NONE)
|
|
expect(settings.commentMention).to.equal(UserNotificationSettingValue.EMAIL)
|
|
}
|
|
})
|
|
|
|
it('Should have correctly imported channels', async function () {
|
|
const { data: channels } = await remoteServer.channels.listByAccount({ token: remoteNoahToken, accountName: 'noah_remote' })
|
|
|
|
// One default + 2 imported
|
|
expect(channels).to.have.lengthOf(3)
|
|
|
|
await remoteServer.channels.get({ token: remoteNoahToken, channelName: 'noah_remote_channel' })
|
|
|
|
const importedMain = await remoteServer.channels.get({ token: remoteNoahToken, channelName: 'noah_channel' })
|
|
expect(importedMain.displayName).to.equal('Main noah channel')
|
|
expect(importedMain.avatars).to.have.lengthOf(0)
|
|
expect(importedMain.banners).to.have.lengthOf(0)
|
|
|
|
const importedSecond = await remoteServer.channels.get({ token: remoteNoahToken, channelName: 'noah_second_channel' })
|
|
expect(importedSecond.displayName).to.equal('noah display name')
|
|
expect(importedSecond.description).to.equal('noah description')
|
|
expect(importedSecond.support).to.equal('noah support')
|
|
|
|
for (const banner of importedSecond.banners) {
|
|
await testImage(remoteServer.url, `banner-user-import-resized-${banner.width}`, banner.path)
|
|
}
|
|
|
|
for (const avatar of importedSecond.avatars) {
|
|
await testImage(remoteServer.url, `avatar-resized-${avatar.width}x${avatar.width}`, avatar.path, '.png')
|
|
}
|
|
|
|
{
|
|
// Also check the correct count on origin server
|
|
const { data: channels } = await server.channels.listByAccount({ accountName: 'noah_remote@' + remoteServer.host })
|
|
expect(channels).to.have.lengthOf(2) // noah_remote_channel doesn't have videos so it has not been federated
|
|
}
|
|
})
|
|
|
|
it('Should have correctly imported following', async function () {
|
|
const { data } = await remoteServer.subscriptions.list({ token: remoteNoahToken })
|
|
|
|
expect(data).to.have.lengthOf(2)
|
|
expect(data.find(f => f.name === 'mouska_channel' && f.host === server.host)).to.exist
|
|
expect(data.find(f => f.name === 'root_channel' && f.host === remoteServer.host)).to.exist
|
|
})
|
|
|
|
it('Should not have reimported followers (it is not a migration)', async function () {
|
|
for (const checkServer of [ server, remoteServer ]) {
|
|
const { data } = await checkServer.channels.listFollowers({ channelName: 'noah_channel@' + remoteServer.host })
|
|
|
|
expect(data).to.have.lengthOf(0)
|
|
}
|
|
})
|
|
|
|
it('Should not have imported comments (it is not a migration)', async function () {
|
|
for (const checkServer of [ server, remoteServer ]) {
|
|
{
|
|
const threads = await checkServer.comments.listThreads({ videoId: noahVideo.uuid })
|
|
expect(threads.total).to.equal(2)
|
|
}
|
|
|
|
{
|
|
const threads = await checkServer.comments.listThreads({ videoId: mouskaVideo.uuid })
|
|
expect(threads.total).to.equal(1)
|
|
}
|
|
}
|
|
})
|
|
|
|
it('Should have correctly imported likes/dislikes', async function () {
|
|
{
|
|
const { rating } = await remoteServer.users.getMyRating({ videoId: mouskaVideo.uuid, token: remoteNoahToken })
|
|
expect(rating).to.equal('like')
|
|
|
|
for (const checkServer of [ server, remoteServer ]) {
|
|
const video = await checkServer.videos.get({ id: mouskaVideo.uuid })
|
|
expect(video.likes).to.equal(2) // Old account + new account rates
|
|
expect(video.dislikes).to.equal(0)
|
|
}
|
|
}
|
|
|
|
{
|
|
const { rating } = await remoteServer.users.getMyRating({ videoId: noahVideo.uuid, token: remoteNoahToken })
|
|
expect(rating).to.equal('like')
|
|
}
|
|
|
|
{
|
|
const { rating } = await remoteServer.users.getMyRating({ videoId: externalVideo.uuid, token: remoteNoahToken })
|
|
expect(rating).to.equal('dislike')
|
|
}
|
|
})
|
|
|
|
it('Should have correctly imported user video playlists', async function () {
|
|
const { data } = await remoteServer.playlists.listByAccount({ handle: 'noah_remote', token: remoteNoahToken })
|
|
|
|
// Should merge the watch later playlists
|
|
expect(data).to.have.lengthOf(3)
|
|
|
|
{
|
|
const watchLater = data.find(p => p.type.id === VideoPlaylistType.WATCH_LATER)
|
|
expect(watchLater).to.exist
|
|
expect(watchLater.privacy.id).to.equal(VideoPlaylistPrivacy.PRIVATE)
|
|
|
|
// Playlists were merged
|
|
expect(watchLater.videosLength).to.equal(2)
|
|
|
|
const { data: videos } = await remoteServer.playlists.listVideos({ playlistId: watchLater.id, token: remoteNoahToken })
|
|
|
|
expect(videos[0].position).to.equal(1)
|
|
// Mouska is muted
|
|
expect(videos[0].video).to.not.exist
|
|
expect(videos[1].position).to.equal(2)
|
|
expect(videos[1].video.uuid).to.equal(noahVideo.uuid)
|
|
|
|
// Not federated
|
|
await server.playlists.get({ playlistId: watchLater.uuid, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
|
|
}
|
|
|
|
{
|
|
const playlist1 = data.find(p => p.displayName === 'noah playlist 1')
|
|
expect(playlist1).to.exist
|
|
|
|
expect(playlist1.privacy.id).to.equal(VideoPlaylistPrivacy.PUBLIC)
|
|
expect(playlist1.videosLength).to.equal(2) // 1 private video could not be imported
|
|
|
|
const { data: videos } = await remoteServer.playlists.listVideos({ playlistId: playlist1.id, token: remoteNoahToken })
|
|
expect(videos[0].position).to.equal(1)
|
|
expect(videos[0].startTimestamp).to.equal(2)
|
|
expect(videos[0].stopTimestamp).to.equal(3)
|
|
expect(videos[0].video).to.not.exist // Mouska is blocked
|
|
|
|
expect(videos[1].position).to.equal(2)
|
|
expect(videos[1].video.uuid).to.equal(noahVideo.uuid)
|
|
|
|
// Federated
|
|
await server.playlists.get({ playlistId: playlist1.uuid })
|
|
}
|
|
|
|
{
|
|
const playlist2 = data.find(p => p.displayName === 'noah playlist 2')
|
|
expect(playlist2).to.exist
|
|
|
|
expect(playlist2.privacy.id).to.equal(VideoPlaylistPrivacy.PRIVATE)
|
|
expect(playlist2.videosLength).to.equal(0)
|
|
|
|
// Federated
|
|
await server.playlists.get({ playlistId: playlist2.uuid, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
|
|
}
|
|
})
|
|
|
|
it('Should have correctly imported user video history', async function () {
|
|
const { data } = await remoteServer.history.list({ token: remoteNoahToken })
|
|
|
|
expect(data).to.have.lengthOf(2)
|
|
|
|
expect(data[0].userHistory.currentTime).to.equal(2)
|
|
expect(data[0].url).to.equal(remoteServer.url + '/videos/watch/' + externalVideo.uuid)
|
|
|
|
expect(data[1].userHistory.currentTime).to.equal(4)
|
|
expect(data[1].url).to.equal(server.url + '/videos/watch/' + noahVideo.uuid)
|
|
})
|
|
|
|
it('Should have correctly imported user videos', async function () {
|
|
const { data } = await remoteServer.videos.listMyVideos({ token: remoteNoahToken })
|
|
expect(data).to.have.lengthOf(5)
|
|
|
|
{
|
|
const privateVideo = data.find(v => v.name === 'noah private video')
|
|
expect(privateVideo).to.exist
|
|
expect(privateVideo.privacy.id).to.equal(VideoPrivacy.PRIVATE)
|
|
|
|
// Not federated
|
|
await server.videos.get({ id: privateVideo.uuid, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
|
|
}
|
|
|
|
{
|
|
const publicVideo = data.find(v => v.name === 'noah public video')
|
|
expect(publicVideo).to.exist
|
|
expect(publicVideo.privacy.id).to.equal(VideoPrivacy.PUBLIC)
|
|
|
|
// Federated
|
|
await server.videos.get({ id: publicVideo.uuid })
|
|
}
|
|
|
|
{
|
|
const passwordVideo = data.find(v => v.name === 'noah password video')
|
|
expect(passwordVideo).to.exist
|
|
expect(passwordVideo.privacy.id).to.equal(VideoPrivacy.PASSWORD_PROTECTED)
|
|
|
|
const { data: passwords } = await remoteServer.videoPasswords.list({ videoId: passwordVideo.uuid })
|
|
expect(passwords.map(p => p.password).sort()).to.deep.equal([ 'password1', 'password2' ])
|
|
|
|
// Not federated
|
|
await server.videos.get({ id: passwordVideo.uuid, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
|
|
}
|
|
|
|
{
|
|
const otherVideo = data.find(v => v.name === 'noah public video second channel')
|
|
expect(otherVideo).to.exist
|
|
|
|
for (const checkServer of [ server, remoteServer ]) {
|
|
await completeVideoCheck({
|
|
server: checkServer,
|
|
originServer: remoteServer,
|
|
videoUUID: otherVideo.uuid,
|
|
objectStorageBaseUrl: objectStorage?.getMockWebVideosBaseUrl(),
|
|
|
|
attributes: {
|
|
name: 'noah public video second channel',
|
|
privacy: (VideoPrivacy.PUBLIC),
|
|
category: (12),
|
|
tags: [ 'tag1', 'tag2' ],
|
|
commentsEnabled: false,
|
|
downloadEnabled: false,
|
|
nsfw: false,
|
|
description: ('video description'),
|
|
support: ('video support'),
|
|
language: 'fr',
|
|
licence: 1,
|
|
originallyPublishedAt: new Date(0).toISOString(),
|
|
account: {
|
|
name: 'noah_remote',
|
|
host: remoteServer.host
|
|
},
|
|
likes: 0,
|
|
dislikes: 0,
|
|
duration: 5,
|
|
channel: {
|
|
displayName: 'noah display name',
|
|
name: 'noah_second_channel',
|
|
description: 'noah description'
|
|
},
|
|
fixture: 'video_short.webm',
|
|
files: [
|
|
{
|
|
resolution: 720,
|
|
height: 720,
|
|
width: 1280,
|
|
size: 61000
|
|
},
|
|
{
|
|
resolution: 240,
|
|
height: 240,
|
|
width: 426,
|
|
size: 23000
|
|
}
|
|
],
|
|
thumbnailfile: 'custom-thumbnail-from-preview',
|
|
previewfile: 'custom-preview'
|
|
}
|
|
})
|
|
}
|
|
|
|
await completeCheckHlsPlaylist({
|
|
hlsOnly: false,
|
|
servers: [ remoteServer, server ],
|
|
videoUUID: otherVideo.uuid,
|
|
objectStorageBaseUrl: objectStorage?.getMockPlaylistBaseUrl(),
|
|
resolutions: [ 720, 240 ]
|
|
})
|
|
|
|
const source = await remoteServer.videos.getSource({ id: otherVideo.uuid })
|
|
expect(source.filename).to.equal('video_short.webm')
|
|
expect(source.inputFilename).to.equal('video_short.webm')
|
|
expect(source.fileDownloadUrl).to.not.exist
|
|
|
|
expect(source.metadata?.format).to.exist
|
|
expect(source.metadata?.streams).to.be.an('array')
|
|
}
|
|
|
|
{
|
|
const liveVideo = data.find(v => v.name === 'noah live video')
|
|
expect(liveVideo).to.exist
|
|
|
|
await remoteServer.videos.get({ id: liveVideo.uuid, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
|
|
const video = await remoteServer.videos.getWithPassword({ id: liveVideo.uuid, password: 'password1' })
|
|
const live = await remoteServer.live.get({ videoId: liveVideo.uuid, token: remoteNoahToken })
|
|
|
|
expect(video.isLive).to.be.true
|
|
expect(live.latencyMode).to.equal(LiveVideoLatencyMode.SMALL_LATENCY)
|
|
expect(live.saveReplay).to.be.true
|
|
expect(live.permanentLive).to.be.true
|
|
expect(live.streamKey).to.exist
|
|
expect(live.replaySettings.privacy).to.equal(VideoPrivacy.PUBLIC)
|
|
|
|
expect(video.channel.name).to.equal('noah_second_channel')
|
|
expect(video.privacy.id).to.equal(VideoPrivacy.PASSWORD_PROTECTED)
|
|
|
|
expect(video.duration).to.equal(0)
|
|
expect(video.files).to.have.lengthOf(0)
|
|
expect(video.streamingPlaylists).to.have.lengthOf(0)
|
|
|
|
expect(video.state.id).to.equal(VideoState.WAITING_FOR_LIVE)
|
|
}
|
|
})
|
|
|
|
it('Should re-import the same file', async function () {
|
|
this.timeout(240000)
|
|
|
|
const { userImport } = await remoteServer.userImports.importArchive({ fixture: archivePath, userId: remoteNoahId })
|
|
await waitJobs([ remoteServer ])
|
|
latestImportId = userImport.id
|
|
})
|
|
|
|
it('Should have the status of this new reimport', async function () {
|
|
const userImport = await remoteServer.userImports.getLatestImport({ userId: remoteNoahId, token: remoteNoahToken })
|
|
|
|
expect(userImport.id).to.equal(latestImportId)
|
|
expect(userImport.state.id).to.equal(UserImportState.COMPLETED)
|
|
expect(userImport.state.label).to.equal('Completed')
|
|
})
|
|
|
|
it('Should not have duplicated data', async function () {
|
|
// Blocklist
|
|
{
|
|
{
|
|
const { data } = await remoteServer.blocklist.listMyAccountBlocklist({ start: 0, count: 5, token: remoteNoahToken })
|
|
expect(data).to.have.lengthOf(2)
|
|
}
|
|
|
|
{
|
|
const { data } = await remoteServer.blocklist.listMyServerBlocklist({ start: 0, count: 5, token: remoteNoahToken })
|
|
expect(data).to.have.lengthOf(1)
|
|
}
|
|
}
|
|
|
|
// My avatars
|
|
{
|
|
const me = await remoteServer.users.getMyInfo({ token: remoteNoahToken })
|
|
expect(me.account.avatars).to.have.lengthOf(4)
|
|
}
|
|
|
|
// Channels
|
|
{
|
|
const { data: channels } = await remoteServer.channels.listByAccount({ token: remoteNoahToken, accountName: 'noah_remote' })
|
|
expect(channels).to.have.lengthOf(3)
|
|
}
|
|
|
|
// Following
|
|
{
|
|
const { data } = await remoteServer.subscriptions.list({ token: remoteNoahToken })
|
|
expect(data).to.have.lengthOf(2)
|
|
}
|
|
|
|
// Likes/dislikes
|
|
{
|
|
const video = await remoteServer.videos.get({ id: mouskaVideo.uuid })
|
|
expect(video.likes).to.equal(2)
|
|
expect(video.dislikes).to.equal(0)
|
|
|
|
const { rating } = await remoteServer.users.getMyRating({ videoId: mouskaVideo.uuid, token: remoteNoahToken })
|
|
expect(rating).to.equal('like')
|
|
}
|
|
|
|
// Playlists
|
|
{
|
|
const { data } = await remoteServer.playlists.listByAccount({ handle: 'noah_remote', token: remoteNoahToken })
|
|
expect(data).to.have.lengthOf(3)
|
|
}
|
|
|
|
// Videos
|
|
{
|
|
const { data } = await remoteServer.videos.listMyVideos({ token: remoteNoahToken })
|
|
expect(data).to.have.lengthOf(5)
|
|
}
|
|
})
|
|
|
|
it('Should have received an email on finished import', async function () {
|
|
const email = emails.reverse().find(e => {
|
|
return e['to'][0]['address'] === 'noah_remote@example.com' &&
|
|
e['subject'].includes('archive import has finished')
|
|
})
|
|
|
|
expect(email).to.exist
|
|
expect(email['text']).to.contain('as considered duplicate: 5') // 5 videos are considered as duplicates
|
|
})
|
|
|
|
it('Should auto blacklist imported videos if enabled by the administrator', async function () {
|
|
this.timeout(240000)
|
|
|
|
await blockedServer.config.enableAutoBlacklist()
|
|
|
|
const { token, userId } = await blockedServer.users.generate('blocked_user')
|
|
await blockedServer.userImports.importArchive({ fixture: archivePath, userId, token })
|
|
await waitJobs([ blockedServer ])
|
|
|
|
{
|
|
const { data } = await blockedServer.videos.listMyVideos({ token })
|
|
expect(data).to.have.lengthOf(5)
|
|
|
|
for (const video of data) {
|
|
expect(video.blacklisted).to.be.true
|
|
}
|
|
}
|
|
})
|
|
|
|
it('Should import original file if included in the export', async function () {
|
|
this.timeout(120000)
|
|
|
|
await server.config.enableMinimumTranscoding({ keepOriginal: true })
|
|
await remoteServer.config.keepSourceFile()
|
|
|
|
const archivePath = join(server.getDirectoryPath('tmp'), 'archive2.zip')
|
|
const fixture = 'video_short1.webm'
|
|
|
|
{
|
|
const { token, userId } = await server.users.generate('claire')
|
|
|
|
await server.videos.quickUpload({ name: 'claire video', token, fixture })
|
|
|
|
await waitJobs([ server ])
|
|
|
|
await server.userExports.request({ userId, token, withVideoFiles: true })
|
|
await server.userExports.waitForCreation({ userId, token })
|
|
|
|
await server.userExports.downloadLatestArchive({ userId, token, destination: archivePath })
|
|
}
|
|
|
|
{
|
|
const { token, userId } = await remoteServer.users.generate('external_claire')
|
|
|
|
await remoteServer.userImports.importArchive({ fixture: archivePath, userId, token })
|
|
await waitJobs([ remoteServer ])
|
|
|
|
{
|
|
const { data } = await remoteServer.videos.listMyVideos({ token })
|
|
expect(data).to.have.lengthOf(1)
|
|
|
|
const source = await remoteServer.videos.getSource({ id: data[0].id })
|
|
expect(source.filename).to.equal(fixture)
|
|
expect(source.inputFilename).to.equal(fixture)
|
|
expect(source.fileDownloadUrl).to.exist
|
|
|
|
expect(source.metadata?.format).to.exist
|
|
expect(source.metadata?.streams).to.be.an('array')
|
|
expect(source.metadata.format['format_name']).to.include('webm')
|
|
|
|
expect(source.createdAt).to.exist
|
|
expect(source.fps).to.equal(25)
|
|
expect(source.height).to.equal(720)
|
|
expect(source.width).to.equal(1280)
|
|
expect(source.resolution.id).to.equal(720)
|
|
expect(source.size).to.equal(572456)
|
|
}
|
|
}
|
|
})
|
|
|
|
after(async function () {
|
|
MockSmtpServer.Instance.kill()
|
|
|
|
await cleanupTests([ server, remoteServer, blockedServer ])
|
|
})
|
|
}
|
|
|
|
describe('Test user import', function () {
|
|
|
|
describe('From filesystem', function () {
|
|
runTest(false)
|
|
})
|
|
|
|
describe('From object storage', function () {
|
|
if (areMockObjectStorageTestsDisabled()) return
|
|
|
|
runTest(true)
|
|
})
|
|
})
|