salix/modules/invoiceIn/back/methods/invoice-in/specs/exchangeRateUpdate.spec.js

describe('exchangeRateUpdate functionality', function() {
    const axios = require('axios');
    const models = require('vn-loopback/server/server').models;
    let tx; let options;

    function formatYmd(d) {
        const mm = (d.getMonth() + 1).toString().padStart(2, '0');
        const dd = d.getDate().toString().padStart(2, '0');
        return `${d.getFullYear()}-${mm}-${dd}`;
    }

    afterEach(async() => {
        await tx.rollback();
    });

    beforeEach(async() => {
        tx = await models.Sale.beginTransaction({});
        options = {transaction: tx};
        spyOn(axios, 'get').and.returnValue(Promise.resolve({data: ''}));
    });

    it('should process XML data and create rates', async function() {
        const d1 = Date.vnNew();
        const d4 = Date.vnNew();
        d4.setDate(d4.getDate() + 1);
        const xml = `<Cube>
        <Cube time='${formatYmd(d1)}'>
          <Cube currency='USD' rate='1.1'/>
          <Cube currency='CNY' rate='1.2'/>
        </Cube>
        <Cube time='${formatYmd(d4)}'>
          <Cube currency='USD' rate='1.3'/>
        </Cube>
      </Cube>`;
        axios.get.and.returnValue(Promise.resolve({data: xml}));
        spyOn(models.ReferenceRate, 'findOne').and.returnValue(Promise.resolve(null));
        spyOn(models.ReferenceRate, 'create').and.returnValue(Promise.resolve());
        await models.InvoiceIn.exchangeRateUpdate(options);

        expect(models.ReferenceRate.create).toHaveBeenCalledTimes(3);
    });

    it('should handle no data', async function() {
        axios.get.and.returnValue(Promise.resolve({}));
        spyOn(models.ReferenceRate, 'create');
        let e;
        try {
            await models.InvoiceIn.exchangeRateUpdate(options);
        } catch (err) {
            e = err;
        }

        expect(e.message).toBe('No cubes found. Exiting the method.');
        expect(models.ReferenceRate.create).not.toHaveBeenCalled();
    });

    it('should handle errors', async function() {
        axios.get.and.returnValue(Promise.reject(new Error('Network error')));
        let e;
        try {
            await models.InvoiceIn.exchangeRateUpdate(options);
        } catch (err) {
            e = err;
        }

        expect(e).toBeDefined();
        expect(e.message).toBe('Network error');
    });

    it('should update existing rate', async function() {
        const existingRate = await models.ReferenceRate.findOne({
            order: 'id DESC'
        }, options);

        if (!existingRate) return fail('No ReferenceRate records in DB');

        const currency = await models.Currency.findById(existingRate.currencyFk, null, options);

        const xml = `<Cube>
          <Cube time='${formatYmd(existingRate.dated)}'>
            <Cube currency='${currency.code}' rate='2.22'/>
          </Cube>
        </Cube>`;

        axios.get.and.returnValue(Promise.resolve({data: xml}));

        await models.InvoiceIn.exchangeRateUpdate(options);

        const updatedRate = await models.ReferenceRate.findById(existingRate.id, null, options);

        expect(updatedRate.value).toBeCloseTo('2.22');
    });

    it('should not update if same rate', async function() {
        const existingRate = await models.ReferenceRate.findOne({order: 'id DESC'}, options);
        if (!existingRate) return fail('No existing ReferenceRate in DB');

        const currency = await models.Currency.findById(existingRate.currencyFk, null, options);

        const oldValue = existingRate.value;
        const xml = `<Cube>
          <Cube time='${formatYmd(existingRate.dated)}'>
            <Cube currency='${currency.code}' rate='${oldValue}'/>
          </Cube>
        </Cube>`;

        axios.get.and.returnValue(Promise.resolve({data: xml}));

        await models.InvoiceIn.exchangeRateUpdate(options);

        const updatedRate = await models.ReferenceRate.findById(existingRate.id, null, options);

        expect(updatedRate.value).toBe(oldValue);
    });

    it('should backfill missing dates', async function() {
        const lastRate = await models.ReferenceRate.findOne({order: 'dated DESC'}, options);
        if (!lastRate) return fail('No existing ReferenceRate data in DB');

        const currency = await models.Currency.findById(lastRate.currencyFk, null, options);

        const d1 = new Date(lastRate.dated);
        d1.setDate(d1.getDate() + 1);
        const d4 = new Date(lastRate.dated);
        d4.setDate(d4.getDate() + 4);

        const xml = `<Cube>
          <Cube time='${formatYmd(d1)}'>
            <Cube currency='${currency.code}' rate='1.0'/>
          </Cube>
          <Cube time='${formatYmd(d4)}'>
            <Cube currency='${currency.code}' rate='2.0'/>
          </Cube>
        </Cube>`;

        axios.get.and.returnValue(Promise.resolve({data: xml}));

        const beforeCount = await models.ReferenceRate.count({}, options);
        await models.InvoiceIn.exchangeRateUpdate(options);
        const afterCount = await models.ReferenceRate.count({}, options);

        expect(afterCount - beforeCount).toBe(4);
    });

    it('should create entries for day1 and day2 from the feed, and not backfill day3', async function() {
        const lastRate = await models.ReferenceRate.findOne({order: 'dated DESC'}, options);
        if (!lastRate) return fail('No existing ReferenceRate data in DB');

        const currency = await models.Currency.findById(lastRate.currencyFk, null, options);
        if (!currency) return fail(`No currency for ID ${lastRate.currencyFk}`);

        const day1 = new Date(lastRate.dated);
        day1.setDate(day1.getDate() + 1);

        const day2 = new Date(lastRate.dated);
        day2.setDate(day2.getDate() + 2);

        const day3 = new Date(lastRate.dated);
        day3.setDate(day3.getDate() + 3);

        const xml = `<Cube>
          <Cube time='${formatYmd(day1)}'>
            <Cube currency='${currency.code}' rate='1.1'/>
          </Cube>
          <Cube time='${formatYmd(day2)}'>
            <Cube currency='${currency.code}' rate='2.2'/>
          </Cube>
        </Cube>`;

        axios.get.and.returnValue(Promise.resolve({data: xml}));

        await models.InvoiceIn.exchangeRateUpdate(options);

        const day3Record = await models.ReferenceRate.findOne({
            where: {currencyFk: currency.id, dated: day3}
        }, options);

        expect(day3Record).toBeNull();

        const day1Record = await models.ReferenceRate.findOne({
            where: {currencyFk: currency.id, dated: day1}
        }, options);
        const day2Record = await models.ReferenceRate.findOne({
            where: {currencyFk: currency.id, dated: day2}
        }, options);

        expect(day1Record.value).toBeCloseTo('1.1');
        expect(day2Record.value).toBeCloseTo('2.2');
    });
});