-/* tslint:disable:no-unused-expression */
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/no-floating-promises */
+import { HttpStatusCode } from '@shared/core-utils'
import { expect } from 'chai'
import { pathExists, readdir, readFile } from 'fs-extra'
import * as parseTorrent from 'parse-torrent'
import { extname, join } from 'path'
import * as request from 'supertest'
-import {
- buildAbsoluteFixturePath,
- getMyUserInformation,
- immutableAssign,
- makeGetRequest,
- makePutBodyRequest,
- makeUploadRequest,
- root,
- ServerInfo,
- testImage
-} from '../'
+import { v4 as uuidv4 } from 'uuid'
import validator from 'validator'
+import { loadLanguages, VIDEO_CATEGORIES, VIDEO_LANGUAGES, VIDEO_LICENCES, VIDEO_PRIVACIES } from '../../../server/initializers/constants'
import { VideoDetails, VideoPrivacy } from '../../models/videos'
-import { VIDEO_CATEGORIES, VIDEO_LANGUAGES, loadLanguages, VIDEO_LICENCES, VIDEO_PRIVACIES } from '../../../server/initializers/constants'
-import { dateIsValid, webtorrentAdd, buildServerDirectory } from '../miscs/miscs'
+import { buildAbsoluteFixturePath, buildServerDirectory, dateIsValid, immutableAssign, testImage, webtorrentAdd } from '../miscs/miscs'
+import { makeGetRequest, makePutBodyRequest, makeUploadRequest } from '../requests/requests'
+import { waitJobs } from '../server/jobs'
+import { ServerInfo } from '../server/servers'
+import { getMyUserInformation } from '../users/users'
loadLanguages()
return makeGetRequest({
url,
path,
- statusCodeExpected: 200
+ statusCodeExpected: HttpStatusCode.OK_200
})
}
return makeGetRequest({
url,
path,
- statusCodeExpected: 200
+ statusCodeExpected: HttpStatusCode.OK_200
})
}
return makeGetRequest({
url,
path,
- statusCodeExpected: 200
+ statusCodeExpected: HttpStatusCode.OK_200
})
}
return makeGetRequest({
url,
path,
- statusCodeExpected: 200
+ statusCodeExpected: HttpStatusCode.OK_200
})
}
-function getVideo (url: string, id: number | string, expectedStatus = 200) {
+function getVideo (url: string, id: number | string, expectedStatus = HttpStatusCode.OK_200) {
const path = '/api/v1/videos/' + id
return request(url)
.expect(expectedStatus)
}
-function viewVideo (url: string, id: number | string, expectedStatus = 204, xForwardedFor?: string) {
+async function getVideoIdFromUUID (url: string, uuid: string) {
+ const res = await getVideo(url, uuid)
+
+ return res.body.id
+}
+
+function getVideoFileMetadataUrl (url: string) {
+ return request(url)
+ .get('/')
+ .set('Accept', 'application/json')
+ .expect(HttpStatusCode.OK_200)
+ .expect('Content-Type', /json/)
+}
+
+function viewVideo (url: string, id: number | string, expectedStatus = HttpStatusCode.NO_CONTENT_204, xForwardedFor?: string) {
const path = '/api/v1/videos/' + id + '/views'
const req = request(url)
return req.expect(expectedStatus)
}
-function getVideoWithToken (url: string, token: string, id: number | string, expectedStatus = 200) {
+function getVideoWithToken (url: string, token: string, id: number | string, expectedStatus = HttpStatusCode.OK_200) {
const path = '/api/v1/videos/' + id
return request(url)
return request(url)
.get(descriptionPath)
.set('Accept', 'application/json')
- .expect(200)
+ .expect(HttpStatusCode.OK_200)
.expect('Content-Type', /json/)
}
.get(path)
.query({ sort: 'name' })
.set('Accept', 'application/json')
- .expect(200)
+ .expect(HttpStatusCode.OK_200)
.expect('Content-Type', /json/)
}
.set('Authorization', 'Bearer ' + token)
.query(immutableAssign(query, { sort: 'name' }))
.set('Accept', 'application/json')
- .expect(200)
+ .expect(HttpStatusCode.OK_200)
.expect('Content-Type', /json/)
}
.get(path)
.query({ sort: 'name', filter: 'local' })
.set('Accept', 'application/json')
- .expect(200)
+ .expect(HttpStatusCode.OK_200)
.expect('Content-Type', /json/)
}
return req.set('Accept', 'application/json')
.set('Authorization', 'Bearer ' + accessToken)
- .expect(200)
+ .expect(HttpStatusCode.OK_200)
.expect('Content-Type', /json/)
}
sort
}),
token: accessToken,
- statusCodeExpected: 200
+ statusCodeExpected: HttpStatusCode.OK_200
})
}
sort
}),
token: accessToken,
- statusCodeExpected: 200
+ statusCodeExpected: HttpStatusCode.OK_200
})
}
count
}),
token: accessToken,
- statusCodeExpected: 200
+ statusCodeExpected: HttpStatusCode.OK_200
})
}
-function getVideosListPagination (url: string, start: number, count: number, sort?: string) {
+function getVideosListPagination (url: string, start: number, count: number, sort?: string, skipCount?: boolean) {
const path = '/api/v1/videos'
const req = request(url)
.query({ count: count })
if (sort) req.query({ sort })
+ if (skipCount) req.query({ skipCount })
return req.set('Accept', 'application/json')
- .expect(200)
+ .expect(HttpStatusCode.OK_200)
.expect('Content-Type', /json/)
}
.get(path)
.query({ sort: sort })
.set('Accept', 'application/json')
- .expect(200)
+ .expect(HttpStatusCode.OK_200)
.expect('Content-Type', /json/)
}
.get(path)
.query(query)
.set('Accept', 'application/json')
- .expect(200)
+ .expect(HttpStatusCode.OK_200)
.expect('Content-Type', /json/)
}
-function removeVideo (url: string, token: string, id: number | string, expectedStatus = 204) {
+function removeVideo (url: string, token: string, id: number | string, expectedStatus = HttpStatusCode.NO_CONTENT_204) {
const path = '/api/v1/videos'
return request(url)
.expect(expectedStatus)
}
+async function removeAllVideos (server: ServerInfo) {
+ const resVideos = await getVideosList(server.url)
+
+ for (const v of resVideos.body.data) {
+ await removeVideo(server.url, server.accessToken, v.id)
+ }
+}
+
async function checkVideoFilesWereRemoved (
videoUUID: string,
serverNumber: number,
]
) {
for (const directory of directories) {
- const directoryPath = buildServerDirectory(serverNumber, directory)
+ const directoryPath = buildServerDirectory({ internalServerNumber: serverNumber }, directory)
const directoryExists = await pathExists(directoryPath)
if (directoryExists === false) continue
}
}
-async function uploadVideo (url: string, accessToken: string, videoAttributesArg: VideoAttributes, specialStatus = 200) {
+async function uploadVideo (url: string, accessToken: string, videoAttributesArg: VideoAttributes, specialStatus = HttpStatusCode.OK_200) {
const path = '/api/v1/videos/upload'
let defaultChannelId = '1'
.expect(specialStatus)
}
-function updateVideo (url: string, accessToken: string, id: number | string, attributes: VideoAttributes, statusCodeExpected = 204) {
+function updateVideo (
+ url: string,
+ accessToken: string,
+ id: number | string,
+ attributes: VideoAttributes,
+ statusCodeExpected = HttpStatusCode.NO_CONTENT_204
+) {
const path = '/api/v1/videos/' + id
const body = {}
})
}
-function rateVideo (url: string, accessToken: string, id: number, rating: string, specialStatus = 204) {
+function rateVideo (url: string, accessToken: string, id: number, rating: string, specialStatus = HttpStatusCode.NO_CONTENT_204) {
const path = '/api/v1/videos/' + id + '/rate'
return request(url)
function parseTorrentVideo (server: ServerInfo, videoUUID: string, resolution: number) {
return new Promise<any>((res, rej) => {
const torrentName = videoUUID + '-' + resolution + '.torrent'
- const torrentPath = join(root(), 'test' + server.serverNumber, 'torrents', torrentName)
+ const torrentPath = buildServerDirectory(server, join('torrents', torrentName))
+
readFile(torrentPath, (err, data) => {
if (err) return rej(err)
description: string
publishedAt?: string
support: string
- originallyPublishedAt?: string,
+ originallyPublishedAt?: string
account: {
name: string
host: string
files: {
resolution: number
size: number
- }[],
+ }[]
thumbnailfile?: string
previewfile?: string
}
const minSize = attributeFile.size - ((10 * attributeFile.size) / 100)
const maxSize = attributeFile.size + ((10 * attributeFile.size) / 100)
- expect(file.size,
- 'File size for resolution ' + file.resolution.label + ' outside confidence interval (' + minSize + '> size <' + maxSize + ')')
- .to.be.above(minSize).and.below(maxSize)
-
- {
- await testImage(url, attributes.thumbnailfile || attributes.fixture, videoDetails.thumbnailPath)
- }
-
- if (attributes.previewfile) {
- await testImage(url, attributes.previewfile, videoDetails.previewPath)
- }
+ expect(
+ file.size,
+ 'File size for resolution ' + file.resolution.label + ' outside confidence interval (' + minSize + '> size <' + maxSize + ')'
+ ).to.be.above(minSize).and.below(maxSize)
const torrent = await webtorrentAdd(file.magnetUri, true)
expect(torrent.files).to.be.an('array')
expect(torrent.files.length).to.equal(1)
expect(torrent.files[0].path).to.exist.and.to.not.equal('')
}
+
+ await testImage(url, attributes.thumbnailfile || attributes.fixture, videoDetails.thumbnailPath)
+
+ if (attributes.previewfile) {
+ await testImage(url, attributes.previewfile, videoDetails.previewPath)
+ }
}
async function videoUUIDToId (url: string, id: number | string) {
return res.body.id
}
-async function uploadVideoAndGetId (options: { server: ServerInfo, videoName: string, nsfw?: boolean, token?: string }) {
+async function uploadVideoAndGetId (options: {
+ server: ServerInfo
+ videoName: string
+ nsfw?: boolean
+ privacy?: VideoPrivacy
+ token?: string
+}) {
const videoAttrs: any = { name: options.videoName }
if (options.nsfw) videoAttrs.nsfw = options.nsfw
+ if (options.privacy) videoAttrs.privacy = options.privacy
const res = await uploadVideo(options.server.url, options.token || options.server.accessToken, videoAttrs)
return { id: res.body.video.id, uuid: res.body.video.uuid }
}
+async function getLocalIdByUUID (url: string, uuid: string) {
+ const res = await getVideo(url, uuid)
+
+ return res.body.id
+}
+
+// serverNumber starts from 1
+async function uploadRandomVideoOnServers (servers: ServerInfo[], serverNumber: number, additionalParams: any = {}) {
+ const server = servers.find(s => s.serverNumber === serverNumber)
+ const res = await uploadRandomVideo(server, false, additionalParams)
+
+ await waitJobs(servers)
+
+ return res
+}
+
+async function uploadRandomVideo (server: ServerInfo, wait = true, additionalParams: any = {}) {
+ const prefixName = additionalParams.prefixName || ''
+ const name = prefixName + uuidv4()
+
+ const data = Object.assign({ name }, additionalParams)
+ const res = await uploadVideo(server.url, server.accessToken, data)
+
+ if (wait) await waitJobs([ server ])
+
+ return { uuid: res.body.video.uuid, name }
+}
+
// ---------------------------------------------------------------------------
export {
getVideoDescription,
getVideoCategories,
+ uploadRandomVideo,
getVideoLicences,
videoUUIDToId,
getVideoPrivacies,
getAccountVideos,
getVideoChannelVideos,
getVideo,
+ getVideoFileMetadataUrl,
getVideoWithToken,
getVideosList,
+ removeAllVideos,
getVideosListPagination,
getVideosListSort,
removeVideo,
getVideosListWithToken,
uploadVideo,
getVideosWithFilters,
+ uploadRandomVideoOnServers,
updateVideo,
rateVideo,
viewVideo,
completeVideoCheck,
checkVideoFilesWereRemoved,
getPlaylistVideos,
- uploadVideoAndGetId
+ uploadVideoAndGetId,
+ getLocalIdByUUID,
+ getVideoIdFromUUID
}
projects / github / Chocobozzz / PeerTube.git / blobdiff