import * as autocannon from 'autocannon'
import { writeJson } from 'fs-extra'
-import { flushAndRunServer, killallServers, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
+import { createSingleServer, killallServers, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
import { Video, VideoPrivacy } from '@shared/models'
import { registerTSPaths } from '../server/helpers/register-ts-paths'
registerTSPaths()
-let server: ServerInfo
+let server: PeerTubeServer
let video: Video
let threadId: number
}
async function prepare () {
- server = await flushAndRunServer(1, {
+ server = await createSingleServer(1, {
rates_limit: {
api: {
max: 5_000_000
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
wait,
waitJobs
const expect = chai.expect
describe('Test AP cleaner', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let videoUUID1: string
let videoUUID2: string
let videoUUID3: string
videos: { cleanup_remote_interactions: true }
}
}
- servers = await flushAndRunMultipleServers(3, config)
+ servers = await createMultipleServers(3, config)
// Get the access tokens
await setAccessTokensToServers(servers)
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
makeActivityPubGetRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel
} from '@shared/extra-utils'
const expect = chai.expect
describe('Test activitypub', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let video: { id: number, uuid: string, shortUUID: string }
let playlist: { id: number, uuid: string, shortUUID: string }
before(async function () {
this.timeout(30000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
await setDefaultVideoChannel(servers)
import 'mocha'
import * as chai from 'chai'
-import { cleanupTests, doubleFollow, flushAndRunMultipleServers, ServerInfo, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
+import { cleanupTests, doubleFollow, createMultipleServers, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
const expect = chai.expect
describe('Test ActivityPub fetcher', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
// ---------------------------------------------------------------
before(async function () {
this.timeout(60000)
- servers = await flushAndRunMultipleServers(3)
+ servers = await createMultipleServers(3)
// Get the access tokens
await setAccessTokensToServers(servers)
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
killallServers,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
wait,
import { VideoPlaylistPrivacy } from '@shared/models'
describe('Test AP refresher', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let videoUUID1: string
let videoUUID2: string
let videoUUID3: string
before(async function () {
this.timeout(60000)
- servers = await flushAndRunMultipleServers(2, { transcoding: { enabled: false } })
+ servers = await createMultipleServers(2, { transcoding: { enabled: false } })
// Get the access tokens
await setAccessTokensToServers(servers)
// The refresh should fail
await waitJobs([ servers[0] ])
- await reRunServer(servers[1])
+ await servers[1].run()
await servers[0].videos.get({ id: videoUUID3 })
})
import {
buildAbsoluteFixturePath,
cleanupTests,
- flushAndRunMultipleServers,
+ createMultipleServers,
killallServers,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
wait
} from '../../../../shared/extra-utils'
import { makeFollowRequest, makePOSTAPRequest } from '../../../../shared/extra-utils/requests/activitypub'
const expect = chai.expect
-function setKeysOfServer (onServer: ServerInfo, ofServer: ServerInfo, publicKey: string, privateKey: string) {
+function setKeysOfServer (onServer: PeerTubeServer, ofServer: PeerTubeServer, publicKey: string, privateKey: string) {
const url = 'http://localhost:' + ofServer.port + '/accounts/peertube'
return Promise.all([
])
}
-function setUpdatedAtOfServer (onServer: ServerInfo, ofServer: ServerInfo, updatedAt: string) {
+function setUpdatedAtOfServer (onServer: PeerTubeServer, ofServer: PeerTubeServer, updatedAt: string) {
const url = 'http://localhost:' + ofServer.port + '/accounts/peertube'
return Promise.all([
])
}
-function getAnnounceWithoutContext (server: ServerInfo) {
+function getAnnounceWithoutContext (server: PeerTubeServer) {
const json = require(buildAbsoluteFixturePath('./ap-json/peertube/announce-without-context.json'))
const result: typeof json = {}
}
describe('Test ActivityPub security', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let url: string
const keys = require(buildAbsoluteFixturePath('./ap-json/peertube/keys.json'))
before(async function () {
this.timeout(60000)
- servers = await flushAndRunMultipleServers(3)
+ servers = await createMultipleServers(3)
url = servers[0].url + '/inbox'
// Invalid peertube actor cache
await killallServers([ servers[1] ])
- await reRunServer(servers[1])
+ await servers[1].run()
const body = activityPubContextify(getAnnounceWithoutContext(servers[1]))
const headers = buildGlobalHeaders(body)
checkBadStartPagination,
cleanupTests,
doubleFollow,
- flushAndRunServer,
+ createSingleServer,
makeGetRequest,
makePostBodyRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '@shared/extra-utils'
describe('Test abuses API validators', function () {
const basePath = '/api/v1/abuses/'
- let server: ServerInfo
+ let server: PeerTubeServer
let userToken = ''
let userToken2 = ''
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
describe('When trying to manage messages of a remote abuse', function () {
let remoteAbuseId: number
- let anotherServer: ServerInfo
+ let anotherServer: PeerTubeServer
before(async function () {
this.timeout(50000)
- anotherServer = await flushAndRunServer(2)
+ anotherServer = await createSingleServer(2)
await setAccessTokensToServers([ anotherServer ])
await doubleFollow(anotherServer, server)
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- flushAndRunServer,
- ServerInfo
+ createSingleServer,
+ PeerTubeServer
} from '@shared/extra-utils'
describe('Test accounts API validators', function () {
const path = '/api/v1/accounts/'
- let server: ServerInfo
+ let server: PeerTubeServer
// ---------------------------------------------------------------
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
})
describe('When listing accounts', function () {
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
makeDeleteRequest,
makeGetRequest,
makePostBodyRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '../../../../shared/extra-utils'
import {
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
describe('Test blocklist API validators', function () {
- let servers: ServerInfo[]
- let server: ServerInfo
+ let servers: PeerTubeServer[]
+ let server: PeerTubeServer
let userAccessToken: string
before(async function () {
this.timeout(60000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
server = servers[0]
import 'mocha'
import {
cleanupTests,
- flushAndRunServer,
- ServerInfo,
+ createSingleServer,
+ PeerTubeServer,
setAccessTokensToServers
} from '../../../../shared/extra-utils'
import { makePostBodyRequest } from '../../../../shared/extra-utils/requests/requests'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
describe('Test bulk API validators', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken: string
// ---------------------------------------------------------------
before(async function () {
this.timeout(120000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
const user = { username: 'user1', password: 'password' }
import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeDeleteRequest,
makeGetRequest,
makePutBodyRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '@shared/extra-utils'
import { CustomConfig } from '@shared/models'
describe('Test config API validators', function () {
const path = '/api/v1/config/custom'
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken: string
const updateParams: CustomConfig = {
instance: {
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
import 'mocha'
import { HttpStatusCode } from '@shared/core-utils'
-import { cleanupTests, flushAndRunServer, killallServers, MockSmtpServer, reRunServer, ServerInfo } from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, killallServers, MockSmtpServer, PeerTubeServer } from '@shared/extra-utils'
import { ContactFormCommand } from '@shared/extra-utils/server'
describe('Test contact form API validators', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
const emails: object[] = []
const defaultBody = {
fromName: 'super name',
emailPort = await MockSmtpServer.Instance.collectEmails(emails)
// Email is disabled
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
command = server.contactForm
})
await killallServers([ server ])
// Contact form is disabled
- await reRunServer(server, { smtp: { hostname: 'localhost', port: emailPort }, contact_form: { enabled: false } })
+ await server.run({ smtp: { hostname: 'localhost', port: emailPort }, contact_form: { enabled: false } })
await command.send({ ...defaultBody, expectedStatus: HttpStatusCode.CONFLICT_409 })
})
await killallServers([ server ])
// Email & contact form enabled
- await reRunServer(server, { smtp: { hostname: 'localhost', port: emailPort } })
+ await server.run({ smtp: { hostname: 'localhost', port: emailPort } })
await command.send({ ...defaultBody, fromEmail: 'badEmail', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
await command.send({ ...defaultBody, fromEmail: 'badEmail@', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
import {
cleanupTests,
- flushAndRunServer,
- ServerInfo,
+ createSingleServer,
+ PeerTubeServer,
setAccessTokensToServers
} from '../../../../shared/extra-utils'
import { makeGetRequest, makePutBodyRequest } from '../../../../shared/extra-utils/requests/requests'
describe('Test custom pages validators', function () {
const path = '/api/v1/custom-pages/homepage/instance'
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken: string
// ---------------------------------------------------------------
before(async function () {
this.timeout(120000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
const user = { username: 'user1', password: 'password' }
import {
cleanupTests,
- flushAndRunServer,
- ServerInfo,
+ createSingleServer,
+ PeerTubeServer,
setAccessTokensToServers
} from '../../../../shared/extra-utils'
import { makeGetRequest } from '../../../../shared/extra-utils/requests/requests'
describe('Test debug API validators', function () {
const path = '/api/v1/server/debug'
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken = ''
// ---------------------------------------------------------------
before(async function () {
this.timeout(120000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeDeleteRequest, makeGetRequest,
makePostBodyRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '../../../../shared/extra-utils'
import {
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
describe('Test server follows API validators', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
// ---------------------------------------------------------------
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
})
import {
cleanupTests,
- flushAndRunServer,
- ServerInfo,
+ createSingleServer,
+ PeerTubeServer,
setAccessTokensToServers
} from '../../../../shared/extra-utils'
import {
describe('Test jobs API validators', function () {
const path = '/api/v1/jobs/failed'
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken = ''
// ---------------------------------------------------------------
before(async function () {
this.timeout(120000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
import {
buildAbsoluteFixturePath,
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
LiveCommand,
makePostBodyRequest,
makeUploadRequest,
sendRTMPStream,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
stopFfmpeg
} from '@shared/extra-utils'
describe('Test video lives API validator', function () {
const path = '/api/v1/videos/live'
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken = ''
let channelId: number
let video: VideoCreateResult
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
import {
cleanupTests,
- flushAndRunServer,
- ServerInfo,
+ createSingleServer,
+ PeerTubeServer,
setAccessTokensToServers
} from '../../../../shared/extra-utils'
import { makeGetRequest } from '../../../../shared/extra-utils/requests/requests'
describe('Test logs API validators', function () {
const path = '/api/v1/server/logs'
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken = ''
// ---------------------------------------------------------------
before(async function () {
this.timeout(120000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeGetRequest,
makePostBodyRequest,
makePutBodyRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '@shared/extra-utils'
import { PeerTubePlugin, PluginType } from '@shared/models'
describe('Test server plugins API validators', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken = null
const npmPlugin = 'peertube-plugin-hello-world'
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
checkBadStartPagination,
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
makeDeleteRequest,
makeGetRequest,
makePostBodyRequest,
makePutBodyRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '../../../../shared/extra-utils'
describe('Test server redundancy API validators', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let userAccessToken = null
let videoIdLocal: number
let videoRemote: VideoCreateResult
before(async function () {
this.timeout(80000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
await doubleFollow(servers[0], servers[1])
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeGetRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '@shared/extra-utils'
-function updateSearchIndex (server: ServerInfo, enabled: boolean, disableLocalSearch = false) {
+function updateSearchIndex (server: PeerTubeServer, enabled: boolean, disableLocalSearch = false) {
return server.config.updateCustomSubConfig({
newConfig: {
search: {
}
describe('Test videos API validator', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
// ---------------------------------------------------------------
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
})
import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeGetRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel
} from '@shared/extra-utils'
import { VideoPlaylistPrivacy } from '@shared/models'
describe('Test services API validators', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let playlistUUID: string
// ---------------------------------------------------------------
before(async function () {
this.timeout(60000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await setDefaultVideoChannel([ server ])
})
})
-function checkParamEmbed (server: ServerInfo, embedUrl: string, statusCodeExpected = HttpStatusCode.BAD_REQUEST_400, query = {}) {
+function checkParamEmbed (server: PeerTubeServer, embedUrl: string, statusCodeExpected = HttpStatusCode.BAD_REQUEST_400, query = {}) {
const path = '/services/oembed'
return makeGetRequest({
import { HttpStatusCode, randomInt } from '@shared/core-utils'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
ImportsCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
VideosCommand,
import { VideoImportState, VideoPrivacy } from '@shared/models'
describe('Test upload quota', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let rootId: number
let command: VideosCommand
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await setDefaultVideoChannel([ server ])
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeGetRequest,
makePostBodyRequest,
makePutBodyRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
wait
} from '@shared/extra-utils'
import { UserNotificationSetting, UserNotificationSettingValue } from '@shared/models'
describe('Test user notifications API validators', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
// ---------------------------------------------------------------
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
})
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeDeleteRequest,
makeGetRequest,
makePostBodyRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '../../../../shared/extra-utils'
describe('Test user subscriptions API validators', function () {
const path = '/api/v1/users/me/subscriptions'
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken = ''
// ---------------------------------------------------------------
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
killallServers,
makeGetRequest,
makePostBodyRequest,
makePutBodyRequest,
makeUploadRequest,
MockSmtpServer,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
UsersCommand
} from '@shared/extra-utils'
let rootId: number
let moderatorId: number
let video: VideoCreateResult
- let server: ServerInfo
- let serverWithRegistrationDisabled: ServerInfo
+ let server: PeerTubeServer
+ let serverWithRegistrationDisabled: PeerTubeServer
let userToken = ''
let moderatorToken = ''
let emailPort: number
{
const res = await Promise.all([
- flushAndRunServer(1, overrideConfig),
- flushAndRunServer(2)
+ createSingleServer(1, overrideConfig),
+ createSingleServer(2)
])
server = res[0]
port: emailPort
}
}
- await reRunServer(server, config)
+ await server.run(config)
const fields = {
...baseCorrectParams,
checkBadStartPagination,
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
makePostBodyRequest,
makePutBodyRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '@shared/extra-utils'
import { VideoBlacklistType } from '@shared/models'
describe('Test video blacklist API validators', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let notBlacklistedVideoId: string
let remoteVideoUUID: string
let userAccessToken1 = ''
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
await doubleFollow(servers[0], servers[1])
import {
buildAbsoluteFixturePath,
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeDeleteRequest,
makeGetRequest,
makeUploadRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '@shared/extra-utils'
import { VideoCreateResult } from '@shared/models'
describe('Test video captions API validator', function () {
const path = '/api/v1/videos/'
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken: string
let video: VideoCreateResult
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeGetRequest,
makePostBodyRequest,
makePutBodyRequest,
makeUploadRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '@shared/extra-utils'
import { VideoChannelUpdate } from '@shared/models'
describe('Test video channels API validator', function () {
const videoChannelPath = '/api/v1/video-channels'
- let server: ServerInfo
+ let server: PeerTubeServer
let accessTokenUser: string
let command: ChannelsCommand
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeDeleteRequest,
makeGetRequest,
makePostBodyRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '@shared/extra-utils'
import { VideoCreateResult } from '@shared/models'
describe('Test video comments API validator', function () {
let pathThread: string
let pathComment: string
- let server: ServerInfo
+ let server: PeerTubeServer
let video: VideoCreateResult
let userAccessToken: string
let userAccessToken2: string
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
ImportsCommand,
makeGetRequest,
makePostBodyRequest,
makeUploadRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '@shared/extra-utils'
import { VideoPrivacy } from '@shared/models'
describe('Test video imports API validator', function () {
const path = '/api/v1/videos/imports'
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken = ''
let channelId: number
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
checkBadSortPagination,
checkBadStartPagination,
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeGetRequest,
PlaylistsCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel
} from '@shared/extra-utils'
} from '@shared/models'
describe('Test video playlists API validator', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken: string
let playlist: VideoPlaylistCreateResult
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await setDefaultVideoChannel([ server ])
import 'mocha'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeGetRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel
} from '../../../../shared/extra-utils'
import { UserRole } from '../../../../shared/models/users'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
-async function testEndpoints (server: ServerInfo, token: string, filter: string, statusCodeExpected: HttpStatusCode) {
+async function testEndpoints (server: PeerTubeServer, token: string, filter: string, statusCodeExpected: HttpStatusCode) {
const paths = [
'/api/v1/video-channels/root_channel/videos',
'/api/v1/accounts/root/videos',
}
describe('Test video filters validators', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken: string
let moderatorAccessToken: string
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await setDefaultVideoChannel([ server ])
checkBadCountPagination,
checkBadStartPagination,
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeGetRequest,
makePostBodyRequest,
makePutBodyRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '@shared/extra-utils'
const myHistoryPath = '/api/v1/users/me/history/videos'
const myHistoryRemove = myHistoryPath + '/remove'
let watchingPath: string
- let server: ServerInfo
+ let server: PeerTubeServer
// ---------------------------------------------------------------
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
import 'mocha'
-import { cleanupTests, flushAndRunServer, ServerInfo } from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, PeerTubeServer } from '@shared/extra-utils'
describe('Test videos overview', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
// ---------------------------------------------------------------
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
})
describe('When getting videos overview', function () {
checkBadStartPagination,
checkUploadVideoParam,
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeDeleteRequest,
makeGetRequest,
makePutBodyRequest,
makeUploadRequest,
root,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '@shared/extra-utils'
import { PeerTubeProblemDocument, VideoCreateResult, VideoPrivacy } from '@shared/models'
describe('Test videos API validator', function () {
const path = '/api/v1/videos/'
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken = ''
let accountName: string
let channelId: number
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
cleanupTests,
ConfigCommand,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
wait,
const expect = chai.expect
describe('Test live constraints', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let userId: number
let userAccessToken: string
let userChannelId: number
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
// Get the access tokens
await setAccessTokensToServers(servers)
cleanupTests,
ConfigCommand,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
stopFfmpeg,
const expect = chai.expect
describe('Permanent live', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let videoUUID: string
async function createLiveWrapper (permanentLive: boolean) {
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
// Get the access tokens
await setAccessTokensToServers(servers)
cleanupTests,
ConfigCommand,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
stopFfmpeg,
const expect = chai.expect
describe('Save replay setting', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let liveVideoUUID: string
let ffmpegCommand: FfmpegCommand
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
// Get the access tokens
await setAccessTokensToServers(servers)
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
stopFfmpeg,
const expect = chai.expect
describe('Test live', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
// Get the access tokens
await setAccessTokensToServers(servers)
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
stopFfmpeg,
const expect = chai.expect
describe('Test live', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
// Get the access tokens
await setAccessTokensToServers(servers)
checkResolutionsInMasterPlaylist,
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
killallServers,
LiveCommand,
makeRawRequest,
- reRunServer,
sendRTMPStream,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
stopFfmpeg,
const expect = chai.expect
describe('Test live', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let commands: LiveCommand[]
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
// Get the access tokens
await setAccessTokensToServers(servers)
await commands[0].waitUntilSegmentGeneration({ videoUUID: liveVideoReplayId, resolution: 0, segment: 2 })
await killallServers([ servers[0] ])
- await reRunServer(servers[0])
+ await servers[0].run()
await wait(5000)
})
AbusesCommand,
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '@shared/extra-utils'
const expect = chai.expect
describe('Test abuses', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let abuseServer1: AdminAbuse
let abuseServer2: AdminAbuse
let commands: AbusesCommand[]
this.timeout(50000)
// Run servers
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
// Get the access tokens
await setAccessTokensToServers(servers)
describe('Comment abuses', function () {
- async function getComment (server: ServerInfo, videoIdArg: number | string) {
+ async function getComment (server: PeerTubeServer, videoIdArg: number | string) {
const videoId = typeof videoIdArg === 'string'
? await server.videos.getId({ uuid: videoIdArg })
: videoIdArg
describe('Account abuses', function () {
- function getAccountFromServer (server: ServerInfo, targetName: string, targetServer: ServerInfo) {
+ function getAccountFromServer (server: PeerTubeServer, targetName: string, targetServer: PeerTubeServer) {
return server.accounts.get({ accountName: targetName + '@' + targetServer.host })
}
import 'mocha'
import * as chai from 'chai'
-import { cleanupTests, doubleFollow, flushAndRunMultipleServers, ServerInfo, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
+import { cleanupTests, doubleFollow, createMultipleServers, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
import { UserNotificationType } from '@shared/models'
const expect = chai.expect
-async function checkNotifications (server: ServerInfo, token: string, expected: UserNotificationType[]) {
+async function checkNotifications (server: PeerTubeServer, token: string, expected: UserNotificationType[]) {
const { data } = await server.notifications.list({ token, start: 0, count: 10, unread: true })
expect(data).to.have.lengthOf(expected.length)
}
describe('Test blocklist', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let videoUUID: string
let userToken1: string
before(async function () {
this.timeout(60000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
{
cleanupTests,
CommentsCommand,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '@shared/extra-utils'
const expect = chai.expect
-async function checkAllVideos (server: ServerInfo, token: string) {
+async function checkAllVideos (server: PeerTubeServer, token: string) {
{
const { data } = await server.videos.listWithToken({ token })
expect(data).to.have.lengthOf(5)
}
}
-async function checkAllComments (server: ServerInfo, token: string, videoUUID: string) {
+async function checkAllComments (server: PeerTubeServer, token: string, videoUUID: string) {
const { data } = await server.comments.listThreads({ videoId: videoUUID, start: 0, count: 25, sort: '-createdAt', token })
const threads = data.filter(t => t.isDeleted === false)
}
async function checkCommentNotification (
- mainServer: ServerInfo,
- comment: { server: ServerInfo, token: string, videoUUID: string, text: string },
+ mainServer: PeerTubeServer,
+ comment: { server: PeerTubeServer, token: string, videoUUID: string, text: string },
check: 'presence' | 'absence'
) {
const command = comment.server.comments
}
describe('Test blocklist', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let videoUUID1: string
let videoUUID2: string
let videoUUID3: string
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(3)
+ servers = await createMultipleServers(3)
await setAccessTokensToServers(servers)
command = servers[0].blocklist
BlacklistCommand,
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
ImportsCommand,
killallServers,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '@shared/extra-utils'
const expect = chai.expect
describe('Test video blacklist', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let videoId: number
let command: BlacklistCommand
- async function blacklistVideosOnServer (server: ServerInfo) {
+ async function blacklistVideosOnServer (server: PeerTubeServer) {
const { data } = await server.videos.list()
for (const video of data) {
this.timeout(50000)
// Run servers
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
// Get the access tokens
await setAccessTokensToServers(servers)
}
}
}
- await reRunServer(servers[0], config)
+ await servers[0].run(config)
{
const user = { username: 'user_without_flag', password: 'password' }
MockJoinPeerTubeVersions,
MockSmtpServer,
prepareNotificationsTest,
- ServerInfo,
+ PeerTubeServer,
wait
} from '@shared/extra-utils'
import { PluginType, UserNotification, UserNotificationType } from '@shared/models'
describe('Test admin notifications', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let userNotifications: UserNotification[] = []
let adminNotifications: UserNotification[] = []
let emails: object[] = []
cleanupTests,
MockSmtpServer,
prepareNotificationsTest,
- ServerInfo,
+ PeerTubeServer,
waitJobs
} from '@shared/extra-utils'
import { UserNotification } from '@shared/models'
const expect = chai.expect
describe('Test comments notifications', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let userToken: string
let userNotifications: UserNotification[] = []
let emails: object[] = []
MockInstancesIndex,
MockSmtpServer,
prepareNotificationsTest,
- ServerInfo,
+ PeerTubeServer,
wait,
waitJobs
} from '@shared/extra-utils'
import { AbuseState, CustomConfig, UserNotification, VideoPrivacy } from '@shared/models'
describe('Test moderation notifications', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let userAccessToken: string
let userNotifications: UserNotification[] = []
let adminNotifications: UserNotification[] = []
getAllNotificationsSettings,
MockSmtpServer,
prepareNotificationsTest,
- ServerInfo,
+ PeerTubeServer,
waitJobs
} from '@shared/extra-utils'
import { UserNotification, UserNotificationSettingValue } from '@shared/models'
const expect = chai.expect
describe('Test notifications API', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let userNotifications: UserNotification[] = []
let userToken: string
let emails: object[] = []
ImportsCommand,
MockSmtpServer,
prepareNotificationsTest,
- ServerInfo,
+ PeerTubeServer,
uploadRandomVideoOnServers,
wait,
waitJobs
const expect = chai.expect
describe('Test user notifications', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let userAccessToken: string
let userNotifications: UserNotification[] = []
let adminNotifications: UserNotification[] = []
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
RedundancyCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '@shared/extra-utils'
describe('Test manage videos redundancy', function () {
const targets: VideoRedundanciesTarget[] = [ 'my-videos', 'remote-videos' ]
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let video1Server2UUID: string
let video2Server2UUID: string
let redundanciesToRemove: number[] = []
}
}
}
- servers = await flushAndRunMultipleServers(3, config)
+ servers = await createMultipleServers(3, config)
// Get the access tokens
await setAccessTokensToServers(servers)
import { expect } from 'chai'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
killallServers,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '@shared/extra-utils'
import { VideoPrivacy } from '@shared/models'
describe('Test redundancy constraints', function () {
- let remoteServer: ServerInfo
- let localServer: ServerInfo
- let servers: ServerInfo[]
+ let remoteServer: PeerTubeServer
+ let localServer: PeerTubeServer
+ let servers: PeerTubeServer[]
const remoteServerConfig = {
redundancy: {
this.timeout(120000)
{
- remoteServer = await flushAndRunServer(1, remoteServerConfig)
+ remoteServer = await createSingleServer(1, remoteServerConfig)
}
{
}
}
}
- localServer = await flushAndRunServer(2, config)
+ localServer = await createSingleServer(2, config)
}
servers = [ remoteServer, localServer ]
}
}
await await killallServers([ localServer ])
- await reRunServer(localServer, config)
+ await localServer.run(config)
await uploadWrapper('video 2 server 2')
}
}
await killallServers([ localServer ])
- await reRunServer(localServer, config)
+ await localServer.run(config)
await uploadWrapper('video 3 server 2')
checkVideoFilesWereRemoved,
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
killallServers,
makeGetRequest,
- reRunServer,
root,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
wait,
waitJobs
const expect = chai.expect
-let servers: ServerInfo[] = []
+let servers: PeerTubeServer[] = []
let video1Server2UUID: string
let video1Server2Id: number
-function checkMagnetWebseeds (file: { magnetUri: string, resolution: { id: number } }, baseWebseeds: string[], server: ServerInfo) {
+function checkMagnetWebseeds (file: { magnetUri: string, resolution: { id: number } }, baseWebseeds: string[], server: PeerTubeServer) {
const parsed = magnetUtil.decode(file.magnetUri)
for (const ws of baseWebseeds) {
expect(parsed.urlList).to.have.lengthOf(baseWebseeds.length)
}
-async function flushAndRunServers (strategy: VideoRedundancyStrategy | null, additionalParams: any = {}, withWebtorrent = true) {
+async function createSingleServers (strategy: VideoRedundancyStrategy | null, additionalParams: any = {}, withWebtorrent = true) {
const strategies: any[] = []
if (strategy !== null) {
}
}
- servers = await flushAndRunMultipleServers(3, config)
+ servers = await createMultipleServers(3, config)
// Get the access tokens
await setAccessTokensToServers(servers)
before(function () {
this.timeout(120000)
- return flushAndRunServers(strategy)
+ return createSingleServers(strategy)
})
it('Should have 1 webseed on the first video', async function () {
before(function () {
this.timeout(120000)
- return flushAndRunServers(strategy)
+ return createSingleServers(strategy)
})
it('Should have 1 webseed on the first video', async function () {
before(function () {
this.timeout(120000)
- return flushAndRunServers(strategy, { min_views: 3 })
+ return createSingleServers(strategy, { min_views: 3 })
})
it('Should have 1 webseed on the first video', async function () {
before(async function () {
this.timeout(120000)
- await flushAndRunServers(strategy, { min_views: 3 }, false)
+ await createSingleServers(strategy, { min_views: 3 }, false)
})
it('Should have 0 playlist redundancy on the first video', async function () {
before(function () {
this.timeout(120000)
- return flushAndRunServers(null)
+ return createSingleServers(null)
})
it('Should have 1 webseed on the first video', async function () {
describe('Test expiration', function () {
const strategy = 'recently-added'
- async function checkContains (servers: ServerInfo[], str: string) {
+ async function checkContains (servers: PeerTubeServer[], str: string) {
for (const server of servers) {
const video = await server.videos.get({ id: video1Server2UUID })
}
}
- async function checkNotContains (servers: ServerInfo[], str: string) {
+ async function checkNotContains (servers: PeerTubeServer[], str: string) {
for (const server of servers) {
const video = await server.videos.get({ id: video1Server2UUID })
before(async function () {
this.timeout(120000)
- await flushAndRunServers(strategy, { min_lifetime: '7 seconds', min_views: 0 })
+ await createSingleServers(strategy, { min_lifetime: '7 seconds', min_views: 0 })
await enableRedundancyOnServer1()
})
before(async function () {
this.timeout(120000)
- await flushAndRunServers(strategy, { min_lifetime: '7 seconds', min_views: 0 })
+ await createSingleServers(strategy, { min_lifetime: '7 seconds', min_views: 0 })
await enableRedundancyOnServer1()
await waitJobs(servers)
await killallServers([ servers[0] ])
- await reRunServer(servers[0], {
+ await servers[0].run({
redundancy: {
videos: {
check_interval: '1 second',
import * as chai from 'chai'
import {
cleanupTests,
- flushAndRunMultipleServers,
+ createMultipleServers,
SearchCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
wait,
waitJobs
const expect = chai.expect
describe('Test ActivityPub video channels search', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let userServer2Token: string
let videoServer2UUID: string
let channelIdServer2: number
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
import * as chai from 'chai'
import {
cleanupTests,
- flushAndRunMultipleServers,
+ createMultipleServers,
SearchCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
wait,
const expect = chai.expect
describe('Test ActivityPub playlists search', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let playlistServer1UUID: string
let playlistServer2UUID: string
let video2Server2: string
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
await setDefaultVideoChannel(servers)
import * as chai from 'chai'
import {
cleanupTests,
- flushAndRunMultipleServers,
+ createMultipleServers,
SearchCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
wait,
waitJobs
const expect = chai.expect
describe('Test ActivityPub videos search', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let videoServer1UUID: string
let videoServer2UUID: string
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
import 'mocha'
import * as chai from 'chai'
-import { cleanupTests, flushAndRunServer, SearchCommand, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, SearchCommand, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
import { VideoChannel } from '@shared/models'
const expect = chai.expect
describe('Test channels search', function () {
- let server: ServerInfo = null
+ let server: PeerTubeServer = null
let command: SearchCommand
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
import 'mocha'
import * as chai from 'chai'
-import { cleanupTests, flushAndRunServer, SearchCommand, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, SearchCommand, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
import { BooleanBothQuery, VideoPlaylistPrivacy, VideoPlaylistType, VideosSearchQuery } from '@shared/models'
const expect = chai.expect
describe('Test videos search', function () {
const localVideoName = 'local video' + new Date().toISOString()
- let server: ServerInfo = null
+ let server: PeerTubeServer = null
let command: SearchCommand
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
import * as chai from 'chai'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
SearchCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel
} from '@shared/extra-utils'
const expect = chai.expect
describe('Test playlists search', function () {
- let server: ServerInfo = null
+ let server: PeerTubeServer = null
let command: SearchCommand
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await setDefaultVideoChannel([ server ])
import * as chai from 'chai'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
SearchCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
stopFfmpeg,
const expect = chai.expect
describe('Test videos search', function () {
- let server: ServerInfo = null
+ let server: PeerTubeServer = null
let startDate: string
let videoUUID: string
before(async function () {
this.timeout(60000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await setDefaultVideoChannel([ server ])
import * as chai from 'chai'
import {
cleanupTests,
- flushAndRunMultipleServers,
+ createMultipleServers,
MockInstancesIndex,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
wait,
waitJobs
const expect = chai.expect
-async function checkFollow (follower: ServerInfo, following: ServerInfo, exists: boolean) {
+async function checkFollow (follower: PeerTubeServer, following: PeerTubeServer, exists: boolean) {
{
const body = await following.follows.getFollowers({ start: 0, count: 5, sort: '-createdAt' })
const follow = body.data.find(f => f.follower.host === follower.host && f.state === 'accepted')
}
}
-async function server1Follows2 (servers: ServerInfo[]) {
+async function server1Follows2 (servers: PeerTubeServer[]) {
await servers[0].follows.follow({ targets: [ servers[1].host ] })
await waitJobs(servers)
}
-async function resetFollows (servers: ServerInfo[]) {
+async function resetFollows (servers: PeerTubeServer[]) {
try {
await servers[0].follows.unfollow({ target: servers[1] })
await servers[1].follows.unfollow({ target: servers[0] })
}
describe('Test auto follows', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
before(async function () {
this.timeout(30000)
- servers = await flushAndRunMultipleServers(3)
+ servers = await createMultipleServers(3)
// Get the access tokens
await setAccessTokensToServers(servers)
BulkCommand,
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '@shared/extra-utils'
describe('Test bulk actions', function () {
const commentsUser3: { videoId: number, commentId: number }[] = []
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let user1Token: string
let user2Token: string
let user3Token: string
before(async function () {
this.timeout(30000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
// Get the access tokens
await setAccessTokensToServers(servers)
import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
killallServers,
makeGetRequest,
parallelTests,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '@shared/extra-utils'
import { CustomConfig } from '@shared/models'
const expect = chai.expect
-function checkInitialConfig (server: ServerInfo, data: CustomConfig) {
+function checkInitialConfig (server: PeerTubeServer, data: CustomConfig) {
expect(data.instance.name).to.equal('PeerTube')
expect(data.instance.shortDescription).to.equal(
'PeerTube, an ActivityPub-federated video streaming platform using P2P directly in your web browser.'
}
describe('Test config', function () {
- let server: ServerInfo = null
+ let server: PeerTubeServer = null
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
})
await killallServers([ server ])
- await reRunServer(server)
+ await server.run()
const data = await server.config.getCustomConfig()
frameguard: { enabled: false }
}
}
- server = await reRunServer(server, config)
+ await server.run(config)
{
const res = await makeGetRequest({
import 'mocha'
import * as chai from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
-import { cleanupTests, flushAndRunServer, MockSmtpServer, ServerInfo, setAccessTokensToServers, wait, waitJobs } from '@shared/extra-utils'
-import { ContactFormCommand } from '@shared/extra-utils/server'
+import {
+ cleanupTests,
+ ContactFormCommand,
+ createSingleServer,
+ MockSmtpServer,
+ PeerTubeServer,
+ setAccessTokensToServers,
+ wait,
+ waitJobs
+} from '@shared/extra-utils'
const expect = chai.expect
describe('Test contact form', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
const emails: object[] = []
let command: ContactFormCommand
port
}
}
- server = await flushAndRunServer(1, overrideConfig)
+ server = await createSingleServer(1, overrideConfig)
await setAccessTokensToServers([ server ])
command = server.contactForm
import 'mocha'
import * as chai from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
-import { cleanupTests, flushAndRunServer, MockSmtpServer, ServerInfo, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, MockSmtpServer, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
const expect = chai.expect
describe('Test emails', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let userId: number
let userId2: number
let userAccessToken: string
port: emailPort
}
}
- server = await flushAndRunServer(1, overrideConfig)
+ server = await createSingleServer(1, overrideConfig)
await setAccessTokensToServers([ server ])
{
import 'mocha'
import * as chai from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
-import { cleanupTests, doubleFollow, flushAndRunMultipleServers, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
+import { cleanupTests, doubleFollow, createMultipleServers, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
import { PeerTubeProblemDocument, ServerErrorCode } from '@shared/models'
const expect = chai.expect
describe('Test follow constraints', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let video1UUID: string
let video2UUID: string
let userToken: string
before(async function () {
this.timeout(90000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
// Get the access tokens
await setAccessTokensToServers(servers)
import * as chai from 'chai'
import {
cleanupTests,
- flushAndRunMultipleServers,
+ createMultipleServers,
FollowsCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '@shared/extra-utils'
const expect = chai.expect
-async function checkServer1And2HasFollowers (servers: ServerInfo[], state = 'accepted') {
+async function checkServer1And2HasFollowers (servers: PeerTubeServer[], state = 'accepted') {
const fns = [
servers[0].follows.getFollowings.bind(servers[0].follows),
servers[1].follows.getFollowers.bind(servers[1].follows)
}
}
-async function checkNoFollowers (servers: ServerInfo[]) {
+async function checkNoFollowers (servers: PeerTubeServer[]) {
const fns = [
servers[0].follows.getFollowings.bind(servers[0].follows),
servers[1].follows.getFollowers.bind(servers[1].follows)
}
describe('Test follows moderation', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let commands: FollowsCommand[]
before(async function () {
this.timeout(30000)
- servers = await flushAndRunMultipleServers(3)
+ servers = await createMultipleServers(3)
// Get the access tokens
await setAccessTokensToServers(servers)
completeVideoCheck,
dateIsValid,
expectAccountFollows,
- flushAndRunMultipleServers,
+ createMultipleServers,
FollowsCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
testCaptionFile,
waitJobs
const expect = chai.expect
describe('Test follows', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let followsCommands: FollowsCommand[]
before(async function () {
this.timeout(30000)
- servers = await flushAndRunMultipleServers(3)
+ servers = await createMultipleServers(3)
followsCommands = servers.map(s => s.follows)
// Get the access tokens
cleanupTests,
CommentsCommand,
completeVideoCheck,
- flushAndRunMultipleServers,
+ createMultipleServers,
killallServers,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
wait,
waitJobs
const expect = chai.expect
describe('Test handle downs', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let threadIdServer1: number
let threadIdServer2: number
let commentIdServer1: number
before(async function () {
this.timeout(30000)
- servers = await flushAndRunMultipleServers(3)
+ servers = await createMultipleServers(3)
commentCommands = servers.map(s => s.comments)
checkAttributes = {
it('Should re-follow server 1', async function () {
this.timeout(35000)
- await reRunServer(servers[1])
- await reRunServer(servers[2])
+ await servers[1].run()
+ await servers[2].run()
await servers[1].follows.unfollow({ target: servers[0] })
await waitJobs(servers)
import {
cleanupTests,
CustomPagesCommand,
- flushAndRunServer,
+ createSingleServer,
killallServers,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '../../../../shared/extra-utils/index'
const expect = chai.expect
-async function getHomepageState (server: ServerInfo) {
+async function getHomepageState (server: PeerTubeServer) {
const config = await server.config.getConfig()
return config.homepage.enabled
}
describe('Test instance homepage actions', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let command: CustomPagesCommand
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
command = server.customPage
await killallServers([ server ])
- await reRunServer(server)
+ await server.run()
const page = await command.getInstanceHomepage()
expect(page.content).to.equal('<picsou-magazine></picsou-magazine>')
cleanupTests,
dateIsValid,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '@shared/extra-utils'
const expect = chai.expect
describe('Test jobs', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
before(async function () {
this.timeout(30000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
import * as chai from 'chai'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
killallServers,
LogsCommand,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '@shared/extra-utils'
const expect = chai.expect
describe('Test logs', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let logsCommand: LogsCommand
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
logsCommand = server.logs
await killallServers([ server ])
- await reRunServer(server, { log: { log_ping_requests: false } })
+ await server.run({ log: { log_ping_requests: false } })
const now = new Date()
import 'mocha'
import * as request from 'supertest'
-import { ServerInfo } from '../../../../shared/extra-utils'
-import { cleanupTests, flushAndRunServer } from '../../../../shared/extra-utils/server/servers'
+import { PeerTubeServer } from '../../../../shared/extra-utils'
+import { cleanupTests, createSingleServer } from '../../../../shared/extra-utils/server/servers'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
describe('Start and stop server without web client routes', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1, {}, [ '--no-client' ])
+ server = await createSingleServer(1, {}, [ '--no-client' ])
})
it('Should fail getting the client', function () {
import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
killallServers,
PluginsCommand,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
testHelloWorldRegisteredSettings,
wait
const expect = chai.expect
describe('Test plugins', function () {
- let server: ServerInfo = null
+ let server: PeerTubeServer = null
let command: PluginsCommand
before(async function () {
index: { check_latest_versions_interval: '5 seconds' }
}
}
- server = await flushAndRunServer(1, configOverride)
+ server = await createSingleServer(1, configOverride)
await setAccessTokensToServers([ server ])
command = server.plugins
// Restart the server to take into account this change
await killallServers([ server ])
- await reRunServer(server)
+ await server.run()
{
const body = await command.list({ pluginType: PluginType.PLUGIN })
await check()
await killallServers([ server ])
- await reRunServer(server)
+ await server.run()
await check()
})
import { expect } from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
-import { cleanupTests, flushAndRunServer, ServerInfo, setAccessTokensToServers, wait } from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers, wait } from '@shared/extra-utils'
describe('Test application behind a reverse proxy', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let videoId: string
before(async function () {
}
}
- server = await flushAndRunServer(1, config)
+ server = await createSingleServer(1, config)
await setAccessTokensToServers([ server ])
const { uuid } = await server.videos.upload()
import 'mocha'
import * as chai from 'chai'
-import { cleanupTests, flushAndRunServer, ServerInfo, setAccessTokensToServers, setDefaultVideoChannel } from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers, setDefaultVideoChannel } from '@shared/extra-utils'
import { Video, VideoPlaylistPrivacy } from '@shared/models'
const expect = chai.expect
describe('Test services', function () {
- let server: ServerInfo = null
+ let server: PeerTubeServer = null
let playlistUUID: string
let playlistDisplayName: string
let video: Video
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await setDefaultVideoChannel([ server ])
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
wait,
waitJobs
const expect = chai.expect
describe('Test stats (excluding redundancy)', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let channelId
const user = {
username: 'user1',
before(async function () {
this.timeout(60000)
- servers = await flushAndRunMultipleServers(3)
+ servers = await createMultipleServers(3)
await setAccessTokensToServers(servers)
import 'mocha'
import * as magnetUtil from 'magnet-uri'
import * as WebTorrent from 'webtorrent'
-import { cleanupTests, flushAndRunServer, killallServers, reRunServer, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, killallServers, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
describe('Test tracker', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let badMagnet: string
let goodMagnet: string
before(async function () {
this.timeout(60000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
{
const errCb = () => done(new Error('Tracker is enabled'))
killallServers([ server ])
- .then(() => reRunServer(server, { tracker: { enabled: false } }))
+ .then(() => server.run({ tracker: { enabled: false } }))
.then(() => {
const webtorrent = new WebTorrent()
this.timeout(20000)
killallServers([ server ])
- .then(() => reRunServer(server))
+ .then(() => server.run())
.then(() => {
const webtorrent = new WebTorrent()
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
SubscriptionsCommand,
waitJobs
const expect = chai.expect
describe('Test users subscriptions', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
const users: { accessToken: string }[] = []
let video3UUID: string
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(3)
+ servers = await createMultipleServers(3)
// Get the access tokens
await setAccessTokensToServers(servers)
checkVideoFilesWereRemoved,
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
testImage,
waitJobs
const expect = chai.expect
describe('Test users with multiple servers', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let user: User
let userId: number
let videoUUID: string
before(async function () {
this.timeout(120_000)
- servers = await flushAndRunMultipleServers(3)
+ servers = await createMultipleServers(3)
// Get the access tokens
await setAccessTokensToServers(servers)
import 'mocha'
import * as chai from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
-import { cleanupTests, flushAndRunServer, MockSmtpServer, ServerInfo, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, MockSmtpServer, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
const expect = chai.expect
describe('Test users account verification', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let userId: number
let userAccessToken: string
let verificationString: string
port
}
}
- server = await flushAndRunServer(1, overrideConfig)
+ server = await createSingleServer(1, overrideConfig)
await setAccessTokensToServers([ server ])
})
import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
killallServers,
makePutBodyRequest,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
testImage,
waitJobs
const expect = chai.expect
describe('Test users', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let token: string
let userToken: string
let videoId: number
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1, {
+ server = await createSingleServer(1, {
rates_limit: {
login: {
max: 30
await server.sql.setTokenField(server.accessToken, 'refreshTokenExpiresAt', new Date().toISOString())
await killallServers([ server ])
- await reRunServer(server)
+ await server.run()
await server.users.getMyInfo({ expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
})
await server.sql.setTokenField(server.accessToken, 'refreshTokenExpiresAt', futureDate)
await killallServers([ server ])
- await reRunServer(server)
+ await server.run()
const res = await server.login.refreshToken({ refreshToken: server.refreshToken })
server.accessToken = res.body.access_token
import * as chai from 'chai'
import { join } from 'path'
import { getAudioStream, getVideoStreamSize } from '@server/helpers/ffprobe-utils'
-import { cleanupTests, doubleFollow, flushAndRunMultipleServers, ServerInfo, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
+import { cleanupTests, doubleFollow, createMultipleServers, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
const expect = chai.expect
describe('Test audio only video transcoding', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let videoUUID: string
before(async function () {
}
}
}
- servers = await flushAndRunMultipleServers(2, configOverride)
+ servers = await createMultipleServers(2, configOverride)
// Get the access tokens
await setAccessTokensToServers(servers)
completeVideoCheck,
dateIsValid,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
testImage,
wait,
const expect = chai.expect
describe('Test multiple servers', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
const toRemove = []
let videoUUID = ''
let videoChannelId: number
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(3)
+ servers = await createMultipleServers(3)
// Get the access tokens
await setAccessTokensToServers(servers)
import {
buildAbsoluteFixturePath,
cleanupTests,
- flushAndRunServer,
- ServerInfo,
+ createSingleServer,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel
} from '@shared/extra-utils'
describe('Test resumable upload', function () {
const defaultFixture = 'video_short.mp4'
- let server: ServerInfo
+ let server: PeerTubeServer
let rootId: number
async function buildSize (fixture: string, size?: number) {
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await setDefaultVideoChannel([ server ])
checkVideoFilesWereRemoved,
cleanupTests,
completeVideoCheck,
- flushAndRunServer,
- ServerInfo,
+ createSingleServer,
+ PeerTubeServer,
setAccessTokensToServers,
testImage,
wait
describe('Test a single server', function () {
function runSuite (mode: 'legacy' | 'resumable') {
- let server: ServerInfo = null
+ let server: PeerTubeServer = null
let videoId: number | string
let videoId2: string
let videoUUID = ''
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
})
checkVideoFilesWereRemoved,
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
testCaptionFile,
wait,
describe('Test video captions', function () {
const uuidRegex = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let videoUUID: string
before(async function () {
this.timeout(60000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
await doubleFollow(servers[0], servers[1])
ChangeOwnershipCommand,
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
- flushAndRunServer,
- ServerInfo,
+ createMultipleServers,
+ createSingleServer,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
waitJobs
const expect = chai.expect
describe('Test video change ownership - nominal', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
const firstUser = 'first'
const secondUser = 'second'
before(async function () {
this.timeout(50000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
await setDefaultVideoChannel(servers)
})
describe('Test video change ownership - quota too small', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
const firstUser = 'first'
const secondUser = 'second'
this.timeout(50000)
// Run one server
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await server.users.create({ username: secondUser, videoQuota: 10 })
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
testFileExistsOrNot,
const expect = chai.expect
-async function findChannel (server: ServerInfo, channelId: number) {
+async function findChannel (server: PeerTubeServer, channelId: number) {
const body = await server.channels.list({ sort: '-name' })
return body.data.find(c => c.id === channelId)
}
describe('Test video channels', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let userInfo: User
let secondVideoChannelId: number
let totoChannel: number
before(async function () {
this.timeout(60000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
await setDefaultVideoChannel(servers)
cleanupTests,
CommentsCommand,
dateIsValid,
- flushAndRunServer,
- ServerInfo,
+ createSingleServer,
+ PeerTubeServer,
setAccessTokensToServers,
testImage
} from '@shared/extra-utils'
const expect = chai.expect
describe('Test video comments', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let videoId: number
let videoUUID: string
let threadId: number
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
import 'mocha'
import * as chai from 'chai'
-import { cleanupTests, doubleFollow, flushAndRunMultipleServers, ServerInfo, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
+import { cleanupTests, doubleFollow, createMultipleServers, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
const expect = chai.expect
describe('Test video description', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let videoUUID = ''
let videoId: number
const longDescription = 'my super description for server 1'.repeat(50)
this.timeout(40000)
// Run servers
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
// Get the access tokens
await setAccessTokensToServers(servers)
checkTmpIsEmpty,
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
makeRawRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs,
webtorrentAdd
const expect = chai.expect
-async function checkHlsPlaylist (servers: ServerInfo[], videoUUID: string, hlsOnly: boolean, resolutions = [ 240, 360, 480, 720 ]) {
+async function checkHlsPlaylist (servers: PeerTubeServer[], videoUUID: string, hlsOnly: boolean, resolutions = [ 240, 360, 480, 720 ]) {
for (const server of servers) {
const videoDetails = await server.videos.get({ id: videoUUID })
const baseUrl = `http://${videoDetails.account.host}`
}
describe('Test HLS videos', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let videoUUID = ''
let videoAudioUUID = ''
}
}
}
- servers = await flushAndRunMultipleServers(2, configOverride)
+ servers = await createMultipleServers(2, configOverride)
// Get the access tokens
await setAccessTokensToServers(servers)
areHttpImportTestsDisabled,
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
ImportsCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
testCaptionFile,
testImage,
const expect = chai.expect
describe('Test video imports', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let channelIdServer1: number
let channelIdServer2: number
if (areHttpImportTestsDisabled()) return
- async function checkVideosServer1 (server: ServerInfo, idHttp: string, idMagnet: string, idTorrent: string) {
+ async function checkVideosServer1 (server: PeerTubeServer, idHttp: string, idMagnet: string, idTorrent: string) {
const videoHttp = await server.videos.get({ id: idHttp })
expect(videoHttp.name).to.equal('small video - youtube')
expect(bodyCaptions.total).to.equal(2)
}
- async function checkVideoServer2 (server: ServerInfo, id: number | string) {
+ async function checkVideoServer2 (server: PeerTubeServer, id: number | string) {
const video = await server.videos.get({ id })
expect(video.name).to.equal('my super name')
this.timeout(30_000)
// Run servers
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
import 'mocha'
import * as chai from 'chai'
-import { cleanupTests, flushAndRunServer, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
import { BooleanBothQuery, CustomConfig, ResultList, Video, VideosOverview } from '@shared/models'
const expect = chai.expect
}
describe('Test video NSFW policy', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken: string
let customConfig: CustomConfig
before(async function () {
this.timeout(50000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
// Get the access tokens
await setAccessTokensToServers([ server ])
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
testImage,
const expect = chai.expect
describe('Playlist thumbnail', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let playlistWithoutThumbnailId: number
let playlistWithThumbnailId: number
let video1: number
let video2: number
- async function getPlaylistWithoutThumbnail (server: ServerInfo) {
+ async function getPlaylistWithoutThumbnail (server: PeerTubeServer) {
const body = await server.playlists.list({ start: 0, count: 10 })
return body.data.find(p => p.displayName === 'playlist without thumbnail')
}
- async function getPlaylistWithThumbnail (server: ServerInfo) {
+ async function getPlaylistWithThumbnail (server: PeerTubeServer) {
const body = await server.playlists.list({ start: 0, count: 10 })
return body.data.find(p => p.displayName === 'playlist with thumbnail')
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(2, { transcoding: { enabled: false } })
+ servers = await createMultipleServers(2, { transcoding: { enabled: false } })
// Get the access tokens
await setAccessTokensToServers(servers)
checkPlaylistFilesWereRemoved,
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
PlaylistsCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
testImage,
const expect = chai.expect
async function checkPlaylistElementType (
- servers: ServerInfo[],
+ servers: PeerTubeServer[],
playlistId: string,
type: VideoPlaylistElementType,
position: number,
}
describe('Test video playlists', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let playlistServer2Id1: number
let playlistServer2Id2: number
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(3, { transcoding: { enabled: false } })
+ servers = await createMultipleServers(3, { transcoding: { enabled: false } })
// Get the access tokens
await setAccessTokensToServers(servers)
})
describe('Element type', function () {
- let groupUser1: ServerInfo[]
- let groupWithoutToken1: ServerInfo[]
- let group1: ServerInfo[]
- let group2: ServerInfo[]
+ let groupUser1: PeerTubeServer[]
+ let groupWithoutToken1: PeerTubeServer[]
+ let group1: PeerTubeServer[]
+ let group2: PeerTubeServer[]
let video1: string
let video2: string
import 'mocha'
import * as chai from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
-import { cleanupTests, doubleFollow, flushAndRunServer, ServerInfo, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
+import { cleanupTests, doubleFollow, createSingleServer, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
import { VideoCreateResult, VideoPrivacy } from '@shared/models'
const expect = chai.expect
describe('Test video privacy', function () {
- const servers: ServerInfo[] = []
+ const servers: PeerTubeServer[] = []
let anotherUserToken: string
let privateVideoId: number
this.timeout(50000)
// Run servers
- servers.push(await flushAndRunServer(1, dontFederateUnlistedConfig))
- servers.push(await flushAndRunServer(2))
+ servers.push(await createSingleServer(1, dontFederateUnlistedConfig))
+ servers.push(await createSingleServer(2))
// Get the access tokens
await setAccessTokensToServers(servers)
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
wait,
waitJobs
}
describe('Test video update scheduler', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let video2UUID: string
before(async function () {
this.timeout(30000)
// Run servers
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
buildAbsoluteFixturePath,
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
generateHighBitrateVideo,
generateVideoWithFramerate,
makeGetRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs,
webtorrentAdd
const expect = chai.expect
-function updateConfigForTranscoding (server: ServerInfo) {
+function updateConfigForTranscoding (server: PeerTubeServer) {
return server.config.updateCustomSubConfig({
newConfig: {
transcoding: {
}
describe('Test video transcoding', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let video4k: string
before(async function () {
this.timeout(30_000)
// Run servers
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
makeGetRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '@shared/extra-utils'
import { UserRole, Video, VideoPrivacy } from '@shared/models'
-async function getVideosNames (server: ServerInfo, token: string, filter: string, statusCodeExpected = HttpStatusCode.OK_200) {
+async function getVideosNames (server: PeerTubeServer, token: string, filter: string, statusCodeExpected = HttpStatusCode.OK_200) {
const paths = [
'/api/v1/video-channels/root_channel/videos',
'/api/v1/accounts/root/videos',
}
describe('Test videos filter', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
// ---------------------------------------------------------------
before(async function () {
this.timeout(160000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
HistoryCommand,
killallServers,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
wait
} from '@shared/extra-utils'
const expect = chai.expect
describe('Test videos history', function () {
- let server: ServerInfo = null
+ let server: PeerTubeServer = null
let video1UUID: string
let video2UUID: string
let video3UUID: string
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await killallServers([ server ])
- await reRunServer(server, { history: { videos: { max_age: '10 days' } } })
+ await server.run({ history: { videos: { max_age: '10 days' } } })
await wait(6000)
await killallServers([ server ])
- await reRunServer(server, { history: { videos: { max_age: '5 seconds' } } })
+ await server.run({ history: { videos: { max_age: '5 seconds' } } })
await wait(6000)
import 'mocha'
import * as chai from 'chai'
-import { cleanupTests, flushAndRunServer, ServerInfo, setAccessTokensToServers, wait } from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers, wait } from '@shared/extra-utils'
import { VideosOverview } from '@shared/models'
const expect = chai.expect
describe('Test a videos overview', function () {
- let server: ServerInfo = null
+ let server: PeerTubeServer = null
function testOverviewCount (overview: VideosOverview, expected: number) {
expect(overview.tags).to.have.lengthOf(expected)
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
})
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
killallServers,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
wait,
waitJobs
const expect = chai.expect
describe('Test video views cleaner', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let videoIdServer1: string
let videoIdServer2: string
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
await doubleFollow(servers[0], servers[1])
await killallServers([ servers[0] ])
- await reRunServer(servers[0], { views: { videos: { remote: { max_age: '10 days' } } } })
+ await servers[0].run({ views: { videos: { remote: { max_age: '10 days' } } } })
await wait(6000)
await killallServers([ servers[0] ])
- await reRunServer(servers[0], { views: { videos: { remote: { max_age: '5 seconds' } } } })
+ await servers[0].run({ views: { videos: { remote: { max_age: '5 seconds' } } } })
await wait(6000)
import 'mocha'
import * as chai from 'chai'
-import { cleanupTests, doubleFollow, flushAndRunMultipleServers, ServerInfo, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
+import { cleanupTests, doubleFollow, createMultipleServers, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
import { VideoFile } from '@shared/models'
const expect = chai.expect
describe('Test create import video jobs', function () {
this.timeout(60000)
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let video1UUID: string
let video2UUID: string
this.timeout(90000)
// Run server 2 to have transcoding enabled
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
await doubleFollow(servers[0], servers[1])
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
- ServerInfo,
+ createMultipleServers,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '../../../shared/extra-utils'
const expect = chai.expect
describe('Test create transcoding jobs', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
const videosUUID: string[] = []
const config = {
this.timeout(60000)
// Run server 2 to have transcoding enabled
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
await servers[0].config.updateCustomSubConfig({ newConfig: config })
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
generateHighBitrateVideo,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
wait,
waitJobs
const expect = chai.expect
describe('Test optimize old videos', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
before(async function () {
this.timeout(200000)
// Run server 2 to have transcoding enabled
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
await doubleFollow(servers[0], servers[1])
cleanupTests,
CLICommand,
doubleFollow,
- flushAndRunServer,
+ createSingleServer,
ImportsCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
testHelloWorldRegisteredSettings,
waitJobs
} from '../../../shared/extra-utils'
describe('Test CLI wrapper', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let userAccessToken: string
let cliCommand: CLICommand
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await server.users.create({ username: 'user_1', password: 'super_password' })
})
describe('Manage video redundancies', function () {
- let anotherServer: ServerInfo
+ let anotherServer: PeerTubeServer
let video1Server2: number
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
before(async function () {
this.timeout(120000)
- anotherServer = await flushAndRunServer(2)
+ anotherServer = await createSingleServer(2)
await setAccessTokensToServers([ anotherServer ])
await doubleFollow(server, anotherServer)
import { expect } from 'chai'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
killallServers,
PluginsCommand,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '../../../shared/extra-utils'
describe('Test plugin scripts', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
})
this.timeout(30000)
await killallServers([ server ])
- await reRunServer(server)
+ await server.run()
const config = await server.config.getConfig()
this.timeout(30000)
await killallServers([ server ])
- await reRunServer(server)
+ await server.run()
const config = await server.config.getConfig()
cleanupTests,
CLICommand,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
killallServers,
makeGetRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
wait,
const expect = chai.expect
-async function countFiles (server: ServerInfo, directory: string) {
+async function countFiles (server: PeerTubeServer, directory: string) {
const files = await readdir(server.servers.buildDirectory(directory))
return files.length
}
-async function assertNotExists (server: ServerInfo, directory: string, substring: string) {
+async function assertNotExists (server: PeerTubeServer, directory: string, substring: string) {
const files = await readdir(server.servers.buildDirectory(directory))
for (const f of files) {
}
}
-async function assertCountAreOkay (servers: ServerInfo[]) {
+async function assertCountAreOkay (servers: PeerTubeServer[]) {
for (const server of servers) {
const videosCount = await countFiles(server, 'videos')
expect(videosCount).to.equal(8)
}
describe('Test prune storage scripts', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
const badNames: { [directory: string]: string[] } = {}
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(2, { transcoding: { enabled: true } })
+ servers = await createMultipleServers(2, { transcoding: { enabled: true } })
await setAccessTokensToServers(servers)
await setDefaultVideoChannel(servers)
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
makeRawRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '../../../shared/extra-utils'
-async function testThumbnail (server: ServerInfo, videoId: number | string) {
+async function testThumbnail (server: PeerTubeServer, videoId: number | string) {
const video = await server.videos.get({ id: videoId })
const requests = [
}
describe('Test regenerate thumbnails script', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let video1: Video
let video2: Video
before(async function () {
this.timeout(60000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
await doubleFollow(servers[0], servers[1])
import 'mocha'
-import { cleanupTests, CLICommand, flushAndRunServer, ServerInfo, setAccessTokensToServers } from '../../../shared/extra-utils'
+import { cleanupTests, CLICommand, createSingleServer, PeerTubeServer, setAccessTokensToServers } from '../../../shared/extra-utils'
describe('Test reset password scripts', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await server.users.create({ username: 'user_1', password: 'super password' })
import { expect } from 'chai'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
killallServers,
makeActivityPubGetRequest,
parseTorrentVideo,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '@shared/extra-utils'
describe('Test update host scripts', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
before(async function () {
this.timeout(60000)
}
}
// Run server 2 to have transcoding enabled
- server = await flushAndRunServer(2, overrideConfig)
+ server = await createSingleServer(2, overrideConfig)
await setAccessTokensToServers([ server ])
// Upload two videos for our needs
await killallServers([ server ])
// Run server with standard configuration
- await reRunServer(server)
+ await server.run()
await server.cli.execWithEnv(`npm run update-host`)
})
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
makeGetRequest,
makeHTMLRequest,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
waitJobs
}
describe('Test a client controllers', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let account: Account
const videoName = 'my super name for server 1'
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
import 'mocha'
import { expect } from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
-import { cleanupTests, flushAndRunServer, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
describe('Official plugin auth-ldap', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let accessToken: string
let userId: number
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await server.plugins.install({ npmName: 'peertube-plugin-auth-ldap' })
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
killallServers,
MockBlocklist,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
wait
} from '@shared/extra-utils'
import { Video } from '@shared/models'
-async function check (server: ServerInfo, videoUUID: string, exists = true) {
+async function check (server: PeerTubeServer, videoUUID: string, exists = true) {
const { data } = await server.videos.list()
const video = data.find(v => v.uuid === videoUUID)
}
describe('Official plugin auto-block videos', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let blocklistServer: MockBlocklist
let server1Videos: Video[] = []
let server2Videos: Video[] = []
before(async function () {
this.timeout(60000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
for (const server of servers) {
await check(servers[0], video.uuid, true)
await killallServers([ servers[0] ])
- await reRunServer(servers[0])
+ await servers[0].run()
await wait(2000)
await check(servers[0], video.uuid, true)
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
killallServers,
makeGetRequest,
MockBlocklist,
- reRunServer,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
wait
} from '@shared/extra-utils'
describe('Official plugin auto-mute', function () {
const autoMuteListPath = '/plugins/auto-mute/router/api/v1/mute-list'
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let blocklistServer: MockBlocklist
let port: number
before(async function () {
this.timeout(30000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
for (const server of servers) {
}
await killallServers([ servers[0] ])
- await reRunServer(servers[0])
+ await servers[0].run()
await wait(2000)
{
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
- flushAndRunServer,
- ServerInfo,
+ createMultipleServers,
+ createSingleServer,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '@shared/extra-utils'
const expect = chai.expect
describe('Test syndication feeds', () => {
- let servers: ServerInfo[] = []
- let serverHLSOnly: ServerInfo
+ let servers: PeerTubeServer[] = []
+ let serverHLSOnly: PeerTubeServer
let userAccessToken: string
let rootAccountId: number
let rootChannelId: number
this.timeout(120000)
// Run servers
- servers = await flushAndRunMultipleServers(2)
- serverHLSOnly = await flushAndRunServer(3, {
+ servers = await createMultipleServers(2)
+ serverHLSOnly = await createSingleServer(3, {
transcoding: {
enabled: true,
webtorrent: { enabled: false },
import 'mocha'
import * as chai from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
-import { cleanupTests, flushAndRunServer, makeGetRequest, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, makeGetRequest, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
import { VideoPrivacy } from '@shared/models'
const expect = chai.expect
describe('Test misc endpoints', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
before(async function () {
this.timeout(120000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
})
import 'mocha'
import {
cleanupTests,
- flushAndRunMultipleServers,
+ createMultipleServers,
killallServers,
+ PeerTubeServer,
PluginsCommand,
- reRunServer,
- ServerInfo,
setAccessTokensToServers,
setDefaultVideoChannel
} from '@shared/extra-utils'
import { ServerHookName, VideoPlaylistPrivacy, VideoPrivacy } from '@shared/models'
describe('Test plugin action hooks', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let videoUUID: string
let threadId: number
before(async function () {
this.timeout(30000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
await setDefaultVideoChannel(servers)
await killallServers([ servers[0] ])
- await reRunServer(servers[0], {
+ await servers[0].run({
live: {
enabled: true
}
import {
cleanupTests,
decodeQueryString,
- flushAndRunServer,
+ createSingleServer,
PluginsCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
wait
} from '@shared/extra-utils'
import { UserRole } from '@shared/models'
async function loginExternal (options: {
- server: ServerInfo
+ server: PeerTubeServer
npmName: string
authName: string
username: string
}
describe('Test external auth plugins', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let cyanAccessToken: string
let cyanRefreshToken: string
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
for (const suffix of [ 'one', 'two', 'three' ]) {
import {
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
ImportsCommand,
makeRawRequest,
PluginsCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
waitJobs
const expect = chai.expect
describe('Test plugin filter hooks', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
let videoUUID: string
let threadId: number
before(async function () {
this.timeout(60000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
await setDefaultVideoChannel(servers)
await doubleFollow(servers[0], servers[1])
import * as chai from 'chai'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeHTMLRequest,
PluginsCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '../../../shared/extra-utils'
const expect = chai.expect
describe('Test plugins HTML injection', function () {
- let server: ServerInfo = null
+ let server: PeerTubeServer = null
let command: PluginsCommand
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
command = server.plugins
import 'mocha'
import { expect } from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
-import { cleanupTests, flushAndRunServer, PluginsCommand, ServerInfo, setAccessTokensToServers, wait } from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, PluginsCommand, PeerTubeServer, setAccessTokensToServers, wait } from '@shared/extra-utils'
import { UserRole } from '@shared/models'
describe('Test id and pass auth plugins', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let crashAccessToken: string
let crashRefreshToken: string
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
for (const suffix of [ 'one', 'two', 'three' ]) {
checkVideoFilesWereRemoved,
cleanupTests,
doubleFollow,
- flushAndRunMultipleServers,
+ createMultipleServers,
makeGetRequest,
makePostBodyRequest,
PluginsCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
waitJobs
} from '@shared/extra-utils'
-function postCommand (server: ServerInfo, command: string, bodyArg?: object) {
+function postCommand (server: PeerTubeServer, command: string, bodyArg?: object) {
const body = { command }
if (bodyArg) Object.assign(body, bodyArg)
}
describe('Test plugin helpers', function () {
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
before(async function () {
this.timeout(60000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
await setAccessTokensToServers(servers)
await doubleFollow(servers[0], servers[1])
import { HttpStatusCode } from '@shared/core-utils'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
makeGetRequest,
makePostBodyRequest,
PluginsCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers
} from '@shared/extra-utils'
describe('Test plugin helpers', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
const basePaths = [
'/plugins/test-five/router/',
'/plugins/test-five/0.0.1/router/'
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-five') })
import { pathExists, readdir, readFile } from 'fs-extra'
import { join } from 'path'
import { HttpStatusCode } from '@shared/core-utils'
-import { cleanupTests, flushAndRunServer, makeGetRequest, PluginsCommand, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
+import {
+ cleanupTests,
+ createSingleServer,
+ makeGetRequest,
+ PeerTubeServer,
+ PluginsCommand,
+ setAccessTokensToServers
+} from '@shared/extra-utils'
describe('Test plugin storage', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-six') })
import { getAudioStream, getVideoFileFPS, getVideoStreamFromFile } from '@server/helpers/ffprobe-utils'
import {
cleanupTests,
- flushAndRunServer,
+ createSingleServer,
PluginsCommand,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
testFfmpegStreamError,
} from '@shared/extra-utils'
import { VideoPrivacy } from '@shared/models'
-async function createLiveWrapper (server: ServerInfo) {
+async function createLiveWrapper (server: PeerTubeServer) {
const liveAttributes = {
name: 'live video',
channelId: server.store.channel.id,
return uuid
}
-function updateConf (server: ServerInfo, vodProfile: string, liveProfile: string) {
+function updateConf (server: PeerTubeServer, vodProfile: string, liveProfile: string) {
return server.config.updateCustomSubConfig({
newConfig: {
transcoding: {
}
describe('Test transcoding plugins', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
before(async function () {
this.timeout(60000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await setDefaultVideoChannel([ server ])
import 'mocha'
import { expect } from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
-import { cleanupTests, flushAndRunServer, makeGetRequest, PluginsCommand, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
+import {
+ cleanupTests,
+ createSingleServer,
+ makeGetRequest,
+ PeerTubeServer,
+ PluginsCommand,
+ setAccessTokensToServers
+} from '@shared/extra-utils'
describe('Test plugins module unloading', function () {
- let server: ServerInfo = null
+ let server: PeerTubeServer = null
const requestPath = '/plugins/test-unloading/router/get'
let value: string = null
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-unloading') })
import 'mocha'
import * as chai from 'chai'
-import { PluginsCommand, setAccessTokensToServers } from '../../../shared/extra-utils'
-import { cleanupTests, flushAndRunServer, ServerInfo } from '../../../shared/extra-utils/server/servers'
+import { cleanupTests, createSingleServer, PeerTubeServer, PluginsCommand, setAccessTokensToServers } from '@shared/extra-utils'
const expect = chai.expect
describe('Test plugin translations', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
let command: PluginsCommand
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
command = server.plugins
import 'mocha'
import * as chai from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
-import { cleanupTests, flushAndRunServer, PluginsCommand, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, PluginsCommand, PeerTubeServer, setAccessTokensToServers } from '@shared/extra-utils'
import { VideoPlaylistPrivacy } from '@shared/models'
const expect = chai.expect
describe('Test plugin altering video constants', function () {
- let server: ServerInfo
+ let server: PeerTubeServer
before(async function () {
this.timeout(30000)
- server = await flushAndRunServer(1)
+ server = await createSingleServer(1)
await setAccessTokensToServers([ server ])
await server.plugins.install({ path: PluginsCommand.getPluginTestPath('-video-constants') })
import { Netrc } from 'netrc-parser'
import { join } from 'path'
import { createLogger, format, transports } from 'winston'
-import { assignCommands, ServerInfo } from '@shared/extra-utils'
+import { PeerTubeServer } from '@shared/extra-utils'
import { UserRole } from '@shared/models'
import { VideoPrivacy } from '../../shared/models/videos'
import { getAppNumber, isTestInstance, root } from '../helpers/core-utils'
const version = require('../../../package.json').version
-async function getAdminTokenOrDie (server: ServerInfo, username: string, password: string) {
+async function getAdminTokenOrDie (server: PeerTubeServer, username: string, password: string) {
const token = await server.login.getAccessToken(username, password)
const me = await server.users.getMyInfo({ token })
.option('-v, --verbose <verbose>', 'Verbosity, from 0/\'error\' to 4/\'debug\'', 'info')
}
-async function buildVideoAttributesFromCommander (server: ServerInfo, command: Command, defaultAttributes: any = {}) {
+async function buildVideoAttributesFromCommander (server: PeerTubeServer, command: Command, defaultAttributes: any = {}) {
const options = command.opts()
const defaultBooleanAttributes = {
})
}
-function buildServer (url: string): ServerInfo {
- const server = { url, internalServerNumber: undefined }
- assignCommands(server)
-
- return server
+function buildServer (url: string) {
+ return new PeerTubeServer({ url })
}
-async function assignToken (server: ServerInfo, username: string, password: string) {
+async function assignToken (server: PeerTubeServer, username: string, password: string) {
const bodyClient = await server.login.getClient()
const client = { id: bodyClient.client_id, secret: bodyClient.client_secret }
getLogger,
getServerCredentials
} from './cli'
-import { ServerInfo } from '@shared/extra-utils'
+import { PeerTubeServer } from '@shared/extra-utils'
const processOptions = {
maxBuffer: Infinity
/* ---------------------------------------------------------- */
-async function getCategory (server: ServerInfo, categories: string[]) {
+async function getCategory (server: PeerTubeServer, categories: string[]) {
if (!categories) return undefined
const categoryString = categories[0]
import { program } from 'commander'
import { LiveVideoCreate, VideoPrivacy } from '@shared/models'
import {
- flushAndRunServer,
+ createSingleServer,
killallServers,
sendRTMPStream,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel
} from '../../shared/extra-utils'
console.log('Starting server.')
- const server = await flushAndRunServer(1, {}, [], { hideLogs: false, execArgv: [ '--inspect' ] })
+ const server = await createSingleServer(1, {}, [], { hideLogs: false, execArgv: [ '--inspect' ] })
const cleanup = async () => {
console.log('Killing server')
// ----------------------------------------------------------------------------
-async function buildConfig (server: ServerInfo, commandType: CommandType) {
+async function buildConfig (server: PeerTubeServer, commandType: CommandType) {
await server.config.updateCustomSubConfig({
newConfig: {
instance: {
import { root } from '@server/helpers/core-utils'
import { HttpStatusCode } from '@shared/core-utils'
import { makeGetRequest } from '../requests'
-import { ServerInfo } from '../server'
+import { PeerTubeServer } from '../server'
// Default interval -> 5 minutes
function dateIsValid (dateString: string, interval = 300000) {
expect(data.length).to.be.below(maxLength, 'the generated image is way larger than the recorded fixture')
}
-async function testFileExistsOrNot (server: ServerInfo, directory: string, filePath: string, exist: boolean) {
+async function testFileExistsOrNot (server: PeerTubeServer, directory: string, filePath: string, exist: boolean) {
const base = server.servers.buildDirectory(directory)
expect(await pathExists(join(base, filePath))).to.equal(exist)
import * as parseTorrent from 'parse-torrent'
import { join } from 'path'
import * as WebTorrent from 'webtorrent'
-import { ServerInfo } from '../server'
+import { PeerTubeServer } from '../server'
let webtorrent: WebTorrent.Instance
return new Promise<WebTorrent.Torrent>(res => webtorrent.add(torrent, res))
}
-async function parseTorrentVideo (server: ServerInfo, videoUUID: string, resolution: number) {
+async function parseTorrentVideo (server: PeerTubeServer, videoUUID: string, resolution: number) {
const torrentName = videoUUID + '-' + resolution + '.torrent'
const torrentPath = server.servers.buildDirectory(join('torrents', torrentName))
import { pathExists, readdir } from 'fs-extra'
import { join } from 'path'
import { root } from '@server/helpers/core-utils'
-import { ServerInfo } from './servers'
+import { PeerTubeServer } from './server'
-async function checkTmpIsEmpty (server: ServerInfo) {
+async function checkTmpIsEmpty (server: PeerTubeServer) {
await checkDirectoryIsEmpty(server, 'tmp', [ 'plugins-global.css', 'hls', 'resumable-uploads' ])
if (await pathExists(join('test' + server.internalServerNumber, 'tmp', 'hls'))) {
}
}
-async function checkDirectoryIsEmpty (server: ServerInfo, directory: string, exceptions: string[] = []) {
+async function checkDirectoryIsEmpty (server: PeerTubeServer, directory: string, exceptions: string[] = []) {
const testDirectory = 'test' + server.internalServerNumber
const directoryPath = join(root(), testDirectory, directory)
import { ActivityPubActorType, ActorFollow, FollowState, ResultList } from '@shared/models'
import { HttpStatusCode } from '../../core-utils/miscs/http-error-codes'
import { AbstractCommand, OverrideCommandOptions } from '../shared'
-import { ServerInfo } from './servers'
+import { PeerTubeServer } from './server'
export class FollowsCommand extends AbstractCommand {
}
async unfollow (options: OverrideCommandOptions & {
- target: ServerInfo
+ target: PeerTubeServer
}) {
const path = '/api/v1/server/following/' + options.target.host
}
removeFollower (options: OverrideCommandOptions & {
- follower: ServerInfo
+ follower: PeerTubeServer
}) {
const path = '/api/v1/server/followers/peertube@' + options.follower.host
import { waitJobs } from './jobs'
-import { ServerInfo } from './servers'
+import { PeerTubeServer } from './server'
-async function doubleFollow (server1: ServerInfo, server2: ServerInfo) {
+async function doubleFollow (server1: PeerTubeServer, server2: PeerTubeServer) {
await Promise.all([
server1.follows.follow({ targets: [ server2.url ] }),
server2.follows.follow({ targets: [ server1.url ] })
export * from './plugins-command'
export * from './plugins'
export * from './redundancy-command'
+export * from './server'
export * from './servers-command'
export * from './servers'
export * from './stats-command'
import { JobState } from '../../models'
import { wait } from '../miscs'
-import { ServerInfo } from './servers'
+import { PeerTubeServer } from './server'
-async function waitJobs (serversArg: ServerInfo[] | ServerInfo) {
+async function waitJobs (serversArg: PeerTubeServer[] | PeerTubeServer) {
const pendingJobWait = process.env.NODE_PENDING_JOB_WAIT
? parseInt(process.env.NODE_PENDING_JOB_WAIT, 10)
: 250
- let servers: ServerInfo[]
+ let servers: PeerTubeServer[]
- if (Array.isArray(serversArg) === false) servers = [ serversArg as ServerInfo ]
- else servers = serversArg as ServerInfo[]
+ if (Array.isArray(serversArg) === false) servers = [ serversArg as PeerTubeServer ]
+ else servers = serversArg as PeerTubeServer[]
const states: JobState[] = [ 'waiting', 'active', 'delayed' ]
const repeatableJobs = [ 'videos-views', 'activitypub-cleaner' ]
/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
import { expect } from 'chai'
-import { ServerInfo } from '../server/servers'
+import { PeerTubeServer } from '../server/server'
-async function testHelloWorldRegisteredSettings (server: ServerInfo) {
+async function testHelloWorldRegisteredSettings (server: PeerTubeServer) {
const body = await server.plugins.getRegisteredSettings({ npmName: 'peertube-plugin-hello-world' })
const registeredSettings = body.registeredSettings
--- /dev/null
+import { ChildProcess, fork } from 'child_process'
+import { copy } from 'fs-extra'
+import { join } from 'path'
+import { root } from '@server/helpers/core-utils'
+import { randomInt } from '../../core-utils/miscs/miscs'
+import { VideoChannel } from '../../models/videos'
+import { BulkCommand } from '../bulk'
+import { CLICommand } from '../cli'
+import { CustomPagesCommand } from '../custom-pages'
+import { FeedCommand } from '../feeds'
+import { LogsCommand } from '../logs'
+import { parallelTests, SQLCommand } from '../miscs'
+import { AbusesCommand } from '../moderation'
+import { OverviewsCommand } from '../overviews'
+import { SearchCommand } from '../search'
+import { SocketIOCommand } from '../socket'
+import { AccountsCommand, BlocklistCommand, LoginCommand, NotificationsCommand, SubscriptionsCommand, UsersCommand } from '../users'
+import {
+ BlacklistCommand,
+ CaptionsCommand,
+ ChangeOwnershipCommand,
+ ChannelsCommand,
+ HistoryCommand,
+ ImportsCommand,
+ LiveCommand,
+ PlaylistsCommand,
+ ServicesCommand,
+ StreamingPlaylistsCommand,
+ VideosCommand
+} from '../videos'
+import { CommentsCommand } from '../videos/comments-command'
+import { ConfigCommand } from './config-command'
+import { ContactFormCommand } from './contact-form-command'
+import { DebugCommand } from './debug-command'
+import { FollowsCommand } from './follows-command'
+import { JobsCommand } from './jobs-command'
+import { PluginsCommand } from './plugins-command'
+import { RedundancyCommand } from './redundancy-command'
+import { ServersCommand } from './servers-command'
+import { StatsCommand } from './stats-command'
+
+export type RunServerOptions = {
+ hideLogs?: boolean
+ execArgv?: string[]
+}
+
+export class PeerTubeServer {
+ app?: ChildProcess
+
+ url: string
+ host?: string
+ hostname?: string
+ port?: number
+
+ rtmpPort?: number
+
+ parallel?: boolean
+ internalServerNumber: number
+
+ serverNumber?: number
+ customConfigFile?: string
+
+ store?: {
+ client?: {
+ id?: string
+ secret?: string
+ }
+
+ user?: {
+ username: string
+ password: string
+ email?: string
+ }
+
+ channel?: VideoChannel
+
+ video?: {
+ id: number
+ uuid: string
+ shortUUID: string
+ name?: string
+ url?: string
+
+ account?: {
+ name: string
+ }
+
+ embedPath?: string
+ }
+
+ videos?: { id: number, uuid: string }[]
+ }
+
+ accessToken?: string
+ refreshToken?: string
+
+ bulk?: BulkCommand
+ cli?: CLICommand
+ customPage?: CustomPagesCommand
+ feed?: FeedCommand
+ logs?: LogsCommand
+ abuses?: AbusesCommand
+ overviews?: OverviewsCommand
+ search?: SearchCommand
+ contactForm?: ContactFormCommand
+ debug?: DebugCommand
+ follows?: FollowsCommand
+ jobs?: JobsCommand
+ plugins?: PluginsCommand
+ redundancy?: RedundancyCommand
+ stats?: StatsCommand
+ config?: ConfigCommand
+ socketIO?: SocketIOCommand
+ accounts?: AccountsCommand
+ blocklist?: BlocklistCommand
+ subscriptions?: SubscriptionsCommand
+ live?: LiveCommand
+ services?: ServicesCommand
+ blacklist?: BlacklistCommand
+ captions?: CaptionsCommand
+ changeOwnership?: ChangeOwnershipCommand
+ playlists?: PlaylistsCommand
+ history?: HistoryCommand
+ imports?: ImportsCommand
+ streamingPlaylists?: StreamingPlaylistsCommand
+ channels?: ChannelsCommand
+ comments?: CommentsCommand
+ sql?: SQLCommand
+ notifications?: NotificationsCommand
+ servers?: ServersCommand
+ login?: LoginCommand
+ users?: UsersCommand
+ videos?: VideosCommand
+
+ constructor (options: { serverNumber: number } | { url: string }) {
+ if ((options as any).url) {
+ this.setUrl((options as any).url)
+ } else {
+ this.setServerNumber((options as any).serverNumber)
+ }
+
+ this.store = {
+ client: {
+ id: null,
+ secret: null
+ },
+ user: {
+ username: null,
+ password: null
+ }
+ }
+
+ this.assignCommands()
+ }
+
+ setServerNumber (serverNumber: number) {
+ this.serverNumber = serverNumber
+
+ this.parallel = parallelTests()
+
+ this.internalServerNumber = this.parallel ? this.randomServer() : this.serverNumber
+ this.rtmpPort = this.parallel ? this.randomRTMP() : 1936
+ this.port = 9000 + this.internalServerNumber
+
+ this.url = `http://localhost:${this.port}`
+ this.host = `localhost:${this.port}`
+ this.hostname = 'localhost'
+ }
+
+ setUrl (url: string) {
+ const parsed = new URL(url)
+
+ this.url = url
+ this.host = parsed.host
+ this.hostname = parsed.hostname
+ this.port = parseInt(parsed.port)
+ }
+
+ async flushAndRun (configOverride?: Object, args = [], options: RunServerOptions = {}) {
+ await ServersCommand.flushTests(this.internalServerNumber)
+
+ return this.run(configOverride, args, options)
+ }
+
+ async run (configOverrideArg?: any, args = [], options: RunServerOptions = {}) {
+ // These actions are async so we need to be sure that they have both been done
+ const serverRunString = {
+ 'HTTP server listening': false
+ }
+ const key = 'Database peertube_test' + this.internalServerNumber + ' is ready'
+ serverRunString[key] = false
+
+ const regexps = {
+ client_id: 'Client id: (.+)',
+ client_secret: 'Client secret: (.+)',
+ user_username: 'Username: (.+)',
+ user_password: 'User password: (.+)'
+ }
+
+ await this.assignCustomConfigFile()
+
+ const configOverride = this.buildConfigOverride()
+
+ if (configOverrideArg !== undefined) {
+ Object.assign(configOverride, configOverrideArg)
+ }
+
+ // Share the environment
+ const env = Object.create(process.env)
+ env['NODE_ENV'] = 'test'
+ env['NODE_APP_INSTANCE'] = this.internalServerNumber.toString()
+ env['NODE_CONFIG'] = JSON.stringify(configOverride)
+
+ const forkOptions = {
+ silent: true,
+ env,
+ detached: true,
+ execArgv: options.execArgv || []
+ }
+
+ return new Promise<void>(res => {
+ this.app = fork(join(root(), 'dist', 'server.js'), args, forkOptions)
+ this.app.stdout.on('data', function onStdout (data) {
+ let dontContinue = false
+
+ // Capture things if we want to
+ for (const key of Object.keys(regexps)) {
+ const regexp = regexps[key]
+ const matches = data.toString().match(regexp)
+ if (matches !== null) {
+ if (key === 'client_id') this.store.client.id = matches[1]
+ else if (key === 'client_secret') this.store.client.secret = matches[1]
+ else if (key === 'user_username') this.store.user.username = matches[1]
+ else if (key === 'user_password') this.store.user.password = matches[1]
+ }
+ }
+
+ // Check if all required sentences are here
+ for (const key of Object.keys(serverRunString)) {
+ if (data.toString().indexOf(key) !== -1) serverRunString[key] = true
+ if (serverRunString[key] === false) dontContinue = true
+ }
+
+ // If no, there is maybe one thing not already initialized (client/user credentials generation...)
+ if (dontContinue === true) return
+
+ if (options.hideLogs === false) {
+ console.log(data.toString())
+ } else {
+ this.app.stdout.removeListener('data', onStdout)
+ }
+
+ process.on('exit', () => {
+ try {
+ process.kill(this.server.app.pid)
+ } catch { /* empty */ }
+ })
+
+ res()
+ })
+ })
+ }
+
+ async kill () {
+ if (!this.app) return
+
+ await this.sql.cleanup()
+
+ process.kill(-this.app.pid)
+
+ this.app = null
+ }
+
+ private randomServer () {
+ const low = 10
+ const high = 10000
+
+ return randomInt(low, high)
+ }
+
+ private randomRTMP () {
+ const low = 1900
+ const high = 2100
+
+ return randomInt(low, high)
+ }
+
+ private async assignCustomConfigFile () {
+ if (this.internalServerNumber === this.serverNumber) return
+
+ const basePath = join(root(), 'config')
+
+ const tmpConfigFile = join(basePath, `test-${this.internalServerNumber}.yaml`)
+ await copy(join(basePath, `test-${this.serverNumber}.yaml`), tmpConfigFile)
+
+ this.customConfigFile = tmpConfigFile
+ }
+
+ private buildConfigOverride () {
+ if (!this.parallel) return {}
+
+ return {
+ listen: {
+ port: this.port
+ },
+ webserver: {
+ port: this.port
+ },
+ database: {
+ suffix: '_test' + this.internalServerNumber
+ },
+ storage: {
+ tmp: `test${this.internalServerNumber}/tmp/`,
+ avatars: `test${this.internalServerNumber}/avatars/`,
+ videos: `test${this.internalServerNumber}/videos/`,
+ streaming_playlists: `test${this.internalServerNumber}/streaming-playlists/`,
+ redundancy: `test${this.internalServerNumber}/redundancy/`,
+ logs: `test${this.internalServerNumber}/logs/`,
+ previews: `test${this.internalServerNumber}/previews/`,
+ thumbnails: `test${this.internalServerNumber}/thumbnails/`,
+ torrents: `test${this.internalServerNumber}/torrents/`,
+ captions: `test${this.internalServerNumber}/captions/`,
+ cache: `test${this.internalServerNumber}/cache/`,
+ plugins: `test${this.internalServerNumber}/plugins/`
+ },
+ admin: {
+ email: `admin${this.internalServerNumber}@example.com`
+ },
+ live: {
+ rtmp: {
+ port: this.rtmpPort
+ }
+ }
+ }
+ }
+
+ private assignCommands () {
+ this.bulk = new BulkCommand(this)
+ this.cli = new CLICommand(this)
+ this.customPage = new CustomPagesCommand(this)
+ this.feed = new FeedCommand(this)
+ this.logs = new LogsCommand(this)
+ this.abuses = new AbusesCommand(this)
+ this.overviews = new OverviewsCommand(this)
+ this.search = new SearchCommand(this)
+ this.contactForm = new ContactFormCommand(this)
+ this.debug = new DebugCommand(this)
+ this.follows = new FollowsCommand(this)
+ this.jobs = new JobsCommand(this)
+ this.plugins = new PluginsCommand(this)
+ this.redundancy = new RedundancyCommand(this)
+ this.stats = new StatsCommand(this)
+ this.config = new ConfigCommand(this)
+ this.socketIO = new SocketIOCommand(this)
+ this.accounts = new AccountsCommand(this)
+ this.blocklist = new BlocklistCommand(this)
+ this.subscriptions = new SubscriptionsCommand(this)
+ this.live = new LiveCommand(this)
+ this.services = new ServicesCommand(this)
+ this.blacklist = new BlacklistCommand(this)
+ this.captions = new CaptionsCommand(this)
+ this.changeOwnership = new ChangeOwnershipCommand(this)
+ this.playlists = new PlaylistsCommand(this)
+ this.history = new HistoryCommand(this)
+ this.imports = new ImportsCommand(this)
+ this.streamingPlaylists = new StreamingPlaylistsCommand(this)
+ this.channels = new ChannelsCommand(this)
+ this.comments = new CommentsCommand(this)
+ this.sql = new SQLCommand(this)
+ this.notifications = new NotificationsCommand(this)
+ this.servers = new ServersCommand(this)
+ this.login = new LoginCommand(this)
+ this.users = new UsersCommand(this)
+ this.videos = new VideosCommand(this)
+ }
+}
if (isGithubCI()) {
await ensureDir('artifacts')
- const origin = this.server.servers.buildDirectory('logs/peertube.log')
+ const origin = this.buildDirectory('logs/peertube.log')
const destname = `peertube-${this.server.internalServerNumber}.log`
console.log('Saving logs %s.', destname)
-/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/no-floating-promises */
+import { ensureDir } from 'fs-extra'
+import { isGithubCI } from '../miscs'
+import { PeerTubeServer, RunServerOptions } from './server'
-import { ChildProcess, fork } from 'child_process'
-import { copy, ensureDir } from 'fs-extra'
-import { join } from 'path'
-import { root } from '@server/helpers/core-utils'
-import { randomInt } from '../../core-utils/miscs/miscs'
-import { VideoChannel } from '../../models/videos'
-import { BulkCommand } from '../bulk'
-import { CLICommand } from '../cli'
-import { CustomPagesCommand } from '../custom-pages'
-import { FeedCommand } from '../feeds'
-import { LogsCommand } from '../logs'
-import { isGithubCI, parallelTests, SQLCommand } from '../miscs'
-import { AbusesCommand } from '../moderation'
-import { OverviewsCommand } from '../overviews'
-import { SearchCommand } from '../search'
-import { SocketIOCommand } from '../socket'
-import { AccountsCommand, BlocklistCommand, LoginCommand, NotificationsCommand, SubscriptionsCommand, UsersCommand } from '../users'
-import {
- BlacklistCommand,
- CaptionsCommand,
- ChangeOwnershipCommand,
- ChannelsCommand,
- HistoryCommand,
- ImportsCommand,
- LiveCommand,
- PlaylistsCommand,
- ServicesCommand,
- StreamingPlaylistsCommand,
- VideosCommand
-} from '../videos'
-import { CommentsCommand } from '../videos/comments-command'
-import { ConfigCommand } from './config-command'
-import { ContactFormCommand } from './contact-form-command'
-import { DebugCommand } from './debug-command'
-import { FollowsCommand } from './follows-command'
-import { JobsCommand } from './jobs-command'
-import { PluginsCommand } from './plugins-command'
-import { RedundancyCommand } from './redundancy-command'
-import { ServersCommand } from './servers-command'
-import { StatsCommand } from './stats-command'
+async function createSingleServer (serverNumber: number, configOverride?: Object, args = [], options: RunServerOptions = {}) {
+ const server = new PeerTubeServer({ serverNumber })
-interface ServerInfo {
- app?: ChildProcess
+ await server.flushAndRun(configOverride, args, options)
- url: string
- host?: string
- hostname?: string
- port?: number
-
- rtmpPort?: number
-
- parallel?: boolean
- internalServerNumber: number
-
- serverNumber?: number
- customConfigFile?: string
-
- store?: {
- client?: {
- id?: string
- secret?: string
- }
-
- user?: {
- username: string
- password: string
- email?: string
- }
-
- channel?: VideoChannel
-
- video?: {
- id: number
- uuid: string
- shortUUID: string
- name?: string
- url?: string
-
- account?: {
- name: string
- }
-
- embedPath?: string
- }
-
- videos?: { id: number, uuid: string }[]
- }
-
- accessToken?: string
- refreshToken?: string
-
- bulk?: BulkCommand
- cli?: CLICommand
- customPage?: CustomPagesCommand
- feed?: FeedCommand
- logs?: LogsCommand
- abuses?: AbusesCommand
- overviews?: OverviewsCommand
- search?: SearchCommand
- contactForm?: ContactFormCommand
- debug?: DebugCommand
- follows?: FollowsCommand
- jobs?: JobsCommand
- plugins?: PluginsCommand
- redundancy?: RedundancyCommand
- stats?: StatsCommand
- config?: ConfigCommand
- socketIO?: SocketIOCommand
- accounts?: AccountsCommand
- blocklist?: BlocklistCommand
- subscriptions?: SubscriptionsCommand
- live?: LiveCommand
- services?: ServicesCommand
- blacklist?: BlacklistCommand
- captions?: CaptionsCommand
- changeOwnership?: ChangeOwnershipCommand
- playlists?: PlaylistsCommand
- history?: HistoryCommand
- imports?: ImportsCommand
- streamingPlaylists?: StreamingPlaylistsCommand
- channels?: ChannelsCommand
- comments?: CommentsCommand
- sql?: SQLCommand
- notifications?: NotificationsCommand
- servers?: ServersCommand
- login?: LoginCommand
- users?: UsersCommand
- videos?: VideosCommand
-}
-
-function flushAndRunMultipleServers (totalServers: number, configOverride?: Object) {
- const apps = []
- let i = 0
-
- return new Promise<ServerInfo[]>(res => {
- function anotherServerDone (serverNumber, app) {
- apps[serverNumber - 1] = app
- i++
- if (i === totalServers) {
- return res(apps)
- }
- }
-
- for (let j = 1; j <= totalServers; j++) {
- flushAndRunServer(j, configOverride).then(app => anotherServerDone(j, app))
- }
- })
-}
-
-function randomServer () {
- const low = 10
- const high = 10000
-
- return randomInt(low, high)
-}
-
-function randomRTMP () {
- const low = 1900
- const high = 2100
-
- return randomInt(low, high)
-}
-
-type RunServerOptions = {
- hideLogs?: boolean
- execArgv?: string[]
-}
-
-async function flushAndRunServer (serverNumber: number, configOverride?: Object, args = [], options: RunServerOptions = {}) {
- const parallel = parallelTests()
-
- const internalServerNumber = parallel ? randomServer() : serverNumber
- const rtmpPort = parallel ? randomRTMP() : 1936
- const port = 9000 + internalServerNumber
-
- await ServersCommand.flushTests(internalServerNumber)
-
- const server: ServerInfo = {
- app: null,
- port,
- internalServerNumber,
- rtmpPort,
- parallel,
- serverNumber,
- url: `http://localhost:${port}`,
- host: `localhost:${port}`,
- hostname: 'localhost',
- store: {
- client: {
- id: null,
- secret: null
- },
- user: {
- username: null,
- password: null
- }
- }
- }
-
- return runServer(server, configOverride, args, options)
+ return server
}
-async function runServer (server: ServerInfo, configOverrideArg?: any, args = [], options: RunServerOptions = {}) {
- // These actions are async so we need to be sure that they have both been done
- const serverRunString = {
- 'HTTP server listening': false
- }
- const key = 'Database peertube_test' + server.internalServerNumber + ' is ready'
- serverRunString[key] = false
-
- const regexps = {
- client_id: 'Client id: (.+)',
- client_secret: 'Client secret: (.+)',
- user_username: 'Username: (.+)',
- user_password: 'User password: (.+)'
- }
-
- if (server.internalServerNumber !== server.serverNumber) {
- const basePath = join(root(), 'config')
-
- const tmpConfigFile = join(basePath, `test-${server.internalServerNumber}.yaml`)
- await copy(join(basePath, `test-${server.serverNumber}.yaml`), tmpConfigFile)
-
- server.customConfigFile = tmpConfigFile
- }
-
- const configOverride: any = {}
-
- if (server.parallel) {
- Object.assign(configOverride, {
- listen: {
- port: server.port
- },
- webserver: {
- port: server.port
- },
- database: {
- suffix: '_test' + server.internalServerNumber
- },
- storage: {
- tmp: `test${server.internalServerNumber}/tmp/`,
- avatars: `test${server.internalServerNumber}/avatars/`,
- videos: `test${server.internalServerNumber}/videos/`,
- streaming_playlists: `test${server.internalServerNumber}/streaming-playlists/`,
- redundancy: `test${server.internalServerNumber}/redundancy/`,
- logs: `test${server.internalServerNumber}/logs/`,
- previews: `test${server.internalServerNumber}/previews/`,
- thumbnails: `test${server.internalServerNumber}/thumbnails/`,
- torrents: `test${server.internalServerNumber}/torrents/`,
- captions: `test${server.internalServerNumber}/captions/`,
- cache: `test${server.internalServerNumber}/cache/`,
- plugins: `test${server.internalServerNumber}/plugins/`
- },
- admin: {
- email: `admin${server.internalServerNumber}@example.com`
- },
- live: {
- rtmp: {
- port: server.rtmpPort
- }
- }
- })
- }
-
- if (configOverrideArg !== undefined) {
- Object.assign(configOverride, configOverrideArg)
- }
-
- // Share the environment
- const env = Object.create(process.env)
- env['NODE_ENV'] = 'test'
- env['NODE_APP_INSTANCE'] = server.internalServerNumber.toString()
- env['NODE_CONFIG'] = JSON.stringify(configOverride)
+function createMultipleServers (totalServers: number, configOverride?: Object) {
+ const serverPromises: Promise<PeerTubeServer>[] = []
- const forkOptions = {
- silent: true,
- env,
- detached: true,
- execArgv: options.execArgv || []
+ for (let i = 1; i <= totalServers; i++) {
+ serverPromises.push(createSingleServer(i, configOverride))
}
- return new Promise<ServerInfo>(res => {
- server.app = fork(join(root(), 'dist', 'server.js'), args, forkOptions)
- server.app.stdout.on('data', function onStdout (data) {
- let dontContinue = false
-
- // Capture things if we want to
- for (const key of Object.keys(regexps)) {
- const regexp = regexps[key]
- const matches = data.toString().match(regexp)
- if (matches !== null) {
- if (key === 'client_id') server.store.client.id = matches[1]
- else if (key === 'client_secret') server.store.client.secret = matches[1]
- else if (key === 'user_username') server.store.user.username = matches[1]
- else if (key === 'user_password') server.store.user.password = matches[1]
- }
- }
-
- // Check if all required sentences are here
- for (const key of Object.keys(serverRunString)) {
- if (data.toString().indexOf(key) !== -1) serverRunString[key] = true
- if (serverRunString[key] === false) dontContinue = true
- }
-
- // If no, there is maybe one thing not already initialized (client/user credentials generation...)
- if (dontContinue === true) return
-
- if (options.hideLogs === false) {
- console.log(data.toString())
- } else {
- server.app.stdout.removeListener('data', onStdout)
- }
-
- process.on('exit', () => {
- try {
- process.kill(server.app.pid)
- } catch { /* empty */ }
- })
-
- assignCommands(server)
-
- res(server)
- })
- })
-}
-
-function assignCommands (server: ServerInfo) {
- server.bulk = new BulkCommand(server)
- server.cli = new CLICommand(server)
- server.customPage = new CustomPagesCommand(server)
- server.feed = new FeedCommand(server)
- server.logs = new LogsCommand(server)
- server.abuses = new AbusesCommand(server)
- server.overviews = new OverviewsCommand(server)
- server.search = new SearchCommand(server)
- server.contactForm = new ContactFormCommand(server)
- server.debug = new DebugCommand(server)
- server.follows = new FollowsCommand(server)
- server.jobs = new JobsCommand(server)
- server.plugins = new PluginsCommand(server)
- server.redundancy = new RedundancyCommand(server)
- server.stats = new StatsCommand(server)
- server.config = new ConfigCommand(server)
- server.socketIO = new SocketIOCommand(server)
- server.accounts = new AccountsCommand(server)
- server.blocklist = new BlocklistCommand(server)
- server.subscriptions = new SubscriptionsCommand(server)
- server.live = new LiveCommand(server)
- server.services = new ServicesCommand(server)
- server.blacklist = new BlacklistCommand(server)
- server.captions = new CaptionsCommand(server)
- server.changeOwnership = new ChangeOwnershipCommand(server)
- server.playlists = new PlaylistsCommand(server)
- server.history = new HistoryCommand(server)
- server.imports = new ImportsCommand(server)
- server.streamingPlaylists = new StreamingPlaylistsCommand(server)
- server.channels = new ChannelsCommand(server)
- server.comments = new CommentsCommand(server)
- server.sql = new SQLCommand(server)
- server.notifications = new NotificationsCommand(server)
- server.servers = new ServersCommand(server)
- server.login = new LoginCommand(server)
- server.users = new UsersCommand(server)
- server.videos = new VideosCommand(server)
-}
-
-async function reRunServer (server: ServerInfo, configOverride?: any) {
- const newServer = await runServer(server, configOverride)
- server.app = newServer.app
-
- return server
+ return Promise.all(serverPromises)
}
-async function killallServers (servers: ServerInfo[]) {
- for (const server of servers) {
- if (!server.app) continue
-
- await server.sql.cleanup()
-
- process.kill(-server.app.pid)
-
- server.app = null
- }
+async function killallServers (servers: PeerTubeServer[]) {
+ return Promise.all(servers.map(s => s.kill()))
}
-async function cleanupTests (servers: ServerInfo[]) {
+async function cleanupTests (servers: PeerTubeServer[]) {
await killallServers(servers)
if (isGithubCI()) {
// ---------------------------------------------------------------------------
export {
- ServerInfo,
+ createSingleServer,
+ createMultipleServers,
cleanupTests,
- flushAndRunMultipleServers,
- flushAndRunServer,
- killallServers,
- reRunServer,
- assignCommands
+ killallServers
}
unwrapBody,
unwrapText
} from '../requests/requests'
-import { ServerInfo } from '../server/servers'
+import { PeerTubeServer } from '../server/server'
export interface OverrideCommandOptions {
token?: string
abstract class AbstractCommand {
constructor (
- protected server: ServerInfo
+ protected server: PeerTubeServer
) {
}
import { pathExists, readdir } from 'fs-extra'
import { join } from 'path'
import { root } from '@server/helpers/core-utils'
-import { ServerInfo } from '../server'
+import { PeerTubeServer } from '../server'
async function expectAccountFollows (options: {
- server: ServerInfo
+ server: PeerTubeServer
handle: string
followers: number
following: number
-import { ServerInfo } from '../server/servers'
+import { PeerTubeServer } from '../server/server'
-function setAccessTokensToServers (servers: ServerInfo[]) {
+function setAccessTokensToServers (servers: PeerTubeServer[]) {
const tasks: Promise<any>[] = []
for (const server of servers) {
import { AbuseState, PluginType } from '@shared/models'
import { UserNotification, UserNotificationSetting, UserNotificationSettingValue, UserNotificationType } from '../../models/users'
import { MockSmtpServer } from '../mock-servers/mock-email'
+import { PeerTubeServer } from '../server'
import { doubleFollow } from '../server/follows'
-import { flushAndRunMultipleServers, ServerInfo } from '../server/servers'
+import { createMultipleServers } from '../server/servers'
import { setAccessTokensToServers } from './login'
function getAllNotificationsSettings (): UserNotificationSetting {
}
type CheckerBaseParams = {
- server: ServerInfo
+ server: PeerTubeServer
emails: any[]
socketNotifications: UserNotification[]
token: string
limit: 20
}
}
- const servers = await flushAndRunMultipleServers(serversCount, Object.assign(overrideConfig, overrideConfigArg))
+ const servers = await createMultipleServers(serversCount, Object.assign(overrideConfig, overrideConfigArg))
await setAccessTokensToServers(servers)
-import { ServerInfo } from '../server/servers'
+import { PeerTubeServer } from '../server/server'
-function setDefaultVideoChannel (servers: ServerInfo[]) {
+function setDefaultVideoChannel (servers: PeerTubeServer[]) {
const tasks: Promise<any>[] = []
for (const server of servers) {
import { pathExists, readdir } from 'fs-extra'
import { join } from 'path'
import { buildAbsoluteFixturePath, wait } from '../miscs'
-import { ServerInfo } from '../server/servers'
+import { PeerTubeServer } from '../server/server'
function sendRTMPStream (rtmpBaseUrl: string, streamKey: string, fixtureName = 'video_short.mp4') {
const fixture = buildAbsoluteFixturePath(fixtureName)
await wait(500)
}
-async function waitUntilLivePublishedOnAllServers (servers: ServerInfo[], videoId: string) {
+async function waitUntilLivePublishedOnAllServers (servers: PeerTubeServer[], videoId: string) {
for (const server of servers) {
await server.live.waitUntilPublished({ videoId })
}
}
-async function checkLiveCleanup (server: ServerInfo, videoUUID: string, resolutions: number[] = []) {
+async function checkLiveCleanup (server: PeerTubeServer, videoUUID: string, resolutions: number[] = []) {
const basePath = server.servers.buildDirectory('streaming-playlists')
const hlsPath = join(basePath, 'hls', videoUUID)
import { sha256 } from '@server/helpers/core-utils'
import { HttpStatusCode } from '@shared/core-utils'
import { VideoStreamingPlaylist } from '@shared/models'
-import { ServerInfo } from '../server'
+import { PeerTubeServer } from '../server'
async function checkSegmentHash (options: {
- server: ServerInfo
+ server: PeerTubeServer
baseUrlPlaylist: string
baseUrlSegment: string
videoUUID: string
}
async function checkLiveSegmentHash (options: {
- server: ServerInfo
+ server: PeerTubeServer
baseUrlSegment: string
videoUUID: string
segmentName: string
}
async function checkResolutionsInMasterPlaylist (options: {
- server: ServerInfo
+ server: PeerTubeServer
playlistUrl: string
resolutions: number[]
}) {
} from '@shared/models'
import { buildAbsoluteFixturePath, wait } from '../miscs'
import { unwrapBody } from '../requests'
-import { ServerInfo, waitJobs } from '../server'
+import { PeerTubeServer, waitJobs } from '../server'
import { AbstractCommand, OverrideCommandOptions } from '../shared'
export type VideoEdit = Partial<Omit<VideoCreate, 'thumbnailfile' | 'previewfile'>> & {
export class VideosCommand extends AbstractCommand {
- constructor (server: ServerInfo) {
+ constructor (server: PeerTubeServer) {
super(server)
loadLanguages()
import { dateIsValid, testImage, webtorrentAdd } from '../miscs'
import { makeRawRequest } from '../requests/requests'
import { waitJobs } from '../server'
-import { ServerInfo } from '../server/servers'
+import { PeerTubeServer } from '../server/server'
import { VideoEdit } from './videos-command'
async function checkVideoFilesWereRemoved (
videoUUID: string,
- server: ServerInfo,
+ server: PeerTubeServer,
directories = [
'redundancy',
'videos',
}
function checkUploadVideoParam (
- server: ServerInfo,
+ server: PeerTubeServer,
token: string,
attributes: Partial<VideoEdit>,
expectedStatus = HttpStatusCode.OK_200,
}
async function completeVideoCheck (
- server: ServerInfo,
+ server: PeerTubeServer,
video: any,
attributes: {
name: string
// serverNumber starts from 1
async function uploadRandomVideoOnServers (
- servers: ServerInfo[],
+ servers: PeerTubeServer[],
serverNumber: number,
additionalParams?: VideoEdit & { prefixName?: string }
) {
projects / github / Chocobozzz / PeerTube.git / commitdiff
