SkeptiCOM/tests/rss-youtube-spec.js

    // external lib
const Parser = require("rss-parser");

    // tested class
/*const ListenerRssPackage = require("../index");

const Listeners = ListenerRssPackage.ListenerRss
const ListenerRRSInfo = ListenerRssPackage.ListenerRssInfos*/
    const Listeners = require('../src/ListenerRss')
    const ListenerRRSInfo = require('../src/Models/ListenerRSSInfos')

    // Unit test
const chai = require("chai");
const sinon = require("sinon");
const sinon_chai = require("sinon-chai");
chai.use(sinon_chai);


const expect = chai.expect;

describe("test class RSS: jsonfile", function () {
    let myListener = undefined;

    const infosListener = new ListenerRRSInfo('my-test-service', 'fake.rss.service', 15, [
        ['description', ['media:group', 'media:description']],
        ['icon', ['media:group', 'media:thumbnail']]
    ]);

        // parseURL tests
    let stubParser;

    const mockedRSSOutput = {
        items: [
            {
                'title': 'my title 00',
                'media:group': {
                    'media:description': 'my description 00',
                    'media:thumbnail': [{$: {height: 360, width: 420, url: 'my_image00.jpg'}}],
                },
                'link': 'my_url_00.com',
                'pubDate': 'myDate00'
            },
            {
                'title': 'my title 01',
                'media:group' : {
                    'media:description': 'my description 01',
                    'media:thumbnail': [{$: { height: 360, width: 420, url: 'my_image01.jpg'}}],
                },
                'link': 'my_url_01.com',
                'pubDate': 'myDate01'
            },
            {
                'title': 'my title 02',
                'media:group' : {
                    'media:description': 'my description 02',
                    'media:thumbnail': [{$: { height: 360, width: 420, url: 'my_image02.jpg'}}],
                },
                'link': 'my_url_02.com',
                'pubDate': 'myDate02'
            },
        ]
    };

    beforeEach(function () {
        // stubs
        stubParser = sinon.stub(Parser.prototype, 'parseURL');
        stubParser.withArgs(infosListener.address)
            .resolves(mockedRSSOutput);
        stubParser.withArgs('bad.rss.service')
            .resolves(new Error('connect ECONNREFUSED 127.0.0.1:80'));

        // constructor
        myListener = undefined;
    })

    afterEach(function () {
        // restore stubs
        Parser.prototype.parseURL.restore();
    });

    describe("Building Ytb listener", function () {
        it("The build without issues (infosListener parameters)", function () {
            myListener = new Listeners(infosListener);

            // assertions
                // myListener data
            expect(myListener.timeloop).to.eql(15);
            expect(myListener.name).to.eql('my-test-service');
            expect(myListener.address).to.eql('fake.rss.service');
            expect(myListener.customfields).to.eql([
                ['description', ['media:group', 'media:description']],
                ['icon', ['media:group', 'media:thumbnail']]
            ]);
            expect(myListener.parser.options.customFields).to.eql({
                    feed: [],
                    item: [
                        'media:group',
                        'media:group'
                    ]
            });
        });
        it("The build without issues (raw infos : 4 params)", function () {
            myListener = new Listeners('my-test-service', 'fake.rss.service', 15, [
                ['description', ['media:group', 'media:description']],
                ['icon', ['media:group', 'media:thumbnail']]
            ]);

            // assertions
                // myListener data
            expect(myListener.timeloop).to.eql(15);
            expect(myListener.name).to.eql('my-test-service');
            expect(myListener.address).to.eql('fake.rss.service');
            expect(myListener.customfields).to.eql([
                ['description', ['media:group', 'media:description']],
                ['icon', ['media:group', 'media:thumbnail']]
            ]);
            expect(myListener.parser.options.customFields).to.eql({
                feed: [],
                item: [
                    'media:group',
                    'media:group'
                ]
            });
        });
        it("The build without issues (raw infos : just 2 params)", function () {
            myListener = new Listeners('my-test-service', 'fake.rss.service');

            // assertions
            // myListener data
            expect(myListener.timeloop).to.eql(5*60);
            expect(myListener.name).to.eql('my-test-service');
            expect(myListener.address).to.eql('fake.rss.service');
            expect(myListener.customfields).to.eql([]);
            expect(myListener.parser.options.customFields).to.eql({
                feed: [],
                item: []
            });
        });
        it("The build without issues (raw infos : just 3 params (no custom fields))", function () {
            myListener = new Listeners('my-test-service', 'fake.rss.service', 15);

            // assertions
            // myListener data
            expect(myListener.timeloop).to.eql(15);
            expect(myListener.name).to.eql('my-test-service');
            expect(myListener.address).to.eql('fake.rss.service');
            expect(myListener.customfields).to.eql([]);
            expect(myListener.parser.options.customFields).to.eql({
                feed: [],
                item: []
            });
        });
        it("The build without issues (raw infos : just 3 params (no timeloop))", function () {
            myListener = new Listeners('my-test-service', 'fake.rss.service', undefined, [
                ['description', ['media:group', 'media:description']],
                ['icon', ['media:group', 'media:thumbnail']]
            ]);

            // assertions
            // myListener data
            expect(myListener.timeloop).to.eql(5*60);
            expect(myListener.name).to.eql('my-test-service');
            expect(myListener.address).to.eql('fake.rss.service');
            expect(myListener.customfields).to.eql([
                ['description', ['media:group', 'media:description']],
                ['icon', ['media:group', 'media:thumbnail']]
            ]);
            expect(myListener.parser.options.customFields).to.eql({
                feed: [],
                item: [
                    'media:group',
                    'media:group'
                ]
            });
        });
    });

    describe("fetch some data", function () {
        it("fetch without issues",  function () {
            // classic build
            myListener = new Listeners(infosListener);
            // fetch
            let res = myListener.fetchRSS();

            //assertion
            // calls
            expect(stubParser).to.have.been.calledOnce;
            expect(stubParser).to.have.been.calledWith(infosListener._address);
            // Promise
            //await expect(Promise.resolve(res)).to.be.eql(mockedRSSOutput);
            res.then((obj, err) => {
                expect(obj).to.be.eql(mockedRSSOutput);
                expect(err).to.be.undefined
            })
        })
        it("fetch with bad address", function () {
            // classic build
            myListener = new Listeners('my-test-service', 'bad.rss.service', undefined, [
                ['description', ['media:group', 'media:description']],
                ['icon', ['media:group', 'media:thumbnail']]
            ]);
            // fetch
            let res = myListener.fetchRSS();

            //assertion
            // calls
            expect(stubParser).to.have.been.calledOnce;
            expect(stubParser).to.have.been.calledWith('bad.rss.service');
            // Promise
            res.then((obj, err) => {
                expect(obj).to.be.undefined
                expect(err).to.be.eql(new Error('connect ECONNREFUSED 127.0.0.1:80'))
            });
        })
    })

    describe("start", function () {
        it("Let's start the timer", async function () {
            //custom timeout
            this.timeout(15000);

            // classic build
            myListener = new Listeners('my-test-service', 'fake.rss.service', 2, [
                ['description', ['media:group', 'media:description']],
                ['icon', ['media:group', 'media:thumbnail']]
            ]);

            //spy
            const fun_spy = sinon.spy();

            // start timer
            myListener.start(fun_spy);

            await new Promise(res => setTimeout(res, 5 * 1000));

            myListener.stop();

            //assertion
            // calls
            expect(1).to.be.eql(1);
            expect(fun_spy).to.have.been.callCount(3);
            expect(fun_spy).to.have.been.calledWith(mockedRSSOutput, undefined);
        });
        it("Let's start the timer (with a bad address)", async function () {
            //custom timeout
            this.timeout(15000)

            // classic build
            myListener = new Listeners('my-test-service', 'bad.rss.service', 2, [
                ['description', ['media:group', 'media:description']],
                ['icon', ['media:group', 'media:thumbnail']]
            ]);

            //spy
            const fun_spy = sinon.spy();

            // start timer
            myListener.start(fun_spy);

            await new Promise(res => setTimeout(res, 5 * 1000));

            myListener.stop();
            //assertion
            // calls
            expect(1).to.be.eql(1);
            expect(fun_spy).to.have.been.callCount(3);
            expect(fun_spy).to.have.been.calledWith(undefined, Error); //yagni
        });
    });
});