@interaktiv/mibuilder-core/dist/config/config-group.test.js

Core libraries to interact with MiBuilder projects.

"use strict";

var _types = require("@interaktiv/types");

var _mibuilderError = require("../mibuilder-error");

var _testSetup2 = require("../test-setup");

var _configGroup = require("./config-group");

// Setup the test environment.
const _testSetup = (0, _testSetup2.testSetup)();

describe('ConfigGroup should retrieve calls read', () => {
  beforeEach(() => {
    _testSetup.setConfigMockContents('ConfigGroup', {
      contents: {
        orgs: {
          foo: 'foo@example.com'
        }
      }
    });
  });
  it('if file already exists', async () => {
    const options = _configGroup.ConfigGroup.getOptions('orgs', 'test_keyvalue.json');

    const store = await _configGroup.ConfigGroup.create(options);
    expect(store.getInGroup('foo', 'orgs')).toBe('foo@example.com');
  });
}); // eslint-disable-next-line max-lines-per-function

describe('ConfigGroup', () => {
  let store;
  beforeEach(async () => {
    store = await _configGroup.ConfigGroup.create(_configGroup.ConfigGroup.getOptions('default', 'testfetchConfigInfos.json'));
  });
  it('should set key value pair', () => {
    store.set('test', 'val');
    expect(store.get('test')).toBe('val');
    expect(store.getInGroup('test')).toBe('val');
    expect((0, _types.ensureJsonMap)(store.getGroup('default')).test).toBe('val');
  });
  it('should setDefaultGroup to false value for undefined groupname', () => {
    expect.assertions(2);

    try {
      store.setDefaultGroup(undefined);
    } catch (err) {
      // eslint-disable-next-line jest/no-try-expect, jest/no-conditional-expect
      expect(err.name).toBe('MissingGroupName'); // eslint-disable-next-line jest/no-try-expect, jest/no-conditional-expect

      expect(err).toEqual(expect.any(_mibuilderError.MiBuilderError));
    }
  });
  it('should set key value pair if is not accessible in another group', () => {
    store.setInGroup('test', 'val', 'worldly');
    expect(store.get('test')).toBeUndefined();
    expect(store.getInGroup('test', 'worldly')).toBe('val');
    expect((0, _types.ensureJsonMap)(store.getGroup('worldly')).test).toBe('val');
  });
  it('should set key value pair using default group', () => {
    store.set('test', 'val');
    store.setDefaultGroup('worldly');
    store.set('test', 'val2');
    expect(store.get('test')).toBe('val2');
    expect(store.getInGroup('test')).toBe('val2');
    expect(store.getInGroup('test', 'default')).toBe('val');
    expect(store.getInGroup('test', 'worldly')).toBe('val2');
    expect((0, _types.ensureJsonMap)(store.getGroup('worldly')).test).toBe('val2');
  });
  it('should unset key', () => {
    store.set('test', 'val');
    store.unset('test');
    expect(store.get('test')).toBeUndefined();
  });
  it('should unset single key', () => {
    store.set('test1', 'val1');
    store.set('test2', 'val2');
    store.unset('test1');
    expect(store.get('test1')).toBeUndefined();
    expect(store.get('test2')).toBe('val2');
  });
  it('should unset key in different group', () => {
    store.setInGroup('test', 'val', 'worldly');
    store.unset('test');
    expect(store.get('test')).toBeUndefined();
    expect(store.getInGroup('test', 'worldly')).toBe('val');
  });
  it('should unset all key', () => {
    store.set('test1', 'val1');
    store.set('test2', 'val2');
    store.set('test3', 'val3');
    store.unsetAll(['test1', 'test3']);
    expect(store.get('test1')).toBeUndefined();
    expect(store.get('test2')).toBe('val2');
    expect(store.get('test3')).toBeUndefined();
  });
  it('should set contents from object', () => {
    store.setContentsFromObject({
      default: {
        test1: 'val1',
        test2: 'val2'
      }
    });
    expect(store.get('test1')).toBe('val1');
    expect(store.get('test2')).toBe('val2');
  });
  it('should successfully run to object', () => {
    store.set('test1', 'val1');
    store.set('test2', 'val2');
    expect(store.toObject()).toEqual(expect.objectContaining({
      default: {
        test1: 'val1',
        test2: 'val2'
      }
    }));
  });
  it('should return a list of values under a group', () => {
    store.setContentsFromObject({
      default: {
        test1: 'val1',
        test2: 'val2',
        test3: 'val3'
      }
    });
    expect(store.keys()).toEqual(expect.arrayContaining(['test1', 'test2', 'test3']));
    expect(store.values()).toEqual(expect.arrayContaining(['val1', 'val2', 'val3']));
    expect(store.entries()).toEqual(expect.arrayContaining([['test1', 'val1'], ['test2', 'val2'], ['test3', 'val3']]));
  });
  describe('write', () => {
    it('should set key value pair', async () => {
      store.set('test', 'val');
      await store.write();

      const contents = _testSetup.getConfigMockContents('ConfigGroup', 'default');

      expect(contents.test).toBe('val');
    });
    describe('updateValues', () => {
      it('should update one value', async () => {
        await store.updateValues({
          another: 'val'
        }); // Once on initialization with default values
        // Once on updateValue call

        expect(_configGroup.ConfigGroup.prototype.write).toBeCalledTimes(2);

        const contents = _testSetup.getConfigMockContents('ConfigGroup', 'default');

        expect(contents.another).toEqual('val');
      });
      it('should update two of same value', async () => {
        await store.updateValues({
          another: 'val',
          some: 'val'
        }); // Once on initialization with default values
        // Once on updateValue call

        expect(_configGroup.ConfigGroup.prototype.write).toBeCalledTimes(2);

        const contents = _testSetup.getConfigMockContents('ConfigGroup', 'default');

        expect(contents.another).toEqual('val');
        expect(contents.some).toEqual('val');
      });
    });
  });
});