362 lines
11 KiB
TypeScript
362 lines
11 KiB
TypeScript
// external lib
|
|
import * as parserModule from "rss-parser";
|
|
|
|
// tested class
|
|
import {
|
|
ListenerRSSInfos as ListenerRRSInfo,
|
|
ListenerRss as Listeners,
|
|
} from "./../src/index";
|
|
|
|
// Unit test
|
|
import * as chai from "chai";
|
|
import * as sinon from "ts-sinon";
|
|
import { ImportMock } from "ts-mock-imports";
|
|
|
|
const sinonChai = require("sinon-chai");
|
|
|
|
chai.use(sinonChai);
|
|
|
|
const expect = chai.expect;
|
|
|
|
describe("test class RSS: jsonfile", function () {
|
|
const infosListener: ListenerRRSInfo = {
|
|
name: "my-test-service",
|
|
address: "fake.rss.service",
|
|
timeloop: 15,
|
|
customfields: {
|
|
description: ["media:group", "media:description"],
|
|
icon: ["media:group", "media:thumbnail"],
|
|
},
|
|
};
|
|
|
|
// parseURL tests
|
|
let stubListener: sinon.StubbedInstance<Listeners>;
|
|
let stubParser: sinon.StubbedInstance<Parser>;
|
|
|
|
const mockedRSSOutput: Parser.Output<{
|
|
"media:group": { [key: string]: string | [any] };
|
|
}> = {
|
|
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",
|
|
},
|
|
],
|
|
};
|
|
|
|
/**
|
|
* The function create my Stubs for my Listener and my Parser
|
|
*/
|
|
// function fun_initStub(
|
|
// myListener: Listeners
|
|
// ): sinon.StubbedInstance<Listeners> {
|
|
// stubListener = sinon.stubObject<Listeners>(myListener, ["setParser"]);
|
|
// stubListener.setParser.callsFake(() => {
|
|
// if (stubListener.parser !== undefined) {
|
|
// stubParser = sinon.stubObject<Parser>(stubListener.parser, [
|
|
// "parseURL",
|
|
// ]);
|
|
// stubParser.parseURL
|
|
// .withArgs(infosListener.address)
|
|
// .resolves(mockedRSSOutput);
|
|
// stubParser.parseURL
|
|
// .withArgs("bad.rss.service")
|
|
// .rejects(new Error("connect ECONNREFUSED 127.0.0.1:80"));
|
|
// }
|
|
// stubListener.parser = stubParser;
|
|
// });
|
|
// stubListener.setParser();
|
|
// // stubListener.fetchRSS.returns(stubParser.parseURL(stubListener.address));
|
|
// return stubListener;
|
|
// }
|
|
|
|
// afterEach(function () {
|
|
// // restore stubs
|
|
// myListener = undefined;
|
|
// });
|
|
|
|
describe("Building Ytb listener", function () {
|
|
it("The build without issues (infosListener parameters)", function () {
|
|
let 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)
|
|
.to.have.property("options")
|
|
.to.have.property("customFields")
|
|
.to.be.eql({
|
|
feed: [],
|
|
item: ["media:group", "media:group"],
|
|
});
|
|
});
|
|
it("The build without issues (raw infos : 4 params)", function () {
|
|
let myListener = new Listeners({
|
|
name: "my-test-service",
|
|
address: "fake.rss.service",
|
|
timeloop: 15,
|
|
customfields: {
|
|
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)
|
|
.to.have.property("options")
|
|
.to.have.property("customFields")
|
|
.to.be.eql({
|
|
feed: [],
|
|
item: ["media:group", "media:group"],
|
|
});
|
|
});
|
|
it("The build without issues (raw infos : just 2 params)", function () {
|
|
let myListener = new Listeners({
|
|
name: "my-test-service",
|
|
address: "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(undefined);
|
|
expect(myListener.parser)
|
|
.to.have.property("options")
|
|
.to.have.property("customFields")
|
|
.to.be.eql({
|
|
feed: [],
|
|
item: [],
|
|
});
|
|
});
|
|
});
|
|
it("The build without issues (raw infos : just 3 params (no custom fields))", function () {
|
|
let myListener = new Listeners({
|
|
name: "my-test-service",
|
|
address: "fake.rss.service",
|
|
timeloop: 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(undefined);
|
|
expect(myListener.parser)
|
|
.to.have.property("options")
|
|
.to.have.property("customFields")
|
|
.to.be.eql({
|
|
feed: [],
|
|
item: [],
|
|
});
|
|
});
|
|
it("The build without issues (raw infos : just 3 params (no timeloop))", function () {
|
|
let myListener = new Listeners({
|
|
name: "my-test-service",
|
|
address: "fake.rss.service",
|
|
customfields: {
|
|
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)
|
|
.to.have.property("options")
|
|
.to.have.property("customFields")
|
|
.to.be.eql({
|
|
feed: [],
|
|
item: ["media:group", "media:group"],
|
|
});
|
|
});
|
|
|
|
describe("fetch some data", function () {
|
|
it.only("fetch without issues", function () {
|
|
const mockManager = ImportMock.mockClass<
|
|
parserModule.default,
|
|
typeof parserModule
|
|
>(parserModule.default);
|
|
mockManager.mock("parseURL").resolves(mockedRSSOutput);
|
|
const myListener = new Listeners(infosListener);
|
|
|
|
// fetch
|
|
let res = myListener.fetchRSS();
|
|
|
|
//assertion
|
|
// calls
|
|
return res
|
|
.then((obj: any) => {
|
|
expect(obj).to.be.eql(mockedRSSOutput);
|
|
})
|
|
.catch((err) => {
|
|
expect(err).to.be.undefined;
|
|
});
|
|
});
|
|
|
|
// it("fetch with bad address", function () {
|
|
// let myListener = new Listeners({
|
|
// name: "my-test-service",
|
|
// address: "bad.rss.service",
|
|
// customfields: {
|
|
// description: ["media:group", "media:description"],
|
|
// icon: ["media:group", "media:thumbnail"],
|
|
// },
|
|
// });
|
|
// let stubListener = fun_initStub(myListener);
|
|
// // fetch
|
|
// let res = stubListener.fetchRSS();
|
|
|
|
// //assertion
|
|
// // calls
|
|
// expect(stubParser.parseURL).to.have.been.calledOnce;
|
|
// expect(stubParser.parseURL).to.have.been.calledWith("bad.rss.service");
|
|
// // Promise
|
|
// res
|
|
// .then((obj: any) => {
|
|
// expect(obj).to.be.undefined;
|
|
// })
|
|
// .catch((err) => {
|
|
// expect(err).to.be.eql(new Error("connect ECONNREFUSED 127.0.0.1:80"));
|
|
// });
|
|
// });
|
|
});
|
|
|
|
// describe.skip("start", function () {
|
|
// it("Let's start the timer", async function () {
|
|
// let clock: sinon.default.SinonFakeTimers = sinon.default.useFakeTimers();
|
|
|
|
// // classic build
|
|
// let myListener = new Listeners({
|
|
// name: "my-test-service",
|
|
// address: "fake.rss.service",
|
|
// timeloop: 60,
|
|
// customfields: {
|
|
// description: ["media:group", "media:description"],
|
|
// icon: ["media:group", "media:thumbnail"],
|
|
// },
|
|
// });
|
|
// let stubListener = fun_initStub(myListener);
|
|
// stubListener.fetchRSS.reset();
|
|
// stubListener.fetchRSS.resolves(mockedRSSOutput);
|
|
|
|
// //spy
|
|
// let fun_spy: sinon.default.SinonSpy = sinon.default.spy((obj, err) => {
|
|
// expect(obj).to.be.eql(mockedRSSOutput);
|
|
// expect(err).to.be.eql(undefined);
|
|
// });
|
|
|
|
// // start timer
|
|
// stubListener.on("update", (obj) => fun_spy(obj));
|
|
// // stubListener.start(fun_spy);
|
|
|
|
// // wait and assertion
|
|
// // After 1ms
|
|
// await clock.tickAsync(1);
|
|
// expect(stubListener.fetchRSS).to.have.been.calledOnce;
|
|
// expect(fun_spy).to.have.been.calledOnce;
|
|
|
|
// // After 60s
|
|
// await clock.tickAsync(59999);
|
|
// expect(stubListener.fetchRSS).to.have.been.calledTwice;
|
|
// expect(fun_spy).to.have.been.calledTwice;
|
|
|
|
// stubListener.stop();
|
|
// });
|
|
|
|
// it("Let's start the timer (with a bad address)", async function () {
|
|
// let clock: sinon.default.SinonFakeTimers = sinon.default.useFakeTimers();
|
|
|
|
// // classic build
|
|
// let myListener = new Listeners({
|
|
// name: "my-test-service",
|
|
// address: "fake.rss.service",
|
|
// timeloop: 60,
|
|
// customfields: {
|
|
// description: ["media:group", "media:description"],
|
|
// icon: ["media:group", "media:thumbnail"],
|
|
// },
|
|
// });
|
|
// let stubListener = fun_initStub(myListener);
|
|
// stubListener.fetchRSS.reset();
|
|
// stubListener.fetchRSS.rejects(
|
|
// new Error("connect ECONNREFUSED 127.0.0.1:80")
|
|
// );
|
|
|
|
// //spy
|
|
// let fun_spy: sinon.default.SinonSpy = sinon.default.spy((obj, err) => {
|
|
// expect(obj).to.be.eql(undefined);
|
|
// expect(err).to.not.be.eql(undefined);
|
|
// });
|
|
|
|
// // start timer
|
|
// // stubListener.start(fun_spy);
|
|
|
|
// // wait and assertion
|
|
// // After 1ms
|
|
// await clock.tickAsync(1);
|
|
// expect(stubListener.fetchRSS).to.have.been.calledOnce;
|
|
// expect(fun_spy).to.have.been.calledOnce;
|
|
|
|
// // After 60s
|
|
// await clock.tickAsync(59999);
|
|
// expect(stubListener.fetchRSS).to.have.been.calledTwice;
|
|
// expect(fun_spy).to.have.been.calledTwice;
|
|
|
|
// stubListener.stop();
|
|
// });
|
|
// });
|
|
});
|