]>
Commit | Line | Data |
---|---|---|
1 | /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */ | |
2 | ||
3 | import * as chai from 'chai' | |
4 | import { XMLParser, XMLValidator } from 'fast-xml-parser' | |
5 | import { HttpStatusCode, VideoPrivacy } from '@shared/models' | |
6 | import { | |
7 | cleanupTests, | |
8 | createMultipleServers, | |
9 | createSingleServer, | |
10 | doubleFollow, | |
11 | makeGetRequest, | |
12 | makeRawRequest, | |
13 | PeerTubeServer, | |
14 | PluginsCommand, | |
15 | setAccessTokensToServers, | |
16 | setDefaultChannelAvatar, | |
17 | setDefaultVideoChannel, | |
18 | stopFfmpeg, | |
19 | waitJobs | |
20 | } from '@shared/server-commands' | |
21 | ||
22 | chai.use(require('chai-xml')) | |
23 | chai.use(require('chai-json-schema')) | |
24 | chai.config.includeStack = true | |
25 | ||
26 | const expect = chai.expect | |
27 | ||
28 | describe('Test syndication feeds', () => { | |
29 | let servers: PeerTubeServer[] = [] | |
30 | let serverHLSOnly: PeerTubeServer | |
31 | ||
32 | let userAccessToken: string | |
33 | let rootAccountId: number | |
34 | let rootChannelId: number | |
35 | ||
36 | let userAccountId: number | |
37 | let userChannelId: number | |
38 | let userFeedToken: string | |
39 | ||
40 | let liveId: string | |
41 | ||
42 | before(async function () { | |
43 | this.timeout(120000) | |
44 | ||
45 | // Run servers | |
46 | servers = await createMultipleServers(2) | |
47 | serverHLSOnly = await createSingleServer(3, { | |
48 | transcoding: { | |
49 | enabled: true, | |
50 | webtorrent: { enabled: false }, | |
51 | hls: { enabled: true } | |
52 | } | |
53 | }) | |
54 | ||
55 | await setAccessTokensToServers([ ...servers, serverHLSOnly ]) | |
56 | await setDefaultChannelAvatar(servers[0]) | |
57 | await setDefaultVideoChannel(servers) | |
58 | await doubleFollow(servers[0], servers[1]) | |
59 | ||
60 | await servers[0].config.enableLive({ allowReplay: false, transcoding: false }) | |
61 | ||
62 | { | |
63 | const user = await servers[0].users.getMyInfo() | |
64 | rootAccountId = user.account.id | |
65 | rootChannelId = user.videoChannels[0].id | |
66 | } | |
67 | ||
68 | { | |
69 | userAccessToken = await servers[0].users.generateUserAndToken('john') | |
70 | ||
71 | const user = await servers[0].users.getMyInfo({ token: userAccessToken }) | |
72 | userAccountId = user.account.id | |
73 | userChannelId = user.videoChannels[0].id | |
74 | ||
75 | const token = await servers[0].users.getMyScopedTokens({ token: userAccessToken }) | |
76 | userFeedToken = token.feedToken | |
77 | } | |
78 | ||
79 | { | |
80 | await servers[0].videos.upload({ token: userAccessToken, attributes: { name: 'user video' } }) | |
81 | } | |
82 | ||
83 | { | |
84 | const attributes = { | |
85 | name: 'my super name for server 1', | |
86 | description: 'my super description for server 1', | |
87 | fixture: 'video_short.webm' | |
88 | } | |
89 | const { id } = await servers[0].videos.upload({ attributes }) | |
90 | ||
91 | await servers[0].comments.createThread({ videoId: id, text: 'super comment 1' }) | |
92 | await servers[0].comments.createThread({ videoId: id, text: 'super comment 2' }) | |
93 | } | |
94 | ||
95 | { | |
96 | const attributes = { name: 'unlisted video', privacy: VideoPrivacy.UNLISTED } | |
97 | const { id } = await servers[0].videos.upload({ attributes }) | |
98 | ||
99 | await servers[0].comments.createThread({ videoId: id, text: 'comment on unlisted video' }) | |
100 | } | |
101 | ||
102 | await serverHLSOnly.videos.upload({ attributes: { name: 'hls only video' } }) | |
103 | ||
104 | await waitJobs([ ...servers, serverHLSOnly ]) | |
105 | ||
106 | await servers[0].plugins.install({ path: PluginsCommand.getPluginTestPath('-podcast-custom-tags') }) | |
107 | }) | |
108 | ||
109 | describe('All feed', function () { | |
110 | ||
111 | it('Should be well formed XML (covers RSS 2.0 and ATOM 1.0 endpoints)', async function () { | |
112 | for (const feed of [ 'video-comments' as 'video-comments', 'videos' as 'videos' ]) { | |
113 | const rss = await servers[0].feed.getXML({ feed, ignoreCache: true }) | |
114 | expect(rss).xml.to.be.valid() | |
115 | ||
116 | const atom = await servers[0].feed.getXML({ feed, format: 'atom', ignoreCache: true }) | |
117 | expect(atom).xml.to.be.valid() | |
118 | } | |
119 | }) | |
120 | ||
121 | it('Should be well formed XML (covers Podcast endpoint)', async function () { | |
122 | const podcast = await servers[0].feed.getPodcastXML({ ignoreCache: true, channelId: rootChannelId }) | |
123 | expect(podcast).xml.to.be.valid() | |
124 | }) | |
125 | ||
126 | it('Should be well formed JSON (covers JSON feed 1.0 endpoint)', async function () { | |
127 | for (const feed of [ 'video-comments' as 'video-comments', 'videos' as 'videos' ]) { | |
128 | const jsonText = await servers[0].feed.getJSON({ feed, ignoreCache: true }) | |
129 | expect(JSON.parse(jsonText)).to.be.jsonSchema({ type: 'object' }) | |
130 | } | |
131 | }) | |
132 | ||
133 | it('Should serve the endpoint with a classic request', async function () { | |
134 | await makeGetRequest({ | |
135 | url: servers[0].url, | |
136 | path: '/feeds/videos.xml', | |
137 | accept: 'application/xml', | |
138 | expectedStatus: HttpStatusCode.OK_200 | |
139 | }) | |
140 | }) | |
141 | ||
142 | it('Should refuse to serve the endpoint without accept header', async function () { | |
143 | await makeGetRequest({ url: servers[0].url, path: '/feeds/videos.xml', expectedStatus: HttpStatusCode.NOT_ACCEPTABLE_406 }) | |
144 | }) | |
145 | }) | |
146 | ||
147 | describe('Videos feed', function () { | |
148 | ||
149 | describe('Podcast feed', function () { | |
150 | ||
151 | it('Should contain a valid podcast:alternateEnclosure', async function () { | |
152 | // Since podcast feeds should only work on the server they originate on, | |
153 | // only test the first server where the videos reside | |
154 | const rss = await servers[0].feed.getPodcastXML({ ignoreCache: false, channelId: rootChannelId }) | |
155 | expect(XMLValidator.validate(rss)).to.be.true | |
156 | ||
157 | const parser = new XMLParser({ parseAttributeValue: true, ignoreAttributes: false }) | |
158 | const xmlDoc = parser.parse(rss) | |
159 | ||
160 | const itemGuid = xmlDoc.rss.channel.item.guid | |
161 | expect(itemGuid).to.exist | |
162 | expect(itemGuid['@_isPermaLink']).to.equal(true) | |
163 | ||
164 | const enclosure = xmlDoc.rss.channel.item.enclosure | |
165 | expect(enclosure).to.exist | |
166 | const alternateEnclosure = xmlDoc.rss.channel.item['podcast:alternateEnclosure'] | |
167 | expect(alternateEnclosure).to.exist | |
168 | ||
169 | expect(alternateEnclosure['@_type']).to.equal('video/webm') | |
170 | expect(alternateEnclosure['@_length']).to.equal(218910) | |
171 | expect(alternateEnclosure['@_lang']).to.equal('zh') | |
172 | expect(alternateEnclosure['@_title']).to.equal('720p') | |
173 | expect(alternateEnclosure['@_default']).to.equal(true) | |
174 | ||
175 | expect(alternateEnclosure['podcast:source'][0]['@_uri']).to.contain('-720.webm') | |
176 | expect(alternateEnclosure['podcast:source'][0]['@_uri']).to.equal(enclosure['@_url']) | |
177 | expect(alternateEnclosure['podcast:source'][1]['@_uri']).to.contain('-720.torrent') | |
178 | expect(alternateEnclosure['podcast:source'][1]['@_contentType']).to.equal('application/x-bittorrent') | |
179 | expect(alternateEnclosure['podcast:source'][2]['@_uri']).to.contain('magnet:?') | |
180 | }) | |
181 | ||
182 | it('Should contain a valid podcast:alternateEnclosure with HLS only', async function () { | |
183 | const rss = await serverHLSOnly.feed.getPodcastXML({ ignoreCache: false, channelId: rootChannelId }) | |
184 | expect(XMLValidator.validate(rss)).to.be.true | |
185 | ||
186 | const parser = new XMLParser({ parseAttributeValue: true, ignoreAttributes: false }) | |
187 | const xmlDoc = parser.parse(rss) | |
188 | ||
189 | const itemGuid = xmlDoc.rss.channel.item.guid | |
190 | expect(itemGuid).to.exist | |
191 | expect(itemGuid['@_isPermaLink']).to.equal(true) | |
192 | ||
193 | const enclosure = xmlDoc.rss.channel.item.enclosure | |
194 | const alternateEnclosure = xmlDoc.rss.channel.item['podcast:alternateEnclosure'] | |
195 | expect(alternateEnclosure).to.exist | |
196 | ||
197 | expect(alternateEnclosure['@_type']).to.equal('application/x-mpegURL') | |
198 | expect(alternateEnclosure['@_lang']).to.equal('zh') | |
199 | expect(alternateEnclosure['@_title']).to.equal('HLS') | |
200 | expect(alternateEnclosure['@_default']).to.equal(true) | |
201 | ||
202 | expect(alternateEnclosure['podcast:source']['@_uri']).to.contain('-master.m3u8') | |
203 | expect(alternateEnclosure['podcast:source']['@_uri']).to.equal(enclosure['@_url']) | |
204 | }) | |
205 | ||
206 | it('Should contain a valid podcast:socialInteract', async function () { | |
207 | const rss = await servers[0].feed.getPodcastXML({ ignoreCache: false, channelId: rootChannelId }) | |
208 | expect(XMLValidator.validate(rss)).to.be.true | |
209 | ||
210 | const parser = new XMLParser({ parseAttributeValue: true, ignoreAttributes: false }) | |
211 | const xmlDoc = parser.parse(rss) | |
212 | ||
213 | const item = xmlDoc.rss.channel.item | |
214 | const socialInteract = item['podcast:socialInteract'] | |
215 | expect(socialInteract).to.exist | |
216 | expect(socialInteract['@_protocol']).to.equal('activitypub') | |
217 | expect(socialInteract['@_uri']).to.exist | |
218 | expect(socialInteract['@_accountUrl']).to.exist | |
219 | }) | |
220 | ||
221 | it('Should contain a valid support custom tags for plugins', async function () { | |
222 | const rss = await servers[0].feed.getPodcastXML({ ignoreCache: false, channelId: userChannelId }) | |
223 | expect(XMLValidator.validate(rss)).to.be.true | |
224 | ||
225 | const parser = new XMLParser({ parseAttributeValue: true, ignoreAttributes: false }) | |
226 | const xmlDoc = parser.parse(rss) | |
227 | ||
228 | const fooTag = xmlDoc.rss.channel.fooTag | |
229 | expect(fooTag).to.exist | |
230 | expect(fooTag['@_bar']).to.equal('baz') | |
231 | expect(fooTag['#text']).to.equal(42) | |
232 | ||
233 | const bizzBuzzItem = xmlDoc.rss.channel['biz:buzzItem'] | |
234 | expect(bizzBuzzItem).to.exist | |
235 | ||
236 | let nestedTag = bizzBuzzItem.nestedTag | |
237 | expect(nestedTag).to.exist | |
238 | expect(nestedTag).to.equal('example nested tag') | |
239 | ||
240 | const item = xmlDoc.rss.channel.item | |
241 | const fizzTag = item.fizzTag | |
242 | expect(fizzTag).to.exist | |
243 | expect(fizzTag['@_bar']).to.equal('baz') | |
244 | expect(fizzTag['#text']).to.equal(21) | |
245 | ||
246 | const bizzBuzz = item['biz:buzz'] | |
247 | expect(bizzBuzz).to.exist | |
248 | ||
249 | nestedTag = bizzBuzz.nestedTag | |
250 | expect(nestedTag).to.exist | |
251 | expect(nestedTag).to.equal('example nested tag') | |
252 | }) | |
253 | ||
254 | it('Should contain a valid podcast:liveItem for live streams', async function () { | |
255 | this.timeout(120000) | |
256 | ||
257 | const { uuid } = await servers[0].live.create({ | |
258 | fields: { | |
259 | name: 'live-0', | |
260 | privacy: VideoPrivacy.PUBLIC, | |
261 | channelId: rootChannelId, | |
262 | permanentLive: false | |
263 | } | |
264 | }) | |
265 | liveId = uuid | |
266 | ||
267 | const ffmpeg = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveId, copyCodecs: true, fixtureName: 'video_short.mp4' }) | |
268 | await servers[0].live.waitUntilPublished({ videoId: liveId }) | |
269 | ||
270 | const rss = await servers[0].feed.getPodcastXML({ ignoreCache: false, channelId: rootChannelId }) | |
271 | expect(XMLValidator.validate(rss)).to.be.true | |
272 | ||
273 | const parser = new XMLParser({ parseAttributeValue: true, ignoreAttributes: false }) | |
274 | const xmlDoc = parser.parse(rss) | |
275 | const liveItem = xmlDoc.rss.channel['podcast:liveItem'] | |
276 | expect(liveItem.title).to.equal('live-0') | |
277 | expect(liveItem.guid['@_isPermaLink']).to.equal(false) | |
278 | expect(liveItem.guid['#text']).to.contain(`${uuid}_`) | |
279 | expect(liveItem['@_status']).to.equal('live') | |
280 | ||
281 | const enclosure = liveItem.enclosure | |
282 | const alternateEnclosure = liveItem['podcast:alternateEnclosure'] | |
283 | expect(alternateEnclosure).to.exist | |
284 | expect(alternateEnclosure['@_type']).to.equal('application/x-mpegURL') | |
285 | expect(alternateEnclosure['@_title']).to.equal('HLS live stream') | |
286 | expect(alternateEnclosure['@_default']).to.equal(true) | |
287 | ||
288 | expect(alternateEnclosure['podcast:source']['@_uri']).to.contain('/master.m3u8') | |
289 | expect(alternateEnclosure['podcast:source']['@_uri']).to.equal(enclosure['@_url']) | |
290 | ||
291 | await stopFfmpeg(ffmpeg) | |
292 | ||
293 | await servers[0].live.waitUntilEnded({ videoId: liveId }) | |
294 | ||
295 | await waitJobs(servers) | |
296 | }) | |
297 | }) | |
298 | ||
299 | describe('JSON feed', function () { | |
300 | ||
301 | it('Should contain a valid \'attachments\' object', async function () { | |
302 | for (const server of servers) { | |
303 | const json = await server.feed.getJSON({ feed: 'videos', ignoreCache: true }) | |
304 | const jsonObj = JSON.parse(json) | |
305 | expect(jsonObj.items.length).to.be.equal(2) | |
306 | expect(jsonObj.items[0].attachments).to.exist | |
307 | expect(jsonObj.items[0].attachments.length).to.be.eq(1) | |
308 | expect(jsonObj.items[0].attachments[0].mime_type).to.be.eq('application/x-bittorrent') | |
309 | expect(jsonObj.items[0].attachments[0].size_in_bytes).to.be.eq(218910) | |
310 | expect(jsonObj.items[0].attachments[0].url).to.contain('720.torrent') | |
311 | } | |
312 | }) | |
313 | ||
314 | it('Should filter by account', async function () { | |
315 | { | |
316 | const json = await servers[0].feed.getJSON({ feed: 'videos', query: { accountId: rootAccountId }, ignoreCache: true }) | |
317 | const jsonObj = JSON.parse(json) | |
318 | expect(jsonObj.items.length).to.be.equal(1) | |
319 | expect(jsonObj.items[0].title).to.equal('my super name for server 1') | |
320 | expect(jsonObj.items[0].author.name).to.equal('Main root channel') | |
321 | } | |
322 | ||
323 | { | |
324 | const json = await servers[0].feed.getJSON({ feed: 'videos', query: { accountId: userAccountId }, ignoreCache: true }) | |
325 | const jsonObj = JSON.parse(json) | |
326 | expect(jsonObj.items.length).to.be.equal(1) | |
327 | expect(jsonObj.items[0].title).to.equal('user video') | |
328 | expect(jsonObj.items[0].author.name).to.equal('Main john channel') | |
329 | } | |
330 | ||
331 | for (const server of servers) { | |
332 | { | |
333 | const json = await server.feed.getJSON({ feed: 'videos', query: { accountName: 'root@' + servers[0].host }, ignoreCache: true }) | |
334 | const jsonObj = JSON.parse(json) | |
335 | expect(jsonObj.items.length).to.be.equal(1) | |
336 | expect(jsonObj.items[0].title).to.equal('my super name for server 1') | |
337 | } | |
338 | ||
339 | { | |
340 | const json = await server.feed.getJSON({ feed: 'videos', query: { accountName: 'john@' + servers[0].host }, ignoreCache: true }) | |
341 | const jsonObj = JSON.parse(json) | |
342 | expect(jsonObj.items.length).to.be.equal(1) | |
343 | expect(jsonObj.items[0].title).to.equal('user video') | |
344 | } | |
345 | } | |
346 | }) | |
347 | ||
348 | it('Should filter by video channel', async function () { | |
349 | { | |
350 | const json = await servers[0].feed.getJSON({ feed: 'videos', query: { videoChannelId: rootChannelId }, ignoreCache: true }) | |
351 | const jsonObj = JSON.parse(json) | |
352 | expect(jsonObj.items.length).to.be.equal(1) | |
353 | expect(jsonObj.items[0].title).to.equal('my super name for server 1') | |
354 | expect(jsonObj.items[0].author.name).to.equal('Main root channel') | |
355 | } | |
356 | ||
357 | { | |
358 | const json = await servers[0].feed.getJSON({ feed: 'videos', query: { videoChannelId: userChannelId }, ignoreCache: true }) | |
359 | const jsonObj = JSON.parse(json) | |
360 | expect(jsonObj.items.length).to.be.equal(1) | |
361 | expect(jsonObj.items[0].title).to.equal('user video') | |
362 | expect(jsonObj.items[0].author.name).to.equal('Main john channel') | |
363 | } | |
364 | ||
365 | for (const server of servers) { | |
366 | { | |
367 | const query = { videoChannelName: 'root_channel@' + servers[0].host } | |
368 | const json = await server.feed.getJSON({ feed: 'videos', query, ignoreCache: true }) | |
369 | const jsonObj = JSON.parse(json) | |
370 | expect(jsonObj.items.length).to.be.equal(1) | |
371 | expect(jsonObj.items[0].title).to.equal('my super name for server 1') | |
372 | } | |
373 | ||
374 | { | |
375 | const query = { videoChannelName: 'john_channel@' + servers[0].host } | |
376 | const json = await server.feed.getJSON({ feed: 'videos', query, ignoreCache: true }) | |
377 | const jsonObj = JSON.parse(json) | |
378 | expect(jsonObj.items.length).to.be.equal(1) | |
379 | expect(jsonObj.items[0].title).to.equal('user video') | |
380 | } | |
381 | } | |
382 | }) | |
383 | ||
384 | it('Should correctly have videos feed with HLS only', async function () { | |
385 | this.timeout(120000) | |
386 | ||
387 | const json = await serverHLSOnly.feed.getJSON({ feed: 'videos', ignoreCache: true }) | |
388 | const jsonObj = JSON.parse(json) | |
389 | expect(jsonObj.items.length).to.be.equal(1) | |
390 | expect(jsonObj.items[0].attachments).to.exist | |
391 | expect(jsonObj.items[0].attachments.length).to.be.eq(4) | |
392 | ||
393 | for (let i = 0; i < 4; i++) { | |
394 | expect(jsonObj.items[0].attachments[i].mime_type).to.be.eq('application/x-bittorrent') | |
395 | expect(jsonObj.items[0].attachments[i].size_in_bytes).to.be.greaterThan(0) | |
396 | expect(jsonObj.items[0].attachments[i].url).to.exist | |
397 | } | |
398 | }) | |
399 | ||
400 | it('Should not display waiting live videos', async function () { | |
401 | const { uuid } = await servers[0].live.create({ | |
402 | fields: { | |
403 | name: 'live', | |
404 | privacy: VideoPrivacy.PUBLIC, | |
405 | channelId: rootChannelId | |
406 | } | |
407 | }) | |
408 | liveId = uuid | |
409 | ||
410 | const json = await servers[0].feed.getJSON({ feed: 'videos', ignoreCache: true }) | |
411 | ||
412 | const jsonObj = JSON.parse(json) | |
413 | expect(jsonObj.items.length).to.be.equal(2) | |
414 | expect(jsonObj.items[0].title).to.equal('my super name for server 1') | |
415 | expect(jsonObj.items[1].title).to.equal('user video') | |
416 | }) | |
417 | ||
418 | it('Should display published live videos', async function () { | |
419 | this.timeout(120000) | |
420 | ||
421 | const ffmpeg = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveId, copyCodecs: true, fixtureName: 'video_short.mp4' }) | |
422 | await servers[0].live.waitUntilPublished({ videoId: liveId }) | |
423 | ||
424 | const json = await servers[0].feed.getJSON({ feed: 'videos', ignoreCache: true }) | |
425 | ||
426 | const jsonObj = JSON.parse(json) | |
427 | expect(jsonObj.items.length).to.be.equal(3) | |
428 | expect(jsonObj.items[0].title).to.equal('live') | |
429 | expect(jsonObj.items[1].title).to.equal('my super name for server 1') | |
430 | expect(jsonObj.items[2].title).to.equal('user video') | |
431 | ||
432 | await stopFfmpeg(ffmpeg) | |
433 | }) | |
434 | ||
435 | it('Should have the channel avatar as feed icon', async function () { | |
436 | const json = await servers[0].feed.getJSON({ feed: 'videos', query: { videoChannelId: rootChannelId }, ignoreCache: true }) | |
437 | ||
438 | const jsonObj = JSON.parse(json) | |
439 | const imageUrl = jsonObj.icon | |
440 | expect(imageUrl).to.include('/lazy-static/avatars/') | |
441 | await makeRawRequest({ url: imageUrl, expectedStatus: HttpStatusCode.OK_200 }) | |
442 | }) | |
443 | }) | |
444 | }) | |
445 | ||
446 | describe('Video comments feed', function () { | |
447 | ||
448 | it('Should contain valid comments (covers JSON feed 1.0 endpoint) and not from unlisted videos', async function () { | |
449 | for (const server of servers) { | |
450 | const json = await server.feed.getJSON({ feed: 'video-comments', ignoreCache: true }) | |
451 | ||
452 | const jsonObj = JSON.parse(json) | |
453 | expect(jsonObj.items.length).to.be.equal(2) | |
454 | expect(jsonObj.items[0].content_html).to.contain('<p>super comment 2</p>') | |
455 | expect(jsonObj.items[1].content_html).to.contain('<p>super comment 1</p>') | |
456 | } | |
457 | }) | |
458 | ||
459 | it('Should not list comments from muted accounts or instances', async function () { | |
460 | this.timeout(30000) | |
461 | ||
462 | const remoteHandle = 'root@' + servers[0].host | |
463 | ||
464 | await servers[1].blocklist.addToServerBlocklist({ account: remoteHandle }) | |
465 | ||
466 | { | |
467 | const json = await servers[1].feed.getJSON({ feed: 'video-comments', ignoreCache: true }) | |
468 | const jsonObj = JSON.parse(json) | |
469 | expect(jsonObj.items.length).to.be.equal(0) | |
470 | } | |
471 | ||
472 | await servers[1].blocklist.removeFromServerBlocklist({ account: remoteHandle }) | |
473 | ||
474 | { | |
475 | const videoUUID = (await servers[1].videos.quickUpload({ name: 'server 2' })).uuid | |
476 | await waitJobs(servers) | |
477 | await servers[0].comments.createThread({ videoId: videoUUID, text: 'super comment' }) | |
478 | await waitJobs(servers) | |
479 | ||
480 | const json = await servers[1].feed.getJSON({ feed: 'video-comments', ignoreCache: true }) | |
481 | const jsonObj = JSON.parse(json) | |
482 | expect(jsonObj.items.length).to.be.equal(3) | |
483 | } | |
484 | ||
485 | await servers[1].blocklist.addToMyBlocklist({ account: remoteHandle }) | |
486 | ||
487 | { | |
488 | const json = await servers[1].feed.getJSON({ feed: 'video-comments', ignoreCache: true }) | |
489 | const jsonObj = JSON.parse(json) | |
490 | expect(jsonObj.items.length).to.be.equal(2) | |
491 | } | |
492 | }) | |
493 | }) | |
494 | ||
495 | describe('Video feed from my subscriptions', function () { | |
496 | let feeduserAccountId: number | |
497 | let feeduserFeedToken: string | |
498 | ||
499 | it('Should list no videos for a user with no videos and no subscriptions', async function () { | |
500 | const attr = { username: 'feeduser', password: 'password' } | |
501 | await servers[0].users.create({ username: attr.username, password: attr.password }) | |
502 | const feeduserAccessToken = await servers[0].login.getAccessToken(attr) | |
503 | ||
504 | { | |
505 | const user = await servers[0].users.getMyInfo({ token: feeduserAccessToken }) | |
506 | feeduserAccountId = user.account.id | |
507 | } | |
508 | ||
509 | { | |
510 | const token = await servers[0].users.getMyScopedTokens({ token: feeduserAccessToken }) | |
511 | feeduserFeedToken = token.feedToken | |
512 | } | |
513 | ||
514 | { | |
515 | const body = await servers[0].videos.listMySubscriptionVideos({ token: feeduserAccessToken }) | |
516 | expect(body.total).to.equal(0) | |
517 | ||
518 | const query = { accountId: feeduserAccountId, token: feeduserFeedToken } | |
519 | const json = await servers[0].feed.getJSON({ feed: 'subscriptions', query, ignoreCache: true }) | |
520 | const jsonObj = JSON.parse(json) | |
521 | expect(jsonObj.items.length).to.be.equal(0) // no subscription, it should not list the instance's videos but list 0 videos | |
522 | } | |
523 | }) | |
524 | ||
525 | it('Should fail with an invalid token', async function () { | |
526 | const query = { accountId: feeduserAccountId, token: 'toto' } | |
527 | await servers[0].feed.getJSON({ feed: 'subscriptions', query, expectedStatus: HttpStatusCode.FORBIDDEN_403, ignoreCache: true }) | |
528 | }) | |
529 | ||
530 | it('Should fail with a token of another user', async function () { | |
531 | const query = { accountId: feeduserAccountId, token: userFeedToken } | |
532 | await servers[0].feed.getJSON({ feed: 'subscriptions', query, expectedStatus: HttpStatusCode.FORBIDDEN_403, ignoreCache: true }) | |
533 | }) | |
534 | ||
535 | it('Should list no videos for a user with videos but no subscriptions', async function () { | |
536 | const body = await servers[0].videos.listMySubscriptionVideos({ token: userAccessToken }) | |
537 | expect(body.total).to.equal(0) | |
538 | ||
539 | const query = { accountId: userAccountId, token: userFeedToken } | |
540 | const json = await servers[0].feed.getJSON({ feed: 'subscriptions', query, ignoreCache: true }) | |
541 | const jsonObj = JSON.parse(json) | |
542 | expect(jsonObj.items.length).to.be.equal(0) // no subscription, it should not list the instance's videos but list 0 videos | |
543 | }) | |
544 | ||
545 | it('Should list self videos for a user with a subscription to themselves', async function () { | |
546 | this.timeout(30000) | |
547 | ||
548 | await servers[0].subscriptions.add({ token: userAccessToken, targetUri: 'john_channel@' + servers[0].host }) | |
549 | await waitJobs(servers) | |
550 | ||
551 | { | |
552 | const body = await servers[0].videos.listMySubscriptionVideos({ token: userAccessToken }) | |
553 | expect(body.total).to.equal(1) | |
554 | expect(body.data[0].name).to.equal('user video') | |
555 | ||
556 | const query = { accountId: userAccountId, token: userFeedToken } | |
557 | const json = await servers[0].feed.getJSON({ feed: 'subscriptions', query, ignoreCache: true }) | |
558 | const jsonObj = JSON.parse(json) | |
559 | expect(jsonObj.items.length).to.be.equal(1) // subscribed to self, it should not list the instance's videos but list john's | |
560 | } | |
561 | }) | |
562 | ||
563 | it('Should list videos of a user\'s subscription', async function () { | |
564 | this.timeout(30000) | |
565 | ||
566 | await servers[0].subscriptions.add({ token: userAccessToken, targetUri: 'root_channel@' + servers[0].host }) | |
567 | await waitJobs(servers) | |
568 | ||
569 | { | |
570 | const body = await servers[0].videos.listMySubscriptionVideos({ token: userAccessToken }) | |
571 | expect(body.total).to.equal(2, 'there should be 2 videos part of the subscription') | |
572 | ||
573 | const query = { accountId: userAccountId, token: userFeedToken } | |
574 | const json = await servers[0].feed.getJSON({ feed: 'subscriptions', query, ignoreCache: true }) | |
575 | const jsonObj = JSON.parse(json) | |
576 | expect(jsonObj.items.length).to.be.equal(2) // subscribed to root, it should not list the instance's videos but list root/john's | |
577 | } | |
578 | }) | |
579 | ||
580 | it('Should renew the token, and so have an invalid old token', async function () { | |
581 | await servers[0].users.renewMyScopedTokens({ token: userAccessToken }) | |
582 | ||
583 | const query = { accountId: userAccountId, token: userFeedToken } | |
584 | await servers[0].feed.getJSON({ feed: 'subscriptions', query, expectedStatus: HttpStatusCode.FORBIDDEN_403, ignoreCache: true }) | |
585 | }) | |
586 | ||
587 | it('Should succeed with the new token', async function () { | |
588 | const token = await servers[0].users.getMyScopedTokens({ token: userAccessToken }) | |
589 | userFeedToken = token.feedToken | |
590 | ||
591 | const query = { accountId: userAccountId, token: userFeedToken } | |
592 | await servers[0].feed.getJSON({ feed: 'subscriptions', query, ignoreCache: true }) | |
593 | }) | |
594 | ||
595 | }) | |
596 | ||
597 | describe('Cache', function () { | |
598 | const uuids: string[] = [] | |
599 | ||
600 | function doPodcastRequest () { | |
601 | return makeGetRequest({ | |
602 | url: servers[0].url, | |
603 | path: '/feeds/podcast/videos.xml', | |
604 | query: { videoChannelId: servers[0].store.channel.id }, | |
605 | accept: 'application/xml', | |
606 | expectedStatus: HttpStatusCode.OK_200 | |
607 | }) | |
608 | } | |
609 | ||
610 | function doVideosRequest (query: { [id: string]: string } = {}) { | |
611 | return makeGetRequest({ | |
612 | url: servers[0].url, | |
613 | path: '/feeds/videos.xml', | |
614 | query, | |
615 | accept: 'application/xml', | |
616 | expectedStatus: HttpStatusCode.OK_200 | |
617 | }) | |
618 | } | |
619 | ||
620 | before(async function () { | |
621 | { | |
622 | const { uuid } = await servers[0].videos.quickUpload({ name: 'cache 1' }) | |
623 | uuids.push(uuid) | |
624 | } | |
625 | ||
626 | { | |
627 | const { uuid } = await servers[0].videos.quickUpload({ name: 'cache 2' }) | |
628 | uuids.push(uuid) | |
629 | } | |
630 | }) | |
631 | ||
632 | it('Should serve the videos endpoint as a cached request', async function () { | |
633 | await doVideosRequest() | |
634 | ||
635 | const res = await doVideosRequest() | |
636 | ||
637 | expect(res.headers['x-api-cache-cached']).to.equal('true') | |
638 | }) | |
639 | ||
640 | it('Should not serve the videos endpoint as a cached request', async function () { | |
641 | const res = await doVideosRequest({ v: '186' }) | |
642 | ||
643 | expect(res.headers['x-api-cache-cached']).to.not.exist | |
644 | }) | |
645 | ||
646 | it('Should invalidate the podcast feed cache after video deletion', async function () { | |
647 | await doPodcastRequest() | |
648 | ||
649 | { | |
650 | const res = await doPodcastRequest() | |
651 | expect(res.headers['x-api-cache-cached']).to.exist | |
652 | } | |
653 | ||
654 | await servers[0].videos.remove({ id: uuids[0] }) | |
655 | ||
656 | { | |
657 | const res = await doPodcastRequest() | |
658 | expect(res.headers['x-api-cache-cached']).to.not.exist | |
659 | } | |
660 | }) | |
661 | ||
662 | it('Should invalidate the podcast feed cache after video deletion, even after server restart', async function () { | |
663 | this.timeout(120000) | |
664 | ||
665 | await doPodcastRequest() | |
666 | ||
667 | { | |
668 | const res = await doPodcastRequest() | |
669 | expect(res.headers['x-api-cache-cached']).to.exist | |
670 | } | |
671 | ||
672 | await servers[0].kill() | |
673 | await servers[0].run() | |
674 | ||
675 | await servers[0].videos.remove({ id: uuids[1] }) | |
676 | ||
677 | const res = await doPodcastRequest() | |
678 | expect(res.headers['x-api-cache-cached']).to.not.exist | |
679 | }) | |
680 | ||
681 | }) | |
682 | ||
683 | after(async function () { | |
684 | await servers[0].plugins.uninstall({ npmName: 'peertube-plugin-test-podcast-custom-tags' }) | |
685 | ||
686 | await cleanupTests([ ...servers, serverHLSOnly ]) | |
687 | }) | |
688 | }) |