oa-jira/tests/unit/model/services/versions.services.spec.js

Octet Agile's JIRA connectivity project.

const AxiosMock = require('../../../mocks/jira/axios.mock');
const Version = require('../../../../src/model/classes/version.class');
const model = require('../../../../src/model');
const oaJira = require('../../../../');
const Connection = require('../../../../src/connection/classes/connection.class');
const Cache = require('../../../../src/cache/classes/cache.class');

describe('Check [Versions] services', () => {
  const connection = new Connection({ mode: 'Bearer', baseUrl: 'localhost', token: 'TOKEN' });
  const cache = new Cache();

  beforeEach(() => cache.reset());

  describe('Check [create] service.', () => {
    it('should reject error when given nothing.', () => {
      expect(model.versions.create()).rejects.toThrow();
    });

    it('should delegate to class static utility.', async () => {
      const spy = jest.spyOn(Version, 'create').mockResolvedValue('OK');
      expect(model.versions.create({ name: 'version' })).resolves.toEqual('OK');
      expect(spy).toHaveBeenCalledWith({ name: 'version' });
      jest.spyOn(Version, 'create').mockRestore();
    });
  });

  describe('Check [resolve] service.', () => {
    it('should delegate to class static utility.', async () => {
      const spy = jest.spyOn(Version, 'resolve').mockResolvedValue('OK');
      expect(model.versions.resolve('version')).resolves.toEqual('OK');
      expect(spy).toHaveBeenCalledWith('version');
      jest.spyOn(Version, 'resolve').mockRestore();
    });
  });

  describe('Check [get by id] service', () => {
    const mock = AxiosMock.init();

    afterEach(() => mock.reset());

    it('should reject when given nothing', async () => {
      expect(oaJira.versions.getById()).rejects.toThrow('A [connection] is mandatory and cannot be falsy.');
    });

    it('should resolve a version class from jira when no cache given', async () => {
      const version = await oaJira.versions.getById({ connection, id: '10003' });
      expect(version).toBeInstanceOf(Version);
      expect(version.getId()).toEqual('10003');
      expect(mock.getSpy()).toHaveBeenCalledTimes(1);
    });

    it('should resolve a version class from jira when nominal', async () => {
      const connection = await oaJira.connection.createBearer({ baseUrl: 'localhost', token: 'TOKEN' });
      const cache = await oaJira.cache.init();

      await model.versions.getById({ connection, id: '10003', cache });
      expect(cache.versions.has('10003')).toBeTruthy();
      expect(mock.getSpy()).toHaveBeenCalledTimes(1);
      const version1 = await oaJira.versions.getById({ connection, id: '10004', cache });
      expect(version1).toBeInstanceOf(Version);
      expect(version1.getId()).toEqual('10004');
      expect(mock.getSpy()).toHaveBeenCalledTimes(2);
      const version2 = await oaJira.versions.getById({ connection, id: '10004', cache });
      expect(version2).toBeInstanceOf(Version);
      expect(version2.getId()).toEqual('10004');
      expect(mock.getSpy()).toHaveBeenCalledTimes(2);
    });

    it('should resolve null when not found', () => {
      expect(oaJira.versions.getById({ connection, id: '404', cache })).resolves.toBeNull();
    });

    it('should reject when fail to retrieve  version  from jira', () => {
      expect(oaJira.versions.getById({ connection, id: '500' })).rejects.toThrow(
        'Fail to [Get [/rest/api/3/version/500] (Status 500)]'
      );
    });
  });
});