|
@@ -11,6 +11,7 @@ import {
|
|
|
makeGetRequest,
|
|
|
makeRawRequest,
|
|
|
PeerTubeServer,
|
|
|
+ PluginsCommand,
|
|
|
setAccessTokensToServers,
|
|
|
setDefaultChannelAvatar,
|
|
|
stopFfmpeg,
|
|
@@ -26,12 +27,15 @@ const expect = chai.expect
|
|
|
describe('Test syndication feeds', () => {
|
|
|
let servers: PeerTubeServer[] = []
|
|
|
let serverHLSOnly: PeerTubeServer
|
|
|
+
|
|
|
let userAccessToken: string
|
|
|
let rootAccountId: number
|
|
|
let rootChannelId: number
|
|
|
+
|
|
|
let userAccountId: number
|
|
|
let userChannelId: number
|
|
|
let userFeedToken: string
|
|
|
+
|
|
|
let liveId: string
|
|
|
|
|
|
before(async function () {
|
|
@@ -93,7 +97,11 @@ describe('Test syndication feeds', () => {
|
|
|
await servers[0].comments.createThread({ videoId: id, text: 'comment on unlisted video' })
|
|
|
}
|
|
|
|
|
|
- await waitJobs(servers)
|
|
|
+ await serverHLSOnly.videos.upload({ attributes: { name: 'hls only video' } })
|
|
|
+
|
|
|
+ await waitJobs([ ...servers, serverHLSOnly ])
|
|
|
+
|
|
|
+ await servers[0].plugins.install({ path: PluginsCommand.getPluginTestPath('-podcast-custom-tags') })
|
|
|
})
|
|
|
|
|
|
describe('All feed', function () {
|
|
@@ -108,6 +116,11 @@ describe('Test syndication feeds', () => {
|
|
|
}
|
|
|
})
|
|
|
|
|
|
+ it('Should be well formed XML (covers Podcast endpoint)', async function () {
|
|
|
+ const podcast = await servers[0].feed.getPodcastXML({ ignoreCache: true, channelId: rootChannelId })
|
|
|
+ expect(podcast).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 jsonText = await servers[0].feed.getJSON({ feed, ignoreCache: true })
|
|
@@ -153,168 +166,290 @@ describe('Test syndication feeds', () => {
|
|
|
|
|
|
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 server.feed.getXML({ feed: 'videos', ignoreCache: true })
|
|
|
+ describe('Podcast feed', function () {
|
|
|
+
|
|
|
+ it('Should contain a valid podcast:alternateEnclosure', async function () {
|
|
|
+ // Since podcast feeds should only work on the server they originate on,
|
|
|
+ // only test the first server where the videos reside
|
|
|
+ const rss = await servers[0].feed.getPodcastXML({ ignoreCache: false, channelId: rootChannelId })
|
|
|
expect(XMLValidator.validate(rss)).to.be.true
|
|
|
|
|
|
const parser = new XMLParser({ parseAttributeValue: true, ignoreAttributes: false })
|
|
|
const xmlDoc = parser.parse(rss)
|
|
|
|
|
|
- const enclosure = xmlDoc.rss.channel.item[0].enclosure
|
|
|
+ const enclosure = xmlDoc.rss.channel.item.enclosure
|
|
|
expect(enclosure).to.exist
|
|
|
+ const alternateEnclosure = xmlDoc.rss.channel.item['podcast:alternateEnclosure']
|
|
|
+ expect(alternateEnclosure).to.exist
|
|
|
+
|
|
|
+ expect(alternateEnclosure['@_type']).to.equal('video/webm')
|
|
|
+ expect(alternateEnclosure['@_length']).to.equal(218910)
|
|
|
+ expect(alternateEnclosure['@_lang']).to.equal('zh')
|
|
|
+ expect(alternateEnclosure['@_title']).to.equal('720p')
|
|
|
+ expect(alternateEnclosure['@_default']).to.equal(true)
|
|
|
+
|
|
|
+ expect(alternateEnclosure['podcast:source'][0]['@_uri']).to.contain('-720.webm')
|
|
|
+ expect(alternateEnclosure['podcast:source'][0]['@_uri']).to.equal(enclosure['@_url'])
|
|
|
+ expect(alternateEnclosure['podcast:source'][1]['@_uri']).to.contain('-720.torrent')
|
|
|
+ expect(alternateEnclosure['podcast:source'][1]['@_contentType']).to.equal('application/x-bittorrent')
|
|
|
+ expect(alternateEnclosure['podcast:source'][2]['@_uri']).to.contain('magnet:?')
|
|
|
+ })
|
|
|
|
|
|
- expect(enclosure['@_type']).to.equal('video/webm')
|
|
|
- expect(enclosure['@_length']).to.equal(218910)
|
|
|
- expect(enclosure['@_url']).to.contain('-720.webm')
|
|
|
- }
|
|
|
- })
|
|
|
+ it('Should contain a valid podcast:alternateEnclosure with HLS only', async function () {
|
|
|
+ const rss = await serverHLSOnly.feed.getPodcastXML({ ignoreCache: false, channelId: rootChannelId })
|
|
|
+ expect(XMLValidator.validate(rss)).to.be.true
|
|
|
|
|
|
- it('Should contain a valid \'attachments\' object (covers JSON feed 1.0 endpoint)', async function () {
|
|
|
- for (const server of servers) {
|
|
|
- const json = await server.feed.getJSON({ feed: 'videos', ignoreCache: true })
|
|
|
- const jsonObj = JSON.parse(json)
|
|
|
- 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')
|
|
|
- }
|
|
|
+ const parser = new XMLParser({ parseAttributeValue: true, ignoreAttributes: false })
|
|
|
+ const xmlDoc = parser.parse(rss)
|
|
|
+
|
|
|
+ const enclosure = xmlDoc.rss.channel.item.enclosure
|
|
|
+ const alternateEnclosure = xmlDoc.rss.channel.item['podcast:alternateEnclosure']
|
|
|
+ expect(alternateEnclosure).to.exist
|
|
|
+
|
|
|
+ expect(alternateEnclosure['@_type']).to.equal('application/x-mpegURL')
|
|
|
+ expect(alternateEnclosure['@_lang']).to.equal('zh')
|
|
|
+ expect(alternateEnclosure['@_title']).to.equal('HLS')
|
|
|
+ expect(alternateEnclosure['@_default']).to.equal(true)
|
|
|
+
|
|
|
+ expect(alternateEnclosure['podcast:source']['@_uri']).to.contain('-master.m3u8')
|
|
|
+ expect(alternateEnclosure['podcast:source']['@_uri']).to.equal(enclosure['@_url'])
|
|
|
+ })
|
|
|
+
|
|
|
+ it('Should contain a valid podcast:socialInteract', async function () {
|
|
|
+ const rss = await servers[0].feed.getPodcastXML({ ignoreCache: false, channelId: rootChannelId })
|
|
|
+ expect(XMLValidator.validate(rss)).to.be.true
|
|
|
+
|
|
|
+ const parser = new XMLParser({ parseAttributeValue: true, ignoreAttributes: false })
|
|
|
+ const xmlDoc = parser.parse(rss)
|
|
|
+
|
|
|
+ const item = xmlDoc.rss.channel.item
|
|
|
+ const socialInteract = item['podcast:socialInteract']
|
|
|
+ expect(socialInteract).to.exist
|
|
|
+ expect(socialInteract['@_protocol']).to.equal('activitypub')
|
|
|
+ expect(socialInteract['@_uri']).to.exist
|
|
|
+ expect(socialInteract['@_accountUrl']).to.exist
|
|
|
+ })
|
|
|
+
|
|
|
+ it('Should contain a valid support custom tags for plugins', async function () {
|
|
|
+ const rss = await servers[0].feed.getPodcastXML({ ignoreCache: false, channelId: userChannelId })
|
|
|
+ expect(XMLValidator.validate(rss)).to.be.true
|
|
|
+
|
|
|
+ const parser = new XMLParser({ parseAttributeValue: true, ignoreAttributes: false })
|
|
|
+ const xmlDoc = parser.parse(rss)
|
|
|
+
|
|
|
+ const fooTag = xmlDoc.rss.channel.fooTag
|
|
|
+ expect(fooTag).to.exist
|
|
|
+ expect(fooTag['@_bar']).to.equal('baz')
|
|
|
+ expect(fooTag['#text']).to.equal(42)
|
|
|
+
|
|
|
+ const bizzBuzzItem = xmlDoc.rss.channel['biz:buzzItem']
|
|
|
+ expect(bizzBuzzItem).to.exist
|
|
|
+
|
|
|
+ let nestedTag = bizzBuzzItem.nestedTag
|
|
|
+ expect(nestedTag).to.exist
|
|
|
+ expect(nestedTag).to.equal('example nested tag')
|
|
|
+
|
|
|
+ const item = xmlDoc.rss.channel.item
|
|
|
+ const fizzTag = item.fizzTag
|
|
|
+ expect(fizzTag).to.exist
|
|
|
+ expect(fizzTag['@_bar']).to.equal('baz')
|
|
|
+ expect(fizzTag['#text']).to.equal(21)
|
|
|
+
|
|
|
+ const bizzBuzz = item['biz:buzz']
|
|
|
+ expect(bizzBuzz).to.exist
|
|
|
+
|
|
|
+ nestedTag = bizzBuzz.nestedTag
|
|
|
+ expect(nestedTag).to.exist
|
|
|
+ expect(nestedTag).to.equal('example nested tag')
|
|
|
+ })
|
|
|
+
|
|
|
+ it('Should contain a valid podcast:liveItem for live streams', async function () {
|
|
|
+ this.timeout(120000)
|
|
|
+
|
|
|
+ const { uuid } = await servers[0].live.create({
|
|
|
+ fields: {
|
|
|
+ name: 'live-0',
|
|
|
+ privacy: VideoPrivacy.PUBLIC,
|
|
|
+ channelId: rootChannelId,
|
|
|
+ permanentLive: false
|
|
|
+ }
|
|
|
+ })
|
|
|
+ liveId = uuid
|
|
|
+
|
|
|
+ const ffmpeg = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveId, copyCodecs: true, fixtureName: 'video_short.mp4' })
|
|
|
+ await servers[0].live.waitUntilPublished({ videoId: liveId })
|
|
|
+
|
|
|
+ const rss = await servers[0].feed.getPodcastXML({ ignoreCache: false, channelId: rootChannelId })
|
|
|
+ expect(XMLValidator.validate(rss)).to.be.true
|
|
|
+
|
|
|
+ const parser = new XMLParser({ parseAttributeValue: true, ignoreAttributes: false })
|
|
|
+ const xmlDoc = parser.parse(rss)
|
|
|
+ const liveItem = xmlDoc.rss.channel['podcast:liveItem']
|
|
|
+ expect(liveItem.title).to.equal('live-0')
|
|
|
+ expect(liveItem['@_status']).to.equal('live')
|
|
|
+
|
|
|
+ const enclosure = liveItem.enclosure
|
|
|
+ const alternateEnclosure = liveItem['podcast:alternateEnclosure']
|
|
|
+ expect(alternateEnclosure).to.exist
|
|
|
+ expect(alternateEnclosure['@_type']).to.equal('application/x-mpegURL')
|
|
|
+ expect(alternateEnclosure['@_title']).to.equal('HLS live stream')
|
|
|
+ expect(alternateEnclosure['@_default']).to.equal(true)
|
|
|
+
|
|
|
+ expect(alternateEnclosure['podcast:source']['@_uri']).to.contain('/master.m3u8')
|
|
|
+ expect(alternateEnclosure['podcast:source']['@_uri']).to.equal(enclosure['@_url'])
|
|
|
+
|
|
|
+ await stopFfmpeg(ffmpeg)
|
|
|
+
|
|
|
+ await servers[0].live.waitUntilEnded({ videoId: liveId })
|
|
|
+
|
|
|
+ await waitJobs(servers)
|
|
|
+ })
|
|
|
})
|
|
|
|
|
|
- it('Should filter by account', async function () {
|
|
|
- {
|
|
|
- const json = await servers[0].feed.getJSON({ feed: 'videos', query: { accountId: rootAccountId }, ignoreCache: true })
|
|
|
- const jsonObj = JSON.parse(json)
|
|
|
- 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('Main root channel')
|
|
|
- }
|
|
|
+ describe('JSON feed', function () {
|
|
|
|
|
|
- {
|
|
|
- const json = await servers[0].feed.getJSON({ feed: 'videos', query: { accountId: userAccountId }, ignoreCache: true })
|
|
|
- const jsonObj = JSON.parse(json)
|
|
|
- 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('Main john channel')
|
|
|
- }
|
|
|
+ it('Should contain a valid \'attachments\' object', async function () {
|
|
|
+ for (const server of servers) {
|
|
|
+ const json = await server.feed.getJSON({ feed: 'videos', ignoreCache: true })
|
|
|
+ const jsonObj = JSON.parse(json)
|
|
|
+ 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')
|
|
|
+ }
|
|
|
+ })
|
|
|
|
|
|
- for (const server of servers) {
|
|
|
+ it('Should filter by account', async function () {
|
|
|
{
|
|
|
- const json = await server.feed.getJSON({ feed: 'videos', query: { accountName: 'root@' + servers[0].host }, ignoreCache: true })
|
|
|
+ const json = await servers[0].feed.getJSON({ feed: 'videos', query: { accountId: rootAccountId }, ignoreCache: true })
|
|
|
const jsonObj = JSON.parse(json)
|
|
|
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('Main root channel')
|
|
|
}
|
|
|
|
|
|
{
|
|
|
- const json = await server.feed.getJSON({ feed: 'videos', query: { accountName: 'john@' + servers[0].host }, ignoreCache: true })
|
|
|
+ const json = await servers[0].feed.getJSON({ feed: 'videos', query: { accountId: userAccountId }, ignoreCache: true })
|
|
|
const jsonObj = JSON.parse(json)
|
|
|
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('Main john channel')
|
|
|
}
|
|
|
- }
|
|
|
- })
|
|
|
|
|
|
- it('Should filter by video channel', async function () {
|
|
|
- {
|
|
|
- const json = await servers[0].feed.getJSON({ feed: 'videos', query: { videoChannelId: rootChannelId }, ignoreCache: true })
|
|
|
- const jsonObj = JSON.parse(json)
|
|
|
- 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('Main root channel')
|
|
|
- }
|
|
|
-
|
|
|
- {
|
|
|
- const json = await servers[0].feed.getJSON({ feed: 'videos', query: { videoChannelId: userChannelId }, ignoreCache: true })
|
|
|
- const jsonObj = JSON.parse(json)
|
|
|
- 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('Main john channel')
|
|
|
- }
|
|
|
+ for (const server of servers) {
|
|
|
+ {
|
|
|
+ const json = await server.feed.getJSON({ feed: 'videos', query: { accountName: 'root@' + servers[0].host }, ignoreCache: true })
|
|
|
+ const jsonObj = JSON.parse(json)
|
|
|
+ expect(jsonObj.items.length).to.be.equal(1)
|
|
|
+ expect(jsonObj.items[0].title).to.equal('my super name for server 1')
|
|
|
+ }
|
|
|
+
|
|
|
+ {
|
|
|
+ const json = await server.feed.getJSON({ feed: 'videos', query: { accountName: 'john@' + servers[0].host }, ignoreCache: true })
|
|
|
+ const jsonObj = JSON.parse(json)
|
|
|
+ expect(jsonObj.items.length).to.be.equal(1)
|
|
|
+ expect(jsonObj.items[0].title).to.equal('user video')
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
|
|
|
- for (const server of servers) {
|
|
|
+ it('Should filter by video channel', async function () {
|
|
|
{
|
|
|
- const query = { videoChannelName: 'root_channel@' + servers[0].host }
|
|
|
- const json = await server.feed.getJSON({ feed: 'videos', query, ignoreCache: true })
|
|
|
+ const json = await servers[0].feed.getJSON({ feed: 'videos', query: { videoChannelId: rootChannelId }, ignoreCache: true })
|
|
|
const jsonObj = JSON.parse(json)
|
|
|
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('Main root channel')
|
|
|
}
|
|
|
|
|
|
{
|
|
|
- const query = { videoChannelName: 'john_channel@' + servers[0].host }
|
|
|
- const json = await server.feed.getJSON({ feed: 'videos', query, ignoreCache: true })
|
|
|
+ const json = await servers[0].feed.getJSON({ feed: 'videos', query: { videoChannelId: userChannelId }, ignoreCache: true })
|
|
|
const jsonObj = JSON.parse(json)
|
|
|
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('Main john channel')
|
|
|
}
|
|
|
- }
|
|
|
- })
|
|
|
|
|
|
- it('Should correctly have videos feed with HLS only', async function () {
|
|
|
- this.timeout(120000)
|
|
|
-
|
|
|
- await serverHLSOnly.videos.upload({ attributes: { name: 'hls only video' } })
|
|
|
+ for (const server of servers) {
|
|
|
+ {
|
|
|
+ const query = { videoChannelName: 'root_channel@' + servers[0].host }
|
|
|
+ const json = await server.feed.getJSON({ feed: 'videos', query, ignoreCache: true })
|
|
|
+ const jsonObj = JSON.parse(json)
|
|
|
+ expect(jsonObj.items.length).to.be.equal(1)
|
|
|
+ expect(jsonObj.items[0].title).to.equal('my super name for server 1')
|
|
|
+ }
|
|
|
+
|
|
|
+ {
|
|
|
+ const query = { videoChannelName: 'john_channel@' + servers[0].host }
|
|
|
+ const json = await server.feed.getJSON({ feed: 'videos', query, ignoreCache: true })
|
|
|
+ const jsonObj = JSON.parse(json)
|
|
|
+ expect(jsonObj.items.length).to.be.equal(1)
|
|
|
+ expect(jsonObj.items[0].title).to.equal('user video')
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
|
|
|
- await waitJobs([ serverHLSOnly ])
|
|
|
+ it('Should correctly have videos feed with HLS only', async function () {
|
|
|
+ this.timeout(120000)
|
|
|
|
|
|
- const json = await serverHLSOnly.feed.getJSON({ feed: 'videos', ignoreCache: true })
|
|
|
- const jsonObj = JSON.parse(json)
|
|
|
- expect(jsonObj.items.length).to.be.equal(1)
|
|
|
- expect(jsonObj.items[0].attachments).to.exist
|
|
|
- expect(jsonObj.items[0].attachments.length).to.be.eq(4)
|
|
|
-
|
|
|
- for (let i = 0; i < 4; i++) {
|
|
|
- expect(jsonObj.items[0].attachments[i].mime_type).to.be.eq('application/x-bittorrent')
|
|
|
- expect(jsonObj.items[0].attachments[i].size_in_bytes).to.be.greaterThan(0)
|
|
|
- expect(jsonObj.items[0].attachments[i].url).to.exist
|
|
|
- }
|
|
|
- })
|
|
|
+ const json = await serverHLSOnly.feed.getJSON({ feed: 'videos', ignoreCache: true })
|
|
|
+ const jsonObj = JSON.parse(json)
|
|
|
+ expect(jsonObj.items.length).to.be.equal(1)
|
|
|
+ expect(jsonObj.items[0].attachments).to.exist
|
|
|
+ expect(jsonObj.items[0].attachments.length).to.be.eq(4)
|
|
|
|
|
|
- it('Should not display waiting live videos', async function () {
|
|
|
- const { uuid } = await servers[0].live.create({
|
|
|
- fields: {
|
|
|
- name: 'live',
|
|
|
- privacy: VideoPrivacy.PUBLIC,
|
|
|
- channelId: rootChannelId
|
|
|
+ for (let i = 0; i < 4; i++) {
|
|
|
+ expect(jsonObj.items[0].attachments[i].mime_type).to.be.eq('application/x-bittorrent')
|
|
|
+ expect(jsonObj.items[0].attachments[i].size_in_bytes).to.be.greaterThan(0)
|
|
|
+ expect(jsonObj.items[0].attachments[i].url).to.exist
|
|
|
}
|
|
|
})
|
|
|
- liveId = uuid
|
|
|
|
|
|
- const json = await servers[0].feed.getJSON({ feed: 'videos', ignoreCache: true })
|
|
|
+ it('Should not display waiting live videos', async function () {
|
|
|
+ const { uuid } = await servers[0].live.create({
|
|
|
+ fields: {
|
|
|
+ name: 'live',
|
|
|
+ privacy: VideoPrivacy.PUBLIC,
|
|
|
+ channelId: rootChannelId
|
|
|
+ }
|
|
|
+ })
|
|
|
+ liveId = uuid
|
|
|
|
|
|
- const jsonObj = JSON.parse(json)
|
|
|
- expect(jsonObj.items.length).to.be.equal(2)
|
|
|
- expect(jsonObj.items[0].title).to.equal('my super name for server 1')
|
|
|
- expect(jsonObj.items[1].title).to.equal('user video')
|
|
|
- })
|
|
|
+ const json = await servers[0].feed.getJSON({ feed: 'videos', ignoreCache: true })
|
|
|
+
|
|
|
+ const jsonObj = JSON.parse(json)
|
|
|
+ expect(jsonObj.items.length).to.be.equal(2)
|
|
|
+ expect(jsonObj.items[0].title).to.equal('my super name for server 1')
|
|
|
+ expect(jsonObj.items[1].title).to.equal('user video')
|
|
|
+ })
|
|
|
|
|
|
- it('Should display published live videos', async function () {
|
|
|
- this.timeout(120000)
|
|
|
+ it('Should display published live videos', async function () {
|
|
|
+ this.timeout(120000)
|
|
|
|
|
|
- const ffmpeg = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveId, copyCodecs: true, fixtureName: 'video_short.mp4' })
|
|
|
- await servers[0].live.waitUntilPublished({ videoId: liveId })
|
|
|
+ const ffmpeg = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveId, copyCodecs: true, fixtureName: 'video_short.mp4' })
|
|
|
+ await servers[0].live.waitUntilPublished({ videoId: liveId })
|
|
|
|
|
|
- const json = await servers[0].feed.getJSON({ feed: 'videos', ignoreCache: true })
|
|
|
+ const json = await servers[0].feed.getJSON({ feed: 'videos', ignoreCache: true })
|
|
|
|
|
|
- const jsonObj = JSON.parse(json)
|
|
|
- expect(jsonObj.items.length).to.be.equal(3)
|
|
|
- expect(jsonObj.items[0].title).to.equal('live')
|
|
|
- expect(jsonObj.items[1].title).to.equal('my super name for server 1')
|
|
|
- expect(jsonObj.items[2].title).to.equal('user video')
|
|
|
+ const jsonObj = JSON.parse(json)
|
|
|
+ expect(jsonObj.items.length).to.be.equal(3)
|
|
|
+ expect(jsonObj.items[0].title).to.equal('live')
|
|
|
+ expect(jsonObj.items[1].title).to.equal('my super name for server 1')
|
|
|
+ expect(jsonObj.items[2].title).to.equal('user video')
|
|
|
|
|
|
- await stopFfmpeg(ffmpeg)
|
|
|
- })
|
|
|
+ await stopFfmpeg(ffmpeg)
|
|
|
+ })
|
|
|
|
|
|
- it('Should have the channel avatar as feed icon', async function () {
|
|
|
- const json = await servers[0].feed.getJSON({ feed: 'videos', query: { videoChannelId: rootChannelId }, ignoreCache: true })
|
|
|
+ it('Should have the channel avatar as feed icon', async function () {
|
|
|
+ const json = await servers[0].feed.getJSON({ feed: 'videos', query: { videoChannelId: rootChannelId }, ignoreCache: true })
|
|
|
|
|
|
- const jsonObj = JSON.parse(json)
|
|
|
- const imageUrl = jsonObj.icon
|
|
|
- expect(imageUrl).to.include('/lazy-static/avatars/')
|
|
|
- await makeRawRequest({ url: imageUrl, expectedStatus: HttpStatusCode.OK_200 })
|
|
|
+ const jsonObj = JSON.parse(json)
|
|
|
+ const imageUrl = jsonObj.icon
|
|
|
+ expect(imageUrl).to.include('/lazy-static/avatars/')
|
|
|
+ await makeRawRequest({ url: imageUrl, expectedStatus: HttpStatusCode.OK_200 })
|
|
|
+ })
|
|
|
})
|
|
|
})
|
|
|
|
|
@@ -470,6 +605,8 @@ describe('Test syndication feeds', () => {
|
|
|
})
|
|
|
|
|
|
after(async function () {
|
|
|
+ await servers[0].plugins.uninstall({ npmName: 'peertube-plugin-test-podcast-custom-tags' })
|
|
|
+
|
|
|
await cleanupTests([ ...servers, serverHLSOnly ])
|
|
|
})
|
|
|
})
|