forks/peertube
1
0
Fork 0
Code Releases Activity

Introduce channels command

Browse source
This commit is contained in:
Chocobozzz 2021-07-09 11:21:30 +02:00
parent 57f879a540
commit a54618880c
No known key found for this signature in database
GPG key ID: 583A612D890159BE
26 changed files with 363 additions and 440 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
server/tests/api/check-params/users.ts
View file

@ -5,7 +5,6 @@ import { omit } from 'lodash'
import { User, UserRole, VideoCreateResult } from '../../../../shared'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
import {
addVideoChannel,
blockUser,
buildAbsoluteFixturePath,
cleanupTests,
@ -1041,8 +1040,8 @@ describe('Test users API validators', function () {
})
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' } })

18
server/tests/api/check-params/video-channels.ts
View file

@ -6,11 +6,10 @@ import { omit } from 'lodash'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
import {
buildAbsoluteFixturePath,
ChannelsCommand,
cleanupTests,
createUser,
deleteVideoChannel,
flushAndRunServer,
getAccountVideoChannelsList,
immutableAssign,
makeGetRequest,
makePostBodyRequest,
@ -33,6 +32,7 @@ describe('Test video channels API validator', function () {
const videoChannelPath = '/api/v1/video-channels'
let server: ServerInfo
let accessTokenUser: string
let command: ChannelsCommand
// ---------------------------------------------------------------
@ -52,6 +52,8 @@ describe('Test video channels API validator', function () {
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 () {
@ -84,7 +86,7 @@ describe('Test video channels API validator', 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 () {
@ -327,23 +329,23 @@ describe('Test video channels API validator', 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 })
})
})

7
server/tests/api/notifications/user-notifications.ts
View file

@ -17,7 +17,6 @@ import {
ServerInfo,
updateMyUser,
updateVideo,
updateVideoChannel,
uploadRandomVideoOnServers,
wait,
waitJobs
@ -404,7 +403,11 @@ describe('Test user notifications', function () {
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 () {

3
server/tests/api/redundancy/redundancy-constraints.ts
View file

@ -1,6 +1,7 @@
/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
import 'mocha'
import { expect } from 'chai'
import {
cleanupTests,
flushAndRunServer,
@ -15,8 +16,6 @@ import {
} from '@shared/extra-utils'
import { VideoPrivacy } from '@shared/models'
const expect = chai.expect
describe('Test redundancy constraints', function () {
let remoteServer: ServerInfo
let localServer: ServerInfo

30
server/tests/api/search/search-activitypub-video-channels.ts
View file

@ -3,19 +3,15 @@
import 'mocha'
import * as chai from 'chai'
import {
addVideoChannel,
cleanupTests,
createUser,
deleteVideoChannel,
flushAndRunMultipleServers,
getVideoChannelsList,
getVideoChannelVideos,
SearchCommand,
ServerInfo,
setAccessTokensToServers,
updateMyUser,
updateVideo,
updateVideoChannel,
uploadVideo,
userLogin,
wait,
@ -45,7 +41,7 @@ describe('Test ActivityPub video channels search', function () {
name: 'channel1_server1',
displayName: 'Channel 1 server 1'
}
await addVideoChannel(servers[0].url, servers[0].accessToken, channel)
await servers[0].channelsCommand.create({ attributes: channel })
}
{
@ -57,8 +53,8 @@ describe('Test ActivityPub video channels search', function () {
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
@ -143,12 +139,12 @@ describe('Test ActivityPub video channels search', function () {
})
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 () {
@ -171,7 +167,11 @@ describe('Test ActivityPub video channels search', 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)
@ -217,7 +217,7 @@ describe('Test ActivityPub video channels search', function () {
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

5
server/tests/api/search/search-activitypub-videos.ts
View file

@ -3,7 +3,6 @@
import 'mocha'
import * as chai from 'chai'
import {
addVideoChannel,
cleanupTests,
flushAndRunMultipleServers,
getVideosList,
@ -123,8 +122,8 @@ describe('Test ActivityPub videos search', function () {
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',

12
server/tests/api/search/search-channels.ts
View file

@ -2,15 +2,7 @@
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
@ -32,7 +24,7 @@ describe('Test channels search', function () {
name: 'squall_channel',
displayName: 'Squall channel'
}
await addVideoChannel(server.url, server.accessToken, channel)
await server.channelsCommand.create({ attributes: channel })
}
command = server.searchCommand

2
server/tests/api/server/plugins.ts
View file

@ -37,6 +37,8 @@ describe('Test plugins', function () {
}
server = await flushAndRunServer(1, configOverride)
await setAccessTokensToServers([ server ])
command = server.pluginsCommand
})
it('Should list and search available plugins and themes', async function () {

7
server/tests/api/server/stats.ts
View file

@ -3,7 +3,6 @@
import 'mocha'
import * as chai from 'chai'
import {
addVideoChannel,
addVideoCommentThread,
cleanupTests,
createUser,
@ -143,12 +142,12 @@ describe('Test stats (excluding redundancy)', function () {
}
{
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()

15
server/tests/api/users/users-multiple-servers.ts
View file

@ -12,7 +12,6 @@ import {
flushAndRunMultipleServers,
getAccountVideos,
getMyUserInformation,
getVideoChannelsList,
removeUser,
ServerInfo,
setAccessTokensToServers,
@ -23,7 +22,7 @@ import {
userLogin,
waitJobs
} from '@shared/extra-utils'
import { User, VideoChannel } from '@shared/models'
import { User } from '@shared/models'
const expect = chai.expect
@ -199,10 +198,8 @@ describe('Test users with multiple servers', function () {
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
}
@ -216,10 +213,8 @@ describe('Test users with multiple servers', function () {
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
}
})

5
server/tests/api/users/users.ts
View file

@ -18,7 +18,6 @@ import {
getUserInformation,
getUsersList,
getUsersListPaginationAndSort,
getVideoChannel,
getVideosList,
killallServers,
login,
@ -864,9 +863,9 @@ describe('Test users', function () {
})
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 () {

8
server/tests/api/videos/multiple-servers.ts
View file

@ -5,7 +5,6 @@ import * as chai from 'chai'
import * as request from 'supertest'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
import {
addVideoChannel,
buildAbsoluteFixturePath,
checkTmpIsEmpty,
checkVideoFilesWereRemoved,
@ -17,7 +16,6 @@ import {
flushAndRunMultipleServers,
getLocalVideos,
getVideo,
getVideoChannelsList,
getVideosList,
rateVideo,
removeVideo,
@ -64,9 +62,9 @@ describe('Test multiple servers', function () {
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

247
server/tests/api/videos/video-channels.ts
View file

@ -7,43 +7,29 @@ import { ACTOR_IMAGES_SIZE } from '@server/initializers/constants'
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 () {
@ -69,11 +55,11 @@ 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 () {
@ -86,8 +72,8 @@ describe('Test video channels', 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
@ -120,16 +106,14 @@ describe('Test video channels', function () {
})
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')
@ -141,79 +125,69 @@ describe('Test video channels', function () {
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 () {
@ -225,22 +199,23 @@ describe('Test video channels', 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')
const body = await server.channelsCommand.list({ start: 0, 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('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')
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')
}
})
@ -261,7 +236,7 @@ describe('Test video channels', function () {
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)
@ -278,10 +253,8 @@ describe('Test video channels', function () {
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'
})
@ -306,10 +279,8 @@ describe('Test video channels', function () {
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'
})
@ -317,8 +288,7 @@ describe('Test video channels', function () {
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])
@ -333,12 +303,7 @@ describe('Test video channels', function () {
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)
@ -353,12 +318,7 @@ describe('Test video channels', function () {
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)
@ -411,23 +371,23 @@ describe('Test video channels', function () {
})
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
}
{
@ -444,15 +404,9 @@ describe('Test video channels', function () {
this.timeout(10000)
{
const res = await getAccountVideoChannelsList({
url: servers[0].url,
accountName,
withStats: true
})
const { data } = await servers[0].channelsCommand.listByAccount({ accountName, withStats: true })
const channels: VideoChannel[] = res.body.data
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
@ -471,26 +425,17 @@ describe('Test video channels', function () {
// 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)
@ -498,26 +443,18 @@ describe('Test video channels', function () {
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)
}
})
@ -529,30 +466,20 @@ describe('Test video channels', function () {
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')
}
})

9
server/tests/api/videos/video-playlists.ts
View file

@ -4,11 +4,9 @@ import 'mocha'
import * as chai from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
import {
addVideoChannel,
checkPlaylistFilesWereRemoved,
cleanupTests,
createUser,
deleteVideoChannel,
doubleFollow,
flushAndRunMultipleServers,
generateUserAccessToken,
@ -1096,20 +1094,19 @@ describe('Test video playlists', function () {
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)

5
server/tests/cli/peertube.ts
View file

@ -4,7 +4,6 @@ import 'mocha'
import { expect } from 'chai'
import { Video, VideoDetails } from '../../../shared'
import {
addVideoChannel,
areHttpImportTestsDisabled,
buildAbsoluteFixturePath,
cleanupTests,
@ -44,8 +43,8 @@ describe('Test CLI wrapper', function () {
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

10
server/tests/cli/update-host.ts
View file

@ -2,13 +2,11 @@
import 'mocha'
import {
addVideoChannel,
addVideoCommentThread,
cleanupTests,
createUser,
flushAndRunServer,
getVideo,
getVideoChannelsList,
getVideosList,
killallServers,
makeActivityPubGetRequest,
@ -53,7 +51,7 @@ describe('Test update host scripts', function () {
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'
@ -91,10 +89,10 @@ describe('Test update host scripts', function () {
})
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)

6
server/tests/client.ts
View file

@ -16,7 +16,6 @@ import {
setAccessTokensToServers,
setDefaultVideoChannel,
updateMyUser,
updateVideoChannel,
uploadVideo,
waitJobs
} from '../../shared/extra-utils'
@ -63,7 +62,10 @@ describe('Test a client controllers', function () {
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

7
server/tests/misc-endpoints.ts
View file

@ -2,8 +2,8 @@
import 'mocha'
import * as chai from 'chai'
import { HttpStatusCode } from '@shared/core-utils'
import {
addVideoChannel,
cleanupTests,
createUser,
flushAndRunServer,
@ -13,7 +13,6 @@ import {
uploadVideo
} from '../../shared/extra-utils'
import { VideoPrivacy } from '../../shared/models/videos'
import { HttpStatusCode } from '@shared/core-utils'
const expect = chai.expect
@ -171,8 +170,8 @@ describe('Test misc endpoints', function () {
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' })

3
shared/extra-utils/server/servers.ts
View file

@ -22,6 +22,7 @@ import {
BlacklistCommand,
CaptionsCommand,
ChangeOwnershipCommand,
ChannelsCommand,
HistoryCommand,
ImportsCommand,
LiveCommand,
@ -119,6 +120,7 @@ interface ServerInfo {
historyCommand?: HistoryCommand
importsCommand?: ImportsCommand
streamingPlaylistsCommand?: StreamingPlaylistsCommand
channelsCommand?: ChannelsCommand
}
function parallelTests () {
@ -353,6 +355,7 @@ async function runServer (server: ServerInfo, configOverrideArg?: any, args = []
server.historyCommand = new HistoryCommand(server)
server.importsCommand = new ImportsCommand(server)
server.streamingPlaylistsCommand = new StreamingPlaylistsCommand(server)
server.channelsCommand = new ChannelsCommand(server)
res(server)
})

21
shared/extra-utils/shared/abstract-command.ts
View file

@ -1,4 +1,6 @@
import { isAbsolute, join } from 'path'
import { HttpStatusCode } from '@shared/core-utils'
import { root } from '../miscs'
import {
makeDeleteRequest,
makeGetRequest,
@ -146,6 +148,25 @@ abstract class AbstractCommand {
})
}
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

157
shared/extra-utils/videos/channels-command.ts Normal file
View file

@ -0,0 +1,157 @@
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
})
}
}

20
shared/extra-utils/videos/channels.ts Normal file
View file

@ -0,0 +1,20 @@
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
}

5
shared/extra-utils/videos/index.ts
View file

@ -1,7 +1,9 @@
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'
@ -11,6 +13,5 @@ export * from './playlists'
export * from './services-command'
export * from './streaming-playlists-command'
export * from './streaming-playlists'
export * from './video-channels'
export * from './video-comments'
export * from './videos'

192
shared/extra-utils/videos/video-channels.ts
View file

@ -1,192 +0,0 @@
/* 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
}

1
shared/models/videos/channel/index.ts
View file

@ -1,3 +1,4 @@
export * from './video-channel-create-result.model'
export * from './video-channel-create.model'
export * from './video-channel-update.model'
export * from './video-channel.model'

3
shared/models/videos/channel/video-channel-create-result.model.ts Normal file
View file

@ -0,0 +1,3 @@
export interface VideoChannelCreateResult {
id: number
}