1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
|
/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
import 'mocha'
import * as chai from 'chai'
import * as libxmljs from 'libxmljs'
import {
addAccountToAccountBlocklist,
addAccountToServerBlocklist,
removeAccountFromServerBlocklist
} from '@shared/extra-utils/users/blocklist'
import { VideoPrivacy } from '@shared/models'
import {
cleanupTests,
createUser,
doubleFollow,
flushAndRunMultipleServers,
getJSONfeed,
getMyUserInformation,
getXMLfeed,
ServerInfo,
setAccessTokensToServers,
uploadVideo,
uploadVideoAndGetId,
userLogin
} from '../../../shared/extra-utils'
import { waitJobs } from '../../../shared/extra-utils/server/jobs'
import { addVideoCommentThread } from '../../../shared/extra-utils/videos/video-comments'
import { User } from '../../../shared/models/users'
chai.use(require('chai-xml'))
chai.use(require('chai-json-schema'))
chai.config.includeStack = true
const expect = chai.expect
describe('Test syndication feeds', () => {
let servers: ServerInfo[] = []
let userAccessToken: string
let rootAccountId: number
let rootChannelId: number
let userAccountId: number
let userChannelId: number
before(async function () {
this.timeout(120000)
// Run servers
servers = await flushAndRunMultipleServers(2)
await setAccessTokensToServers(servers)
await doubleFollow(servers[0], servers[1])
{
const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
const user: User = res.body
rootAccountId = user.account.id
rootChannelId = user.videoChannels[0].id
}
{
const attr = { username: 'john', password: 'password' }
await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: attr.username, password: attr.password })
userAccessToken = await userLogin(servers[0], attr)
const res = await getMyUserInformation(servers[0].url, userAccessToken)
const user: User = res.body
userAccountId = user.account.id
userChannelId = user.videoChannels[0].id
}
{
await uploadVideo(servers[0].url, userAccessToken, { name: 'user video' })
}
{
const videoAttributes = {
name: 'my super name for server 1',
description: 'my super description for server 1',
fixture: 'video_short.webm'
}
const res = await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
const videoId = res.body.video.id
await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoId, 'super comment 1')
await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoId, 'super comment 2')
}
{
const videoAttributes = { name: 'unlisted video', privacy: VideoPrivacy.UNLISTED }
const res = await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
const videoId = res.body.video.id
await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoId, 'comment on unlisted video')
}
await waitJobs(servers)
})
describe('All feed', function () {
it('Should be well formed XML (covers RSS 2.0 and ATOM 1.0 endpoints)', async function () {
for (const feed of [ 'video-comments' as 'video-comments', 'videos' as 'videos' ]) {
const rss = await getXMLfeed(servers[0].url, feed)
expect(rss.text).xml.to.be.valid()
const atom = await getXMLfeed(servers[0].url, feed, 'atom')
expect(atom.text).xml.to.be.valid()
}
})
it('Should be well formed JSON (covers JSON feed 1.0 endpoint)', async function () {
for (const feed of [ 'video-comments' as 'video-comments', 'videos' as 'videos' ]) {
const json = await getJSONfeed(servers[0].url, feed)
expect(JSON.parse(json.text)).to.be.jsonSchema({ type: 'object' })
}
})
})
describe('Videos feed', function () {
it('Should contain a valid enclosure (covers RSS 2.0 endpoint)', async function () {
for (const server of servers) {
const rss = await getXMLfeed(server.url, 'videos')
const xmlDoc = libxmljs.parseXmlString(rss.text)
const xmlEnclosure = xmlDoc.get('/rss/channel/item/enclosure')
expect(xmlEnclosure).to.exist
expect(xmlEnclosure.attr('type').value()).to.be.equal('application/x-bittorrent')
expect(xmlEnclosure.attr('length').value()).to.be.equal('218910')
expect(xmlEnclosure.attr('url').value()).to.contain('720.torrent')
}
})
it('Should contain a valid \'attachments\' object (covers JSON feed 1.0 endpoint)', async function () {
for (const server of servers) {
const json = await getJSONfeed(server.url, 'videos')
const jsonObj = JSON.parse(json.text)
expect(jsonObj.items.length).to.be.equal(2)
expect(jsonObj.items[0].attachments).to.exist
expect(jsonObj.items[0].attachments.length).to.be.eq(1)
expect(jsonObj.items[0].attachments[0].mime_type).to.be.eq('application/x-bittorrent')
expect(jsonObj.items[0].attachments[0].size_in_bytes).to.be.eq(218910)
expect(jsonObj.items[0].attachments[0].url).to.contain('720.torrent')
}
})
it('Should filter by account', async function () {
{
const json = await getJSONfeed(servers[0].url, 'videos', { accountId: rootAccountId })
const jsonObj = JSON.parse(json.text)
expect(jsonObj.items.length).to.be.equal(1)
expect(jsonObj.items[0].title).to.equal('my super name for server 1')
expect(jsonObj.items[0].author.name).to.equal('root')
}
{
const json = await getJSONfeed(servers[0].url, 'videos', { accountId: userAccountId })
const jsonObj = JSON.parse(json.text)
expect(jsonObj.items.length).to.be.equal(1)
expect(jsonObj.items[0].title).to.equal('user video')
expect(jsonObj.items[0].author.name).to.equal('john')
}
for (const server of servers) {
{
const json = await getJSONfeed(server.url, 'videos', { accountName: 'root@localhost:' + servers[0].port })
const jsonObj = JSON.parse(json.text)
expect(jsonObj.items.length).to.be.equal(1)
expect(jsonObj.items[0].title).to.equal('my super name for server 1')
}
{
const json = await getJSONfeed(server.url, 'videos', { accountName: 'john@localhost:' + servers[0].port })
const jsonObj = JSON.parse(json.text)
expect(jsonObj.items.length).to.be.equal(1)
expect(jsonObj.items[0].title).to.equal('user video')
}
}
})
it('Should filter by video channel', async function () {
{
const json = await getJSONfeed(servers[0].url, 'videos', { videoChannelId: rootChannelId })
const jsonObj = JSON.parse(json.text)
expect(jsonObj.items.length).to.be.equal(1)
expect(jsonObj.items[0].title).to.equal('my super name for server 1')
expect(jsonObj.items[0].author.name).to.equal('root')
}
{
const json = await getJSONfeed(servers[0].url, 'videos', { videoChannelId: userChannelId })
const jsonObj = JSON.parse(json.text)
expect(jsonObj.items.length).to.be.equal(1)
expect(jsonObj.items[0].title).to.equal('user video')
expect(jsonObj.items[0].author.name).to.equal('john')
}
for (const server of servers) {
{
const json = await getJSONfeed(server.url, 'videos', { videoChannelName: 'root_channel@localhost:' + servers[0].port })
const jsonObj = JSON.parse(json.text)
expect(jsonObj.items.length).to.be.equal(1)
expect(jsonObj.items[0].title).to.equal('my super name for server 1')
}
{
const json = await getJSONfeed(server.url, 'videos', { videoChannelName: 'john_channel@localhost:' + servers[0].port })
const jsonObj = JSON.parse(json.text)
expect(jsonObj.items.length).to.be.equal(1)
expect(jsonObj.items[0].title).to.equal('user video')
}
}
})
})
describe('Video comments feed', function () {
it('Should contain valid comments (covers JSON feed 1.0 endpoint) and not from unlisted videos', async function () {
for (const server of servers) {
const json = await getJSONfeed(server.url, 'video-comments')
const jsonObj = JSON.parse(json.text)
expect(jsonObj.items.length).to.be.equal(2)
expect(jsonObj.items[0].html_content).to.equal('super comment 2')
expect(jsonObj.items[1].html_content).to.equal('super comment 1')
}
})
it('Should not list comments from muted accounts or instances', async function () {
this.timeout(30000)
const remoteHandle = 'root@localhost:' + servers[0].port
await addAccountToServerBlocklist(servers[1].url, servers[1].accessToken, remoteHandle)
{
const json = await getJSONfeed(servers[1].url, 'video-comments', { version: 2 })
const jsonObj = JSON.parse(json.text)
expect(jsonObj.items.length).to.be.equal(0)
}
await removeAccountFromServerBlocklist(servers[1].url, servers[1].accessToken, remoteHandle)
{
const videoUUID = (await uploadVideoAndGetId({ server: servers[1], videoName: 'server 2' })).uuid
await waitJobs(servers)
await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoUUID, 'super comment')
await waitJobs(servers)
const json = await getJSONfeed(servers[1].url, 'video-comments', { version: 3 })
const jsonObj = JSON.parse(json.text)
expect(jsonObj.items.length).to.be.equal(3)
}
await addAccountToAccountBlocklist(servers[1].url, servers[1].accessToken, remoteHandle)
{
const json = await getJSONfeed(servers[1].url, 'video-comments', { version: 4 })
const jsonObj = JSON.parse(json.text)
expect(jsonObj.items.length).to.be.equal(2)
}
})
})
after(async function () {
await cleanupTests(servers)
})
})
|
