/* eslint-env mocha */
/* eslint-disable func-names, prefer-arrow-callback */
/* eslint-disable import/no-absolute-path */

import { expect } from 'chai';
import SiteSettings from '/imports/api/SiteSettings/SiteSettings';
import SiteSettingsTypes from '/imports/api/SiteSettings/SiteSettingsTypes';

const setting = {
  name: 'site-test',
  value: 'Some value',
  description: 'Some description',
  isPublic: true,
  type: 'string'
};

describe('site settings store', () => {
  before(async () => {
    await SiteSettings.createIndexAsync({ name: 1 }, { unique: true });
    await SiteSettings.removeAsync({ name: setting.name });
  });

  it('should get settingstypes', () => {
    expect(SiteSettingsTypes.string.value.type).to.equal(String);
  });

  it('should insert settings', async () => {
    const id = await SiteSettings.insertAsync(setting);
    SiteSettings.getSchema(setting.type).validate(setting);

    const inserted = await SiteSettings.findOneAsync(id);
    delete inserted._id;
    expect(inserted).to.deep.equal(setting);

    await SiteSettings.removeAsync(id);
    expect(await SiteSettings.find({ _id: id }).countAsync()).to.equal(0);
  });

  it('should not be inserted twice', async () => {
    const id = await SiteSettings.insertAsync(setting);
    // The unique index on `name` must reject the duplicate.
    let threw = false;
    try {
      await SiteSettings.insertAsync(setting);
    } catch (e) {
      threw = true;
    }
    expect(threw).to.equal(true);
    expect(await SiteSettings.find(id).countAsync()).to.equal(1);
    await SiteSettings.removeAsync(id);
  });

  it('should fail validation', () => {
    expect(() => {
      SiteSettings.getSchema('boolean').validate(setting);
    }).to.throw('Value must be of type Boolean');
  });
});