oa-jira/tests/unit/cache/classes/cache.class.spec.js

Octet Agile's JIRA connectivity project.

const oaJira = require('../../../../');
const Cache = require('../../../../src/cache/classes/cache.class');

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

    it('should reject when cache does not implements expected one.', () => {
      expect(Cache.resolve(new Error())).rejects.toThrow('A [cache] MUST implements [Cache].');
    });

    it('should resolve given when valid.', () => {
      const cache = new Cache();
      expect(Cache.resolve(cache)).resolves.toBe(cache);
    });
  });

  describe('Check [categories] services', () => {
    it('should reject error when id is missing.', async () => {
      const cache = await oaJira.cache.init();
      expect(cache.categories.set()).rejects.toThrow('A [id] is mandatory and cannot be falsy.');
    });

    it('should reject error when try to store an invalid category', async () => {
      const cache = await oaJira.cache.init();
      expect(cache.categories.set(1, 1)).rejects.toThrow('A [resource] MUST implements [categories].');
      expect(cache.categories.has(1)).toBeFalsy();
    });

    it('should resolve undefined when store undefined', async () => {
      const cache = await oaJira.cache.init();
      await expect(cache.categories.set(1)).resolves.toBeNull();
      expect(cache.categories.has(1)).toBeTruthy();
      cache.reset();
      expect(cache.categories.has(1)).toBeFalsy();
    });
  });

  describe('Check [projects] services', () => {
    it('should reject error when id is missing.', async () => {
      const cache = await oaJira.cache.init();
      expect(cache.projects.set()).rejects.toThrow('A [id] is mandatory and cannot be falsy.');
    });

    it('should reject error when try to store an invalid category', async () => {
      const cache = await oaJira.cache.init();
      expect(cache.projects.set(1, 1)).rejects.toThrow('A [resource] MUST implements [projects].');
      expect(cache.projects.has(1)).toBeFalsy();
    });

    it('should resolve undefined when store undefined', async () => {
      const cache = await oaJira.cache.init();
      await expect(cache.projects.set(1)).resolves.toBeNull();
      expect(cache.projects.has(1)).toBeTruthy();
      cache.reset();
      expect(cache.projects.has(1)).toBeFalsy();
    });
  });

  describe('Check [resolutions] services', () => {
    it('should reject error when id is missing.', async () => {
      const cache = await oaJira.cache.init();
      expect(cache.resolutions.set()).rejects.toThrow('A [id] is mandatory and cannot be falsy.');
    });

    it('should reject error when try to store an invalid category', async () => {
      const cache = await oaJira.cache.init();
      expect(cache.resolutions.set(1, 1)).rejects.toThrow('A [resource] MUST implements [resolutions].');
      expect(cache.resolutions.has(1)).toBeFalsy();
    });

    it('should resolve undefined when store undefined', async () => {
      const cache = await oaJira.cache.init();
      await expect(cache.resolutions.set(1)).resolves.toBeNull();
      expect(cache.resolutions.has(1)).toBeTruthy();
      cache.reset();
      expect(cache.resolutions.has(1)).toBeFalsy();
    });
  });

  describe('Check [sprints] services', () => {
    it('should reject error when id is missing.', async () => {
      const cache = await oaJira.cache.init();
      expect(cache.sprints.set()).rejects.toThrow('A [id] is mandatory and cannot be falsy.');
    });

    it('should reject error when try to store an invalid category', async () => {
      const cache = await oaJira.cache.init();
      expect(cache.sprints.set(1, 1)).rejects.toThrow('A [resource] MUST implements [sprints].');
      expect(cache.sprints.has(1)).toBeFalsy();
    });

    it('should resolve undefined when store undefined', async () => {
      const cache = await oaJira.cache.init();
      await expect(cache.sprints.set(1)).resolves.toBeNull();
      expect(cache.sprints.has(1)).toBeTruthy();
      cache.reset();
      expect(cache.sprints.has(1)).toBeFalsy();
    });
  });

  describe('Check [statuses] services', () => {
    it('should reject error when id is missing.', async () => {
      const cache = await oaJira.cache.init();
      expect(cache.statuses.set()).rejects.toThrow('A [id] is mandatory and cannot be falsy.');
    });

    it('should reject error when try to store an invalid category', async () => {
      const cache = await oaJira.cache.init();
      expect(cache.statuses.set(1, 1)).rejects.toThrow('A [resource] MUST implements [statuses].');
      expect(cache.statuses.has(1)).toBeFalsy();
    });

    it('should resolve undefined when store undefined', async () => {
      const cache = await oaJira.cache.init();
      await expect(cache.statuses.set(1)).resolves.toBeNull();
      expect(cache.statuses.has(1)).toBeTruthy();
      cache.reset();
      expect(cache.statuses.has(1)).toBeFalsy();
    });
  });

  describe('Check [types] services', () => {
    it('should reject error when id is missing.', async () => {
      const cache = await oaJira.cache.init();
      expect(cache.types.set()).rejects.toThrow('A [id] is mandatory and cannot be falsy.');
    });

    it('should reject error when try to store an invalid category', async () => {
      const cache = await oaJira.cache.init();
      expect(cache.types.set(1, 1)).rejects.toThrow('A [resource] MUST implements [types].');
      expect(cache.types.has(1)).toBeFalsy();
    });

    it('should resolve undefined when store undefined', async () => {
      const cache = await oaJira.cache.init();
      await expect(cache.types.set(1)).resolves.toBeNull();
      expect(cache.types.has(1)).toBeTruthy();
      cache.reset();
      expect(cache.types.has(1)).toBeFalsy();
    });
  });

  describe('Check [versions] services', () => {
    it('should reject error when id is missing.', async () => {
      const cache = await oaJira.cache.init();
      expect(cache.versions.set()).rejects.toThrow('A [id] is mandatory and cannot be falsy.');
    });

    it('should reject error when try to store an invalid category', async () => {
      const cache = await oaJira.cache.init();
      expect(cache.versions.set(1, 1)).rejects.toThrow('A [resource] MUST implements [versions].');
      expect(cache.versions.has(1)).toBeFalsy();
    });

    it('should resolve undefined when store undefined', async () => {
      const cache = await oaJira.cache.init();
      await expect(cache.versions.set(1)).resolves.toBeNull();
      expect(cache.versions.has(1)).toBeTruthy();
      cache.reset();
      expect(cache.versions.has(1)).toBeFalsy();
    });
  });
});