import { User, UserRole, VideoCreateResult } from '../../../../shared'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
import {
- addVideoChannel,
blockUser,
buildAbsoluteFixturePath,
cleanupTests,
})
it('Should fail with an existing channel', async function () {
- const videoChannelAttributesArg = { name: 'existing_channel', displayName: 'hello', description: 'super description' }
- await addVideoChannel(server.url, server.accessToken, videoChannelAttributesArg)
+ const attributes = { name: 'existing_channel', displayName: 'hello', description: 'super description' }
+ await server.channelsCommand.create({ attributes })
const fields = immutableAssign(baseCorrectParams, { channel: { name: 'existing_channel', displayName: 'toto' } })
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
import {
buildAbsoluteFixturePath,
+ ChannelsCommand,
cleanupTests,
createUser,
- deleteVideoChannel,
flushAndRunServer,
- getAccountVideoChannelsList,
immutableAssign,
makeGetRequest,
makePostBodyRequest,
const videoChannelPath = '/api/v1/video-channels'
let server: ServerInfo
let accessTokenUser: string
+ let command: ChannelsCommand
// ---------------------------------------------------------------
await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
accessTokenUser = await userLogin(server, user)
}
+
+ command = server.channelsCommand
})
describe('When listing a video channels', function () {
})
it('Should fail with a unknown account', async function () {
- await getAccountVideoChannelsList({ url: server.url, accountName: 'unknown', specialStatus: HttpStatusCode.NOT_FOUND_404 })
+ await server.channelsCommand.listByAccount({ accountName: 'unknown', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
})
it('Should succeed with the correct parameters', async function () {
describe('When deleting a video channel', function () {
it('Should fail with a non authenticated user', async function () {
- await deleteVideoChannel(server.url, 'coucou', 'super_channel', HttpStatusCode.UNAUTHORIZED_401)
+ await command.delete({ token: 'coucou', channelName: 'super_channel', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
})
it('Should fail with another authenticated user', async function () {
- await deleteVideoChannel(server.url, accessTokenUser, 'super_channel', HttpStatusCode.FORBIDDEN_403)
+ await command.delete({ token: accessTokenUser, channelName: 'super_channel', expectedStatus: HttpStatusCode.FORBIDDEN_403 })
})
it('Should fail with an unknown video channel id', async function () {
- await deleteVideoChannel(server.url, server.accessToken, 'super_channel2', HttpStatusCode.NOT_FOUND_404)
+ await command.delete({ channelName: 'super_channel2', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
})
it('Should succeed with the correct parameters', async function () {
- await deleteVideoChannel(server.url, server.accessToken, 'super_channel')
+ await command.delete({ channelName: 'super_channel' })
})
it('Should fail to delete the last user video channel', async function () {
- await deleteVideoChannel(server.url, server.accessToken, 'root_channel', HttpStatusCode.CONFLICT_409)
+ await command.delete({ channelName: 'root_channel', expectedStatus: HttpStatusCode.CONFLICT_409 })
})
})
ServerInfo,
updateMyUser,
updateVideo,
- updateVideoChannel,
uploadRandomVideoOnServers,
wait,
waitJobs
displayName: 'super root 2 name'
})
- await updateVideoChannel(servers[0].url, userAccessToken, 'user_1_channel', { displayName: myChannelName })
+ await servers[0].channelsCommand.update({
+ token: userAccessToken,
+ channelName: 'user_1_channel',
+ attributes: { displayName: myChannelName }
+ })
})
it('Should notify when a local channel is following one of our channel', async function () {
/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
import 'mocha'
+import { expect } from 'chai'
import {
cleanupTests,
flushAndRunServer,
} from '@shared/extra-utils'
import { VideoPrivacy } from '@shared/models'
-const expect = chai.expect
-
describe('Test redundancy constraints', function () {
let remoteServer: ServerInfo
let localServer: ServerInfo
import 'mocha'
import * as chai from 'chai'
import {
- addVideoChannel,
cleanupTests,
createUser,
- deleteVideoChannel,
flushAndRunMultipleServers,
- getVideoChannelsList,
getVideoChannelVideos,
SearchCommand,
ServerInfo,
setAccessTokensToServers,
updateMyUser,
updateVideo,
- updateVideoChannel,
uploadVideo,
userLogin,
wait,
name: 'channel1_server1',
displayName: 'Channel 1 server 1'
}
- await addVideoChannel(servers[0].url, servers[0].accessToken, channel)
+ await servers[0].channelsCommand.create({ attributes: channel })
}
{
name: 'channel1_server2',
displayName: 'Channel 1 server 2'
}
- const resChannel = await addVideoChannel(servers[1].url, userServer2Token, channel)
- channelIdServer2 = resChannel.body.videoChannel.id
+ const created = await servers[1].channelsCommand.create({ token: userServer2Token, attributes: channel })
+ channelIdServer2 = created.id
const res = await uploadVideo(servers[1].url, userServer2Token, { name: 'video 1 server 2', channelId: channelIdServer2 })
videoServer2UUID = res.body.video.uuid
})
it('Should not list this remote video channel', async function () {
- const res = await getVideoChannelsList(servers[0].url, 0, 5)
- expect(res.body.total).to.equal(3)
- expect(res.body.data).to.have.lengthOf(3)
- expect(res.body.data[0].name).to.equal('channel1_server1')
- expect(res.body.data[1].name).to.equal('user1_server1_channel')
- expect(res.body.data[2].name).to.equal('root_channel')
+ const body = await servers[0].channelsCommand.list()
+ expect(body.total).to.equal(3)
+ expect(body.data).to.have.lengthOf(3)
+ expect(body.data[0].name).to.equal('channel1_server1')
+ expect(body.data[1].name).to.equal('user1_server1_channel')
+ expect(body.data[2].name).to.equal('root_channel')
})
it('Should list video channel videos of server 2 without token', async function () {
it('Should update video channel of server 2, and refresh it on server 1', async function () {
this.timeout(60000)
- await updateVideoChannel(servers[1].url, userServer2Token, 'channel1_server2', { displayName: 'channel updated' })
+ await servers[1].channelsCommand.update({
+ token: userServer2Token,
+ channelName: 'channel1_server2',
+ attributes: { displayName: 'channel updated' }
+ })
await updateMyUser({ url: servers[1].url, accessToken: userServer2Token, displayName: 'user updated' })
await waitJobs(servers)
it('Should delete video channel of server 2, and delete it on server 1', async function () {
this.timeout(60000)
- await deleteVideoChannel(servers[1].url, userServer2Token, 'channel1_server2')
+ await servers[1].channelsCommand.delete({ token: userServer2Token, channelName: 'channel1_server2' })
await waitJobs(servers)
// Expire video
import 'mocha'
import * as chai from 'chai'
import {
- addVideoChannel,
cleanupTests,
flushAndRunMultipleServers,
getVideosList,
name: 'super_channel',
displayName: 'super channel'
}
- const resChannel = await addVideoChannel(servers[1].url, servers[1].accessToken, channelAttributes)
- const videoChannelId = resChannel.body.videoChannel.id
+ const created = await servers[1].channelsCommand.create({ attributes: channelAttributes })
+ const videoChannelId = created.id
const attributes = {
name: 'updated',
import 'mocha'
import * as chai from 'chai'
-import {
- addVideoChannel,
- cleanupTests,
- createUser,
- flushAndRunServer,
- SearchCommand,
- ServerInfo,
- setAccessTokensToServers
-} from '@shared/extra-utils'
+import { cleanupTests, createUser, flushAndRunServer, SearchCommand, ServerInfo, setAccessTokensToServers } from '@shared/extra-utils'
import { VideoChannel } from '@shared/models'
const expect = chai.expect
name: 'squall_channel',
displayName: 'Squall channel'
}
- await addVideoChannel(server.url, server.accessToken, channel)
+ await server.channelsCommand.create({ attributes: channel })
}
command = server.searchCommand
}
server = await flushAndRunServer(1, configOverride)
await setAccessTokensToServers([ server ])
+
+ command = server.pluginsCommand
})
it('Should list and search available plugins and themes', async function () {
import 'mocha'
import * as chai from 'chai'
import {
- addVideoChannel,
addVideoCommentThread,
cleanupTests,
createUser,
}
{
- const channelAttributes = {
+ const attributes = {
name: 'stats_channel',
displayName: 'My stats channel'
}
- const resChannel = await addVideoChannel(server.url, server.accessToken, channelAttributes)
- channelId = resChannel.body.videoChannel.id
+ const created = await server.channelsCommand.create({ attributes })
+ channelId = created.id
const data = await server.statsCommand.get()
flushAndRunMultipleServers,
getAccountVideos,
getMyUserInformation,
- getVideoChannelsList,
removeUser,
ServerInfo,
setAccessTokensToServers,
userLogin,
waitJobs
} from '@shared/extra-utils'
-import { User, VideoChannel } from '@shared/models'
+import { User } from '@shared/models'
const expect = chai.expect
const accountDeleted = body.data.find(a => a.name === 'user1' && a.host === 'localhost:' + servers[0].port)
expect(accountDeleted).not.to.be.undefined
- const resVideoChannels = await getVideoChannelsList(server.url, 0, 10)
- const videoChannelDeleted = resVideoChannels.body.data.find(a => {
- return a.displayName === 'Main user1 channel' && a.host === 'localhost:' + servers[0].port
- }) as VideoChannel
+ const { data } = await server.channelsCommand.list()
+ const videoChannelDeleted = data.find(a => a.displayName === 'Main user1 channel' && a.host === 'localhost:' + servers[0].port)
expect(videoChannelDeleted).not.to.be.undefined
}
const accountDeleted = body.data.find(a => a.name === 'user1' && a.host === 'localhost:' + servers[0].port)
expect(accountDeleted).to.be.undefined
- const resVideoChannels = await getVideoChannelsList(server.url, 0, 10)
- const videoChannelDeleted = resVideoChannels.body.data.find(a => {
- return a.name === 'Main user1 channel' && a.host === 'localhost:' + servers[0].port
- }) as VideoChannel
+ const { data } = await server.channelsCommand.list()
+ const videoChannelDeleted = data.find(a => a.name === 'Main user1 channel' && a.host === 'localhost:' + servers[0].port)
expect(videoChannelDeleted).to.be.undefined
}
})
getUserInformation,
getUsersList,
getUsersListPaginationAndSort,
- getVideoChannel,
getVideosList,
killallServers,
login,
})
it('Should have created the channel', async function () {
- const res = await getVideoChannel(server.url, 'my_user_15_channel')
+ const { displayName } = await server.channelsCommand.get({ channelName: 'my_user_15_channel' })
- expect(res.body.displayName).to.equal('my channel rocks')
+ expect(displayName).to.equal('my channel rocks')
})
it('Should remove me', async function () {
import * as request from 'supertest'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
import {
- addVideoChannel,
buildAbsoluteFixturePath,
checkTmpIsEmpty,
checkVideoFilesWereRemoved,
flushAndRunMultipleServers,
getLocalVideos,
getVideo,
- getVideoChannelsList,
getVideosList,
rateVideo,
removeVideo,
displayName: 'my channel',
description: 'super channel'
}
- await addVideoChannel(servers[0].url, servers[0].accessToken, videoChannel)
- const channelRes = await getVideoChannelsList(servers[0].url, 0, 1)
- videoChannelId = channelRes.body.data[0].id
+ await servers[0].channelsCommand.create({ attributes: videoChannel })
+ const { data } = await servers[0].channelsCommand.list({ start: 0, count: 1 })
+ videoChannelId = data[0].id
}
// Server 1 and server 2 follow each other
import {
cleanupTests,
createUser,
- deleteVideoChannelImage,
doubleFollow,
flushAndRunMultipleServers,
getActorImage,
getVideo,
- getVideoChannel,
getVideoChannelVideos,
setDefaultVideoChannel,
testFileExistsOrNot,
testImage,
updateVideo,
- updateVideoChannelImage,
uploadVideo,
userLogin,
wait
} from '../../../../shared/extra-utils'
-import {
- addVideoChannel,
- deleteVideoChannel,
- getAccountVideoChannelsList,
- getMyUserInformation,
- getVideoChannelsList,
- ServerInfo,
- setAccessTokensToServers,
- updateVideoChannel,
- viewVideo
-} from '../../../../shared/extra-utils/index'
+import { getMyUserInformation, ServerInfo, setAccessTokensToServers, viewVideo } from '../../../../shared/extra-utils/index'
import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
import { User, Video, VideoChannel, VideoDetails } from '../../../../shared/index'
const expect = chai.expect
async function findChannel (server: ServerInfo, channelId: number) {
- const res = await getVideoChannelsList(server.url, 0, 5, '-name')
- const videoChannel = res.body.data.find(c => c.id === channelId)
+ const body = await server.channelsCommand.list({ sort: '-name' })
- return videoChannel as VideoChannel
+ return body.data.find(c => c.id === channelId)
}
describe('Test video channels', function () {
})
it('Should have one video channel (created with root)', async () => {
- const res = await getVideoChannelsList(servers[0].url, 0, 2)
+ const body = await servers[0].channelsCommand.list({ start: 0, count: 2 })
- expect(res.body.total).to.equal(1)
- expect(res.body.data).to.be.an('array')
- expect(res.body.data).to.have.lengthOf(1)
+ expect(body.total).to.equal(1)
+ expect(body.data).to.be.an('array')
+ expect(body.data).to.have.lengthOf(1)
})
it('Should create another video channel', async function () {
description: 'super video channel description',
support: 'super video channel support text'
}
- const res = await addVideoChannel(servers[0].url, servers[0].accessToken, videoChannel)
- secondVideoChannelId = res.body.videoChannel.id
+ const created = await servers[0].channelsCommand.create({ attributes: videoChannel })
+ secondVideoChannelId = created.id
}
// The channel is 1 is propagated to servers 2
})
it('Should have two video channels when getting account channels on server 1', async function () {
- const res = await getAccountVideoChannelsList({
- url: servers[0].url,
- accountName
- })
+ const body = await servers[0].channelsCommand.listByAccount({ accountName })
+ expect(body.total).to.equal(2)
- expect(res.body.total).to.equal(2)
- expect(res.body.data).to.be.an('array')
- expect(res.body.data).to.have.lengthOf(2)
+ const videoChannels = body.data
+
+ expect(videoChannels).to.be.an('array')
+ expect(videoChannels).to.have.lengthOf(2)
- const videoChannels = res.body.data
expect(videoChannels[0].name).to.equal('root_channel')
expect(videoChannels[0].displayName).to.equal('Main root channel')
it('Should paginate and sort account channels', async function () {
{
- const res = await getAccountVideoChannelsList({
- url: servers[0].url,
+ const body = await servers[0].channelsCommand.listByAccount({
accountName,
start: 0,
count: 1,
sort: 'createdAt'
})
- expect(res.body.total).to.equal(2)
- expect(res.body.data).to.have.lengthOf(1)
+ expect(body.total).to.equal(2)
+ expect(body.data).to.have.lengthOf(1)
- const videoChannel: VideoChannel = res.body.data[0]
+ const videoChannel: VideoChannel = body.data[0]
expect(videoChannel.name).to.equal('root_channel')
}
{
- const res = await getAccountVideoChannelsList({
- url: servers[0].url,
+ const body = await servers[0].channelsCommand.listByAccount({
accountName,
start: 0,
count: 1,
sort: '-createdAt'
})
- expect(res.body.total).to.equal(2)
- expect(res.body.data).to.have.lengthOf(1)
-
- const videoChannel: VideoChannel = res.body.data[0]
- expect(videoChannel.name).to.equal('second_video_channel')
+ expect(body.total).to.equal(2)
+ expect(body.data).to.have.lengthOf(1)
+ expect(body.data[0].name).to.equal('second_video_channel')
}
{
- const res = await getAccountVideoChannelsList({
- url: servers[0].url,
+ const body = await servers[0].channelsCommand.listByAccount({
accountName,
start: 1,
count: 1,
sort: '-createdAt'
})
- expect(res.body.total).to.equal(2)
- expect(res.body.data).to.have.lengthOf(1)
-
- const videoChannel: VideoChannel = res.body.data[0]
- expect(videoChannel.name).to.equal('root_channel')
+ expect(body.total).to.equal(2)
+ expect(body.data).to.have.lengthOf(1)
+ expect(body.data[0].name).to.equal('root_channel')
}
})
it('Should have one video channel when getting account channels on server 2', async function () {
- const res = await getAccountVideoChannelsList({
- url: servers[1].url,
- accountName
- })
+ const body = await servers[1].channelsCommand.listByAccount({ accountName })
- expect(res.body.total).to.equal(1)
- expect(res.body.data).to.be.an('array')
- expect(res.body.data).to.have.lengthOf(1)
+ expect(body.total).to.equal(1)
+ expect(body.data).to.be.an('array')
+ expect(body.data).to.have.lengthOf(1)
- const videoChannels = res.body.data
- expect(videoChannels[0].name).to.equal('second_video_channel')
- expect(videoChannels[0].displayName).to.equal('second video channel')
- expect(videoChannels[0].description).to.equal('super video channel description')
- expect(videoChannels[0].support).to.equal('super video channel support text')
+ const videoChannel = body.data[0]
+ expect(videoChannel.name).to.equal('second_video_channel')
+ expect(videoChannel.displayName).to.equal('second video channel')
+ expect(videoChannel.description).to.equal('super video channel description')
+ expect(videoChannel.support).to.equal('super video channel support text')
})
it('Should list video channels', async function () {
- const res = await getVideoChannelsList(servers[0].url, 1, 1, '-name')
+ const body = await servers[0].channelsCommand.list({ start: 1, count: 1, sort: '-name' })
- expect(res.body.total).to.equal(2)
- expect(res.body.data).to.be.an('array')
- expect(res.body.data).to.have.lengthOf(1)
- expect(res.body.data[0].name).to.equal('root_channel')
- expect(res.body.data[0].displayName).to.equal('Main root channel')
+ expect(body.total).to.equal(2)
+ expect(body.data).to.be.an('array')
+ expect(body.data).to.have.lengthOf(1)
+ expect(body.data[0].name).to.equal('root_channel')
+ expect(body.data[0].displayName).to.equal('Main root channel')
})
it('Should update video channel', async function () {
support: 'support updated'
}
- await updateVideoChannel(servers[0].url, servers[0].accessToken, 'second_video_channel', videoChannelAttributes)
+ await servers[0].channelsCommand.update({ channelName: 'second_video_channel', attributes: videoChannelAttributes })
await waitJobs(servers)
})
it('Should have video channel updated', async function () {
for (const server of servers) {
- const res = await getVideoChannelsList(server.url, 0, 1, '-name')
-
- expect(res.body.total).to.equal(2)
- expect(res.body.data).to.be.an('array')
- expect(res.body.data).to.have.lengthOf(1)
- expect(res.body.data[0].name).to.equal('second_video_channel')
- expect(res.body.data[0].displayName).to.equal('video channel updated')
- expect(res.body.data[0].description).to.equal('video channel description updated')
- expect(res.body.data[0].support).to.equal('support updated')
+ const body = await server.channelsCommand.list({ start: 0, count: 1, sort: '-name' })
+
+ expect(body.total).to.equal(2)
+ expect(body.data).to.be.an('array')
+ expect(body.data).to.have.lengthOf(1)
+
+ expect(body.data[0].name).to.equal('second_video_channel')
+ expect(body.data[0].displayName).to.equal('video channel updated')
+ expect(body.data[0].description).to.equal('video channel description updated')
+ expect(body.data[0].support).to.equal('support updated')
}
})
bulkVideosSupportUpdate: true
}
- await updateVideoChannel(servers[0].url, servers[0].accessToken, 'second_video_channel', videoChannelAttributes)
+ await servers[0].channelsCommand.update({ channelName: 'second_video_channel', attributes: videoChannelAttributes })
await waitJobs(servers)
const fixture = 'avatar.png'
- await updateVideoChannelImage({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- videoChannelName: 'second_video_channel',
+ await servers[0].channelsCommand.updateImage({
+ channelName: 'second_video_channel',
fixture,
type: 'avatar'
})
const fixture = 'banner.jpg'
- await updateVideoChannelImage({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- videoChannelName: 'second_video_channel',
+ await servers[0].channelsCommand.updateImage({
+ channelName: 'second_video_channel',
fixture,
type: 'banner'
})
await waitJobs(servers)
for (const server of servers) {
- const res = await getVideoChannel(server.url, 'second_video_channel@' + servers[0].host)
- const videoChannel = res.body
+ const videoChannel = await server.channelsCommand.get({ channelName: 'second_video_channel@' + servers[0].host })
bannerPaths[server.port] = videoChannel.banner.path
await testImage(server.url, 'banner-resized', bannerPaths[server.port])
it('Should delete the video channel avatar', async function () {
this.timeout(15000)
- await deleteVideoChannelImage({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- videoChannelName: 'second_video_channel',
- type: 'avatar'
- })
+ await servers[0].channelsCommand.deleteImage({ channelName: 'second_video_channel', type: 'avatar' })
await waitJobs(servers)
it('Should delete the video channel banner', async function () {
this.timeout(15000)
- await deleteVideoChannelImage({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- videoChannelName: 'second_video_channel',
- type: 'banner'
- })
+ await servers[0].channelsCommand.deleteImage({ channelName: 'second_video_channel', type: 'banner' })
await waitJobs(servers)
})
it('Should delete video channel', async function () {
- await deleteVideoChannel(servers[0].url, servers[0].accessToken, 'second_video_channel')
+ await servers[0].channelsCommand.delete({ channelName: 'second_video_channel' })
})
it('Should have video channel deleted', async function () {
- const res = await getVideoChannelsList(servers[0].url, 0, 10)
+ const body = await servers[0].channelsCommand.list({ start: 0, count: 10 })
- expect(res.body.total).to.equal(1)
- expect(res.body.data).to.be.an('array')
- expect(res.body.data).to.have.lengthOf(1)
- expect(res.body.data[0].displayName).to.equal('Main root channel')
+ expect(body.total).to.equal(1)
+ expect(body.data).to.be.an('array')
+ expect(body.data).to.have.lengthOf(1)
+ expect(body.data[0].displayName).to.equal('Main root channel')
})
it('Should create the main channel with an uuid if there is a conflict', async function () {
{
const videoChannel = { name: 'toto_channel', displayName: 'My toto channel' }
- const res = await addVideoChannel(servers[0].url, servers[0].accessToken, videoChannel)
- totoChannel = res.body.videoChannel.id
+ const created = await servers[0].channelsCommand.create({ attributes: videoChannel })
+ totoChannel = created.id
}
{
this.timeout(10000)
{
- const res = await getAccountVideoChannelsList({
- url: servers[0].url,
- accountName,
- withStats: true
- })
-
- const channels: VideoChannel[] = res.body.data
+ const { data } = await servers[0].channelsCommand.listByAccount({ accountName, withStats: true })
- for (const channel of channels) {
+ for (const channel of data) {
expect(channel).to.haveOwnProperty('viewsPerDay')
expect(channel.viewsPerDay).to.have.length(30 + 1) // daysPrior + today
// Wait the repeatable job
await wait(8000)
- const res = await getAccountVideoChannelsList({
- url: servers[0].url,
- accountName,
- withStats: true
- })
- const channelWithView = res.body.data.find((channel: VideoChannel) => channel.id === servers[0].videoChannel.id)
+ const { data } = await servers[0].channelsCommand.listByAccount({ accountName, withStats: true })
+ const channelWithView = data.find(channel => channel.id === servers[0].videoChannel.id)
expect(channelWithView.viewsPerDay.slice(-1)[0].views).to.equal(2)
}
})
it('Should report correct videos count', async function () {
- const res = await getAccountVideoChannelsList({
- url: servers[0].url,
- accountName,
- withStats: true
- })
- const channels: VideoChannel[] = res.body.data
+ const { data } = await servers[0].channelsCommand.listByAccount({ accountName, withStats: true })
- const totoChannel = channels.find(c => c.name === 'toto_channel')
- const rootChannel = channels.find(c => c.name === 'root_channel')
+ const totoChannel = data.find(c => c.name === 'toto_channel')
+ const rootChannel = data.find(c => c.name === 'root_channel')
expect(rootChannel.videosCount).to.equal(1)
expect(totoChannel.videosCount).to.equal(0)
it('Should search among account video channels', async function () {
{
- const res = await getAccountVideoChannelsList({
- url: servers[0].url,
- accountName,
- search: 'root'
- })
- expect(res.body.total).to.equal(1)
+ const body = await servers[0].channelsCommand.listByAccount({ accountName, search: 'root' })
+ expect(body.total).to.equal(1)
- const channels = res.body.data
+ const channels = body.data
expect(channels).to.have.lengthOf(1)
}
{
- const res = await getAccountVideoChannelsList({
- url: servers[0].url,
- accountName,
- search: 'does not exist'
- })
- expect(res.body.total).to.equal(0)
+ const body = await servers[0].channelsCommand.listByAccount({ accountName, search: 'does not exist' })
+ expect(body.total).to.equal(0)
- const channels = res.body.data
+ const channels = body.data
expect(channels).to.have.lengthOf(0)
}
})
await waitJobs(servers)
for (const server of servers) {
- const res = await getAccountVideoChannelsList({
- url: server.url,
- accountName,
- sort: '-updatedAt'
- })
+ const { data } = await server.channelsCommand.listByAccount({ accountName, sort: '-updatedAt' })
- const channels: VideoChannel[] = res.body.data
- expect(channels[0].name).to.equal('toto_channel')
- expect(channels[1].name).to.equal('root_channel')
+ expect(data[0].name).to.equal('toto_channel')
+ expect(data[1].name).to.equal('root_channel')
}
await uploadVideo(servers[0].url, servers[0].accessToken, { channelId: servers[0].videoChannel.id })
await waitJobs(servers)
for (const server of servers) {
- const res = await getAccountVideoChannelsList({
- url: server.url,
- accountName,
- sort: '-updatedAt'
- })
+ const { data } = await server.channelsCommand.listByAccount({ accountName, sort: '-updatedAt' })
- const channels: VideoChannel[] = res.body.data
- expect(channels[0].name).to.equal('root_channel')
- expect(channels[1].name).to.equal('toto_channel')
+ expect(data[0].name).to.equal('root_channel')
+ expect(data[1].name).to.equal('toto_channel')
}
})
import * as chai from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
import {
- addVideoChannel,
checkPlaylistFilesWereRemoved,
cleanupTests,
createUser,
- deleteVideoChannel,
doubleFollow,
flushAndRunMultipleServers,
generateUserAccessToken,
it('Should delete a channel and put the associated playlist in private mode', async function () {
this.timeout(30000)
- const res = await addVideoChannel(servers[0].url, servers[0].accessToken, { name: 'super_channel', displayName: 'super channel' })
- const videoChannelId = res.body.videoChannel.id
+ const channel = await servers[0].channelsCommand.create({ attributes: { name: 'super_channel', displayName: 'super channel' } })
const playlistCreated = await commands[0].create({
attributes: {
displayName: 'channel playlist',
privacy: VideoPlaylistPrivacy.PUBLIC,
- videoChannelId
+ videoChannelId: channel.id
}
})
await waitJobs(servers)
- await deleteVideoChannel(servers[0].url, servers[0].accessToken, 'super_channel')
+ await servers[0].channelsCommand.delete({ channelName: 'super_channel' })
await waitJobs(servers)
import { expect } from 'chai'
import { Video, VideoDetails } from '../../../shared'
import {
- addVideoChannel,
areHttpImportTestsDisabled,
buildAbsoluteFixturePath,
cleanupTests,
userAccessToken = await userLogin(server, { username: 'user_1', password: 'super_password' })
{
- const args = { name: 'user_channel', displayName: 'User channel', support: 'super support text' }
- await addVideoChannel(server.url, userAccessToken, args)
+ const attributes = { name: 'user_channel', displayName: 'User channel', support: 'super support text' }
+ await server.channelsCommand.create({ token: userAccessToken, attributes })
}
cliCommand = server.cliCommand
import 'mocha'
import {
- addVideoChannel,
addVideoCommentThread,
cleanupTests,
createUser,
flushAndRunServer,
getVideo,
- getVideoChannelsList,
getVideosList,
killallServers,
makeActivityPubGetRequest,
displayName: 'second video channel',
description: 'super video channel description'
}
- await addVideoChannel(server.url, server.accessToken, videoChannel)
+ await server.channelsCommand.create({ attributes: videoChannel })
// Create comments
const text = 'my super first comment'
})
it('Should have updated video channels url', async function () {
- const res = await getVideoChannelsList(server.url, 0, 5, '-name')
- expect(res.body.total).to.equal(3)
+ const { data, total } = await server.channelsCommand.list({ sort: '-name' })
+ expect(total).to.equal(3)
- for (const channel of res.body.data) {
+ for (const channel of data) {
const { body } = await makeActivityPubGetRequest(server.url, '/video-channels/' + channel.name)
expect(body.id).to.equal('http://localhost:9002/video-channels/' + channel.name)
setAccessTokensToServers,
setDefaultVideoChannel,
updateMyUser,
- updateVideoChannel,
uploadVideo,
waitJobs
} from '../../shared/extra-utils'
await setDefaultVideoChannel(servers)
- await updateVideoChannel(servers[0].url, servers[0].accessToken, servers[0].videoChannel.name, { description: channelDescription })
+ await servers[0].channelsCommand.update({
+ channelName: servers[0].videoChannel.name,
+ attributes: { description: channelDescription }
+ })
// Video
import 'mocha'
import * as chai from 'chai'
+import { HttpStatusCode } from '@shared/core-utils'
import {
- addVideoChannel,
cleanupTests,
createUser,
flushAndRunServer,
uploadVideo
} from '../../shared/extra-utils'
import { VideoPrivacy } from '../../shared/models/videos'
-import { HttpStatusCode } from '@shared/core-utils'
const expect = chai.expect
await uploadVideo(server.url, server.accessToken, { name: 'video 2', nsfw: false })
await uploadVideo(server.url, server.accessToken, { name: 'video 3', privacy: VideoPrivacy.PRIVATE })
- await addVideoChannel(server.url, server.accessToken, { name: 'channel1', displayName: 'channel 1' })
- await addVideoChannel(server.url, server.accessToken, { name: 'channel2', displayName: 'channel 2' })
+ await server.channelsCommand.create({ attributes: { name: 'channel1', displayName: 'channel 1' } })
+ await server.channelsCommand.create({ attributes: { name: 'channel2', displayName: 'channel 2' } })
await createUser({ url: server.url, accessToken: server.accessToken, username: 'user1', password: 'password' })
await createUser({ url: server.url, accessToken: server.accessToken, username: 'user2', password: 'password' })
BlacklistCommand,
CaptionsCommand,
ChangeOwnershipCommand,
+ ChannelsCommand,
HistoryCommand,
ImportsCommand,
LiveCommand,
historyCommand?: HistoryCommand
importsCommand?: ImportsCommand
streamingPlaylistsCommand?: StreamingPlaylistsCommand
+ channelsCommand?: ChannelsCommand
}
function parallelTests () {
server.historyCommand = new HistoryCommand(server)
server.importsCommand = new ImportsCommand(server)
server.streamingPlaylistsCommand = new StreamingPlaylistsCommand(server)
+ server.channelsCommand = new ChannelsCommand(server)
res(server)
})
+import { isAbsolute, join } from 'path'
import { HttpStatusCode } from '@shared/core-utils'
+import { root } from '../miscs'
import {
makeDeleteRequest,
makeGetRequest,
})
}
+ protected updateImageRequest (options: InternalCommonCommandOptions & {
+ fixture: string
+ fieldname: string
+ }) {
+ let filePath = ''
+ if (isAbsolute(options.fixture)) {
+ filePath = options.fixture
+ } else {
+ filePath = join(root(), 'server', 'tests', 'fixtures', options.fixture)
+ }
+
+ return this.postUploadRequest({
+ ...options,
+
+ fields: {},
+ attaches: { [options.fieldname]: filePath }
+ })
+ }
+
private buildCommonRequestOptions (options: InternalCommonCommandOptions) {
const { path } = options
--- /dev/null
+import { pick } from 'lodash'
+import { ResultList, VideoChannel, VideoChannelCreateResult } from '@shared/models'
+import { HttpStatusCode } from '../../core-utils/miscs/http-error-codes'
+import { VideoChannelCreate } from '../../models/videos/channel/video-channel-create.model'
+import { VideoChannelUpdate } from '../../models/videos/channel/video-channel-update.model'
+import { unwrapBody } from '../requests'
+import { AbstractCommand, OverrideCommandOptions } from '../shared'
+
+export class ChannelsCommand extends AbstractCommand {
+
+ list (options: OverrideCommandOptions & {
+ start?: number
+ count?: number
+ sort?: string
+ withStats?: boolean
+ } = {}) {
+ const path = '/api/v1/video-channels'
+
+ return this.getRequestBody<ResultList<VideoChannel>>({
+ ...options,
+
+ path,
+ query: pick(options, [ 'start', 'count', 'sort', 'withStats' ]),
+ implicitToken: false,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })
+ }
+
+ listByAccount (options: OverrideCommandOptions & {
+ accountName: string
+ start?: number
+ count?: number
+ sort?: string
+ withStats?: boolean
+ search?: string
+ }) {
+ const { accountName, sort = 'createdAt' } = options
+ const path = '/api/v1/accounts/' + accountName + '/video-channels'
+
+ return this.getRequestBody<ResultList<VideoChannel>>({
+ ...options,
+
+ path,
+ query: { sort, ...pick(options, [ 'start', 'count', 'withStats', 'search' ]) },
+ implicitToken: false,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })
+ }
+
+ async create (options: OverrideCommandOptions & {
+ attributes: VideoChannelCreate
+ }) {
+ const path = '/api/v1/video-channels/'
+
+ // Default attributes
+ const defaultAttributes = {
+ displayName: 'my super video channel',
+ description: 'my super channel description',
+ support: 'my super channel support'
+ }
+ const attributes = { ...defaultAttributes, ...options.attributes }
+
+ const body = await unwrapBody<{ videoChannel: VideoChannelCreateResult }>(this.postBodyRequest({
+ ...options,
+
+ path,
+ fields: attributes,
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ }))
+
+ return body.videoChannel
+ }
+
+ update (options: OverrideCommandOptions & {
+ channelName: string
+ attributes: VideoChannelUpdate
+ }) {
+ const { channelName, attributes } = options
+ const path = '/api/v1/video-channels/' + channelName
+
+ return this.putBodyRequest({
+ ...options,
+
+ path,
+ fields: attributes,
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+ })
+ }
+
+ delete (options: OverrideCommandOptions & {
+ channelName: string
+ }) {
+ const path = '/api/v1/video-channels/' + options.channelName
+
+ return this.deleteRequest({
+ ...options,
+
+ path,
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+ })
+ }
+
+ get (options: OverrideCommandOptions & {
+ channelName: string
+ }) {
+ const path = '/api/v1/video-channels/' + options.channelName
+
+ return this.getRequestBody<VideoChannel>({
+ ...options,
+
+ path,
+ implicitToken: false,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })
+ }
+
+ updateImage (options: OverrideCommandOptions & {
+ fixture: string
+ channelName: string | number
+ type: 'avatar' | 'banner'
+ }) {
+ const { channelName, fixture, type } = options
+
+ const path = `/api/v1/video-channels/${channelName}/${type}/pick`
+
+ return this.updateImageRequest({
+ ...options,
+
+ path,
+ fixture,
+ fieldname: type + 'file',
+
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.OK_200
+ })
+ }
+
+ deleteImage (options: OverrideCommandOptions & {
+ channelName: string | number
+ type: 'avatar' | 'banner'
+ }) {
+ const { channelName, type } = options
+
+ const path = `/api/v1/video-channels/${channelName}/${type}`
+
+ return this.deleteRequest({
+ ...options,
+
+ path,
+ implicitToken: true,
+ defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
+ })
+ }
+}
--- /dev/null
+import { User } from '../../models/users/user.model'
+import { ServerInfo } from '../server/servers'
+import { getMyUserInformation } from '../users/users'
+
+function setDefaultVideoChannel (servers: ServerInfo[]) {
+ const tasks: Promise<any>[] = []
+
+ for (const server of servers) {
+ const p = getMyUserInformation(server.url, server.accessToken)
+ .then(res => { server.videoChannel = (res.body as User).videoChannels[0] })
+
+ tasks.push(p)
+ }
+
+ return Promise.all(tasks)
+}
+
+export {
+ setDefaultVideoChannel
+}
export * from './blacklist-command'
-export * from './captions'
export * from './captions-command'
+export * from './captions'
export * from './change-ownership-command'
+export * from './channels'
+export * from './channels-command'
export * from './history-command'
export * from './imports-command'
export * from './live-command'
export * from './services-command'
export * from './streaming-playlists-command'
export * from './streaming-playlists'
-export * from './video-channels'
export * from './video-comments'
export * from './videos'
+++ /dev/null
-/* eslint-disable @typescript-eslint/no-floating-promises */
-
-import * as request from 'supertest'
-import { VideoChannelUpdate } from '../../models/videos/channel/video-channel-update.model'
-import { VideoChannelCreate } from '../../models/videos/channel/video-channel-create.model'
-import { makeDeleteRequest, makeGetRequest, updateImageRequest } from '../requests/requests'
-import { ServerInfo } from '../server/servers'
-import { MyUser, User } from '../../models/users/user.model'
-import { getMyUserInformation } from '../users/users'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-
-function getVideoChannelsList (url: string, start: number, count: number, sort?: string, withStats?: boolean) {
- const path = '/api/v1/video-channels'
-
- const req = request(url)
- .get(path)
- .query({ start: start })
- .query({ count: count })
-
- if (sort) req.query({ sort })
- if (withStats) req.query({ withStats })
-
- return req.set('Accept', 'application/json')
- .expect(HttpStatusCode.OK_200)
- .expect('Content-Type', /json/)
-}
-
-function getAccountVideoChannelsList (parameters: {
- url: string
- accountName: string
- start?: number
- count?: number
- sort?: string
- specialStatus?: HttpStatusCode
- withStats?: boolean
- search?: string
-}) {
- const {
- url,
- accountName,
- start,
- count,
- sort = 'createdAt',
- specialStatus = HttpStatusCode.OK_200,
- withStats = false,
- search
- } = parameters
-
- const path = '/api/v1/accounts/' + accountName + '/video-channels'
-
- return makeGetRequest({
- url,
- path,
- query: {
- start,
- count,
- sort,
- withStats,
- search
- },
- statusCodeExpected: specialStatus
- })
-}
-
-function addVideoChannel (
- url: string,
- token: string,
- videoChannelAttributesArg: VideoChannelCreate,
- expectedStatus = HttpStatusCode.OK_200
-) {
- const path = '/api/v1/video-channels/'
-
- // Default attributes
- let attributes = {
- displayName: 'my super video channel',
- description: 'my super channel description',
- support: 'my super channel support'
- }
- attributes = Object.assign(attributes, videoChannelAttributesArg)
-
- return request(url)
- .post(path)
- .send(attributes)
- .set('Accept', 'application/json')
- .set('Authorization', 'Bearer ' + token)
- .expect(expectedStatus)
-}
-
-function updateVideoChannel (
- url: string,
- token: string,
- channelName: string,
- attributes: VideoChannelUpdate,
- expectedStatus = HttpStatusCode.NO_CONTENT_204
-) {
- const body: any = {}
- const path = '/api/v1/video-channels/' + channelName
-
- if (attributes.displayName) body.displayName = attributes.displayName
- if (attributes.description) body.description = attributes.description
- if (attributes.support) body.support = attributes.support
- if (attributes.bulkVideosSupportUpdate) body.bulkVideosSupportUpdate = attributes.bulkVideosSupportUpdate
-
- return request(url)
- .put(path)
- .send(body)
- .set('Accept', 'application/json')
- .set('Authorization', 'Bearer ' + token)
- .expect(expectedStatus)
-}
-
-function deleteVideoChannel (url: string, token: string, channelName: string, expectedStatus = HttpStatusCode.NO_CONTENT_204) {
- const path = '/api/v1/video-channels/' + channelName
-
- return request(url)
- .delete(path)
- .set('Accept', 'application/json')
- .set('Authorization', 'Bearer ' + token)
- .expect(expectedStatus)
-}
-
-function getVideoChannel (url: string, channelName: string) {
- const path = '/api/v1/video-channels/' + channelName
-
- return request(url)
- .get(path)
- .set('Accept', 'application/json')
- .expect(HttpStatusCode.OK_200)
- .expect('Content-Type', /json/)
-}
-
-function updateVideoChannelImage (options: {
- url: string
- accessToken: string
- fixture: string
- videoChannelName: string | number
- type: 'avatar' | 'banner'
-}) {
- const path = `/api/v1/video-channels/${options.videoChannelName}/${options.type}/pick`
-
- return updateImageRequest({ ...options, path, fieldname: options.type + 'file' })
-}
-
-function deleteVideoChannelImage (options: {
- url: string
- accessToken: string
- videoChannelName: string | number
- type: 'avatar' | 'banner'
-}) {
- const path = `/api/v1/video-channels/${options.videoChannelName}/${options.type}`
-
- return makeDeleteRequest({
- url: options.url,
- token: options.accessToken,
- path,
- statusCodeExpected: 204
- })
-}
-
-function setDefaultVideoChannel (servers: ServerInfo[]) {
- const tasks: Promise<any>[] = []
-
- for (const server of servers) {
- const p = getMyUserInformation(server.url, server.accessToken)
- .then(res => { server.videoChannel = (res.body as User).videoChannels[0] })
-
- tasks.push(p)
- }
-
- return Promise.all(tasks)
-}
-
-async function getDefaultVideoChannel (url: string, token: string) {
- const res = await getMyUserInformation(url, token)
-
- return (res.body as MyUser).videoChannels[0].id
-}
-
-// ---------------------------------------------------------------------------
-
-export {
- updateVideoChannelImage,
- getVideoChannelsList,
- getAccountVideoChannelsList,
- addVideoChannel,
- updateVideoChannel,
- deleteVideoChannel,
- getVideoChannel,
- setDefaultVideoChannel,
- deleteVideoChannelImage,
- getDefaultVideoChannel
-}
+export * from './video-channel-create-result.model'
export * from './video-channel-create.model'
export * from './video-channel-update.model'
export * from './video-channel.model'
--- /dev/null
+export interface VideoChannelCreateResult {
+ id: number
+}
projects / github / Chocobozzz / PeerTube.git / commitdiff
