oa-jira/tests/unit/model/classes/changes.class.spec.js

Octet Agile's JIRA connectivity project.

const Change = require('../../../../src/model/classes/change.class');
const Changes = require('../../../../src/model/classes/changes.class');
const Sprint = require('../../../../src/model/classes/sprint.class');

describe('Check [Changes] class.', () => {
  const sprint122 = new Sprint({ id: 122, state: 'future', name: 'Minimal' });
  const sprint120 = new Sprint({
    id: 120,
    state: ' closed ',
    name: ' Closed ',
    startDate: new Date('2024-03-07T17:57:09.121Z'),
    endDate: new Date('2024-03-14T17:57:06.000Z'),
    completeDate: new Date('2024-03-27T05:39:12.081Z'),
    createdDate: new Date('2024-03-07T17:44:01.166Z'),
    originBoardId: 1,
    goal: ' A Goal '
  });

  const changeSprint = new Change({ name: ' sprint ', source: sprint122, target: sprint120 });
  const changeComplexity = new Change({ name: ' complexity ', source: 'source', target: 'target' });
  const changeSummary = new Change({ name: ' summary ', target: 'target' });
  const changeUpdated = new Change({ name: ' updated ', source: 'source' });

  const empty = { changes: [] };
  const minimal = { changes: [changeComplexity] };
  const maximal = { changes: [changeComplexity, changeSummary, changeUpdated, changeSprint] };

  const emptyJSON = {};
  const minJSON = { complexity: changeComplexity.toJSON({ unit: false }) };
  const maxJSON = {
    complexity: changeComplexity.toJSON({ unit: false }),
    summary: changeSummary.toJSON({ unit: false }),
    updated: changeUpdated.toJSON({ unit: false }),
    sprint: changeSprint.toJSON({ unit: false })
  };

  const cases = {
    nominal: [[empty], [minimal], [maximal]],
    invalid: [
      ['A [bulk of changes] MUST be a [array].', { changes: 2 }],
      ['A [change] MUST implements [Change].', { changes: [2] }]
    ]
  };

  describe('Check constructor.', () => {
    it('should reject error when given nothing.', () => {
      expect(() => new Changes()).toThrow();
    });

    it.each(cases.nominal)('should resolve a new instance when init with [%p]', given => {
      expect(new Changes(given)).toBeInstanceOf(Changes);
    });

    it.each(cases.invalid)('should reject [%p] when create from [%p]', (error, given) => {
      expect(() => new Changes(given)).toThrow(error);
    });
  });

  describe('Check getters.', () => {
    describe('Check [size] getter.', () => {
      it.each(cases.nominal)('should return the given trimmed name when init with [%p]', given => {
        expect(new Changes(given).getSize()).toEqual(given.changes.length);
      });
    });

    describe('Check [is empty] getter.', () => {
      it.each(cases.nominal)('should return the given source when init with [%p]', given => {
        expect(new Changes(given).isEmpty()).toEqual(given.changes.length === 0);
      });
    });

    describe('Check [to Array] getter.', () => {
      it.each(cases.nominal)('should return the given source when init with [%p]', given => {
        expect(new Changes(given).toArray()).toEqual(given.changes);
      });
    });
  });

  describe('Check utilities.', () => {
    describe('Check [to string] utility.', () => {
      it.each(cases.nominal)('should return expected string representation when init with [%p]', given => {
        expect(`${new Changes(given)}`).toEqual(`Changes[${given.changes.length}]`);
      });
    });

    describe('Check [to JSON] utility.', () => {
      it('should return expected representation when given empty', () => {
        expect(new Changes(empty).toJSON()).toEqual(emptyJSON);
      });

      it('should return expected representation when given minimum case', () => {
        expect(new Changes(minimal).toJSON()).toEqual(minJSON);
      });

      it('should return expected representation when given maximum case', () => {
        expect(new Changes(maximal).toJSON()).toEqual(maxJSON);
      });
    });
  });

  describe('Check static utilities.', () => {
    describe('Check [create] static utility.', () => {
      it('should reject error when given nothing.', () => {
        expect(Changes.create()).rejects.toThrow();
      });

      it.each(cases.nominal)('should resolve a new instance when init with [%p]', given => {
        expect(Changes.create(given)).resolves.toBeInstanceOf(Changes);
      });

      it.each(cases.invalid)('should reject [%p] when create from [%p]', (error, given) => {
        expect(Changes.create(given)).rejects.toThrow(error);
      });
    });

    describe('Check [check] static utility.', () => {
      it('should throw when given is falsy.', () => {
        expect(() => Changes.check()).toThrow('A [changes] is mandatory and cannot be falsy.');
      });

      it('should throw when given does not implements expected class.', () => {
        expect(() => Changes.check(2)).toThrow('A [changes] MUST implements [Changes].');
      });

      it.each(cases.nominal)('should return given when given is initialised with [%p].', given => {
        const instance = new Changes(given);
        expect(Changes.check(instance)).toBe(instance);
      });
    });

    describe('Check [resolve] static utility.', () => {
      it('should reject when given is falsy.', () => {
        expect(Changes.resolve()).rejects.toThrow('A [changes] is mandatory and cannot be falsy.');
      });

      it('should reject when given does not implements expected class.', () => {
        expect(Changes.resolve(2)).rejects.toThrow('A [changes] MUST implements [Changes].');
      });

      it.each(cases.nominal)('should resolve given when given is initialised with [%p].', given => {
        const instance = new Changes(given);
        expect(Changes.resolve(instance)).resolves.toBe(instance);
      });
    });
  });
});