listener-rss/tests/index-spec.ts

// external lib
import * as Parser 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 sinonChai from "sinon-chai";

const sinonChai = require("sinon-chai");

chai.use(sinonChai);

const expect = chai.expect;

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

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

  // parseURL tests
  let stubParser: sinon.StubbedInstance<Parser>;
  const mockedRSSOutput: any = {
    // TODO any = pas bien
    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.stubObject<Parser>(Parser.prototype, ["parseURL"]);

    stubParser.parseURL
      .withArgs(infosListener.address)
      .resolves(mockedRSSOutput);
    stubParser.parseURL
      .withArgs("bad.rss.service")
      .rejects(new Error("connect ECONNREFUSED 127.0.0.1:80"));

    // constructor
    myListener = undefined;
  });

  afterEach(function () {
    // restore stubs
  });

  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"]],
      ]);
      /* // TODO test des champs dans l'objet parser
      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(undefined);
      /*
      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(undefined);
      /*
      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);

      myListener.parser = stubParser; // replace the parser by my fake parser
      // fetch
      let res = myListener.fetchRSS();

      //assertion
      // calls
      expect(stubParser.parseURL).to.have.been.calledOnce;
      expect(stubParser.parseURL).to.have.been.calledWith(
        infosListener._address
      );
      // Promise
      //await expect(Promise.resolve(res)).to.be.eql(mockedRSSOutput);
      res.then((obj: any, err: Error) => {
        // TODO
        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"]],
        ]
      );
      myListener.parser = stubParser; // replace the parser by my fake parser
      // fetch
      let res = myListener.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, err: Error) => {
        expect(obj).to.be.undefined;
        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 () {
      //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.default.SinonSpy = sinon.default.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.default.SinonSpy = sinon.default.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
    });
  });
});