snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

apps/meteor/tests/unit/server/settings/functions/compareSettingsMetadata.tests.ts

@@ -0,0 +1,28 @@
+import { expect } from 'chai';
+
+import { compareSettings } from '../../../../../server/settings/SettingsRegistry';
+import { getSettingDefaults } from '../../../../../server/settings/functions/getSettingDefaults';
+
+const testSetting = getSettingDefaults({
+	_id: 'my_dummy_setting',
+	type: 'string',
+	value: 'dummy',
+});
+
+describe('#compareSettings', () => {
+	const ignoredKeys = ['value', 'ts', 'createdAt', 'valueSource', 'packageValue', 'processEnvValue', '_updatedAt'];
+
+	ignoredKeys.forEach((key) =>
+		it(`should return true if ${key} changes`, () => {
+			const copiedSetting: any = { ...testSetting };
+
+			if (['ts', 'createdAt', '_updatedAt'].includes(key)) {
+				copiedSetting[key] = new Date();
+			} else {
+				copiedSetting[key] = 'random';
+			}
+
+			expect(compareSettings(testSetting, copiedSetting)).to.be.true;
+		}),
+	);
+});

apps/meteor/tests/unit/server/settings/functions/getSettingDefaults.tests.ts

@@ -0,0 +1,110 @@
+import { expect } from 'chai';
+
+import { getSettingDefaults } from '../../../../../server/settings/functions/getSettingDefaults';
+
+describe('getSettingDefaults', () => {
+	it('should return based on _id type value', () => {
+		const setting = getSettingDefaults({ _id: 'test', value: 'test', type: 'string' });
+
+		expect(setting).to.be.an('object');
+		expect(setting).to.have.property('_id');
+
+		expect(setting).to.have.property('i18nDescription').to.be.equal('test_Description');
+
+		expect(setting).to.have.property('value').to.be.equal('test');
+		expect(setting).to.have.property('packageValue').to.be.equal('test');
+
+		expect(setting).to.have.property('type').to.be.equal('string');
+
+		expect(setting).to.have.property('blocked').to.be.equal(false);
+
+		expect(setting).to.not.have.property('multiline');
+		expect(setting).to.not.have.property('values');
+
+		expect(setting).to.not.have.property('group');
+		expect(setting).to.not.have.property('section');
+		expect(setting).to.not.have.property('tab');
+	});
+
+	it('should return a sorter value', () => {
+		const setting = getSettingDefaults({ _id: 'test', value: 'test', type: 'string', sorter: 1 });
+
+		expect(setting).to.be.an('object');
+		expect(setting).to.have.property('_id');
+
+		expect(setting).to.have.property('sorter').to.be.equal(1);
+	});
+
+	it('should return a private setting', () => {
+		const setting = getSettingDefaults({
+			_id: 'test',
+			value: 'test',
+			type: 'string',
+			public: false,
+		});
+
+		expect(setting).to.be.an('object');
+		expect(setting).to.have.property('_id');
+
+		expect(setting).to.have.property('public').to.be.equal(false);
+	});
+
+	it('should return a public setting', () => {
+		const setting = getSettingDefaults({
+			_id: 'test',
+			value: 'test',
+			type: 'string',
+			public: true,
+		});
+
+		expect(setting).to.be.an('object');
+		expect(setting).to.have.property('_id');
+
+		expect(setting).to.have.property('public').to.be.equal(true);
+	});
+
+	it('should return a blocked setting', () => {
+		const setting = getSettingDefaults({
+			_id: 'test',
+			value: 'test',
+			type: 'string',
+			blocked: true,
+		});
+
+		expect(setting).to.be.an('object');
+		expect(setting).to.have.property('_id');
+
+		expect(setting).to.have.property('blocked').to.be.equal(true);
+	});
+
+	it('should return a blocked setting set by env', () => {
+		const setting = getSettingDefaults({ _id: 'test', value: 'test', type: 'string' }, new Set(['test']));
+
+		expect(setting).to.be.an('object');
+		expect(setting).to.have.property('_id');
+
+		expect(setting).to.have.property('blocked').to.be.equal(true);
+	});
+
+	it('should return a package value', () => {
+		const setting = getSettingDefaults({ _id: 'test', value: true, type: 'string' }, new Set(['test']));
+
+		expect(setting).to.be.an('object');
+		expect(setting).to.have.property('_id');
+
+		expect(setting).to.have.property('blocked').to.be.equal(true);
+	});
+
+	it('should not return undefined options', () => {
+		const setting = getSettingDefaults(
+			{ _id: 'test', value: true, type: 'string', section: undefined, group: undefined },
+			new Set(['test']),
+		);
+
+		expect(setting).to.be.an('object');
+		expect(setting).to.have.property('_id');
+
+		expect(setting).to.not.have.property('section');
+		expect(setting).to.not.have.property('group');
+	});
+});

apps/meteor/tests/unit/server/settings/functions/overrideGenerator.tests.ts

@@ -0,0 +1,46 @@
+import { expect } from 'chai';
+
+import { getSettingDefaults } from '../../../../../server/settings/functions/getSettingDefaults';
+import { overrideGenerator } from '../../../../../server/settings/functions/overrideGenerator';
+
+describe('overrideGenerator', () => {
+	it('should return a new object with the new value', () => {
+		const overwrite = overrideGenerator(() => 'value');
+
+		const setting = getSettingDefaults({ _id: 'test', value: 'test', type: 'string' });
+		const overwritten = overwrite(setting);
+
+		expect(overwritten).to.be.an('object');
+		expect(overwritten).to.have.property('_id');
+
+		expect(setting).to.be.not.equal(overwritten);
+
+		expect(overwritten).to.have.property('value').that.equals('value');
+		expect(overwritten).to.have.property('valueSource').that.equals('processEnvValue');
+	});
+
+	it('should stamp the env source even when the value didnt change', () => {
+		const overwrite = overrideGenerator(() => 'test');
+
+		const setting = getSettingDefaults({ _id: 'test', value: 'test', type: 'string' });
+		const overwritten = overwrite(setting);
+
+		expect(setting).to.be.not.equal(overwritten);
+		expect(overwritten).to.have.property('value').that.equals('test');
+		expect(overwritten).to.have.property('valueSource').that.equals('processEnvValue');
+		expect(overwritten).to.have.property('processEnvValue').that.equals('test');
+	});
+
+	it('should return the same object when the value and the env stamp are already in place', () => {
+		const overwrite = overrideGenerator(() => 'test');
+
+		const setting = {
+			...getSettingDefaults({ _id: 'test', value: 'test', type: 'string' }),
+			valueSource: 'processEnvValue' as const,
+			processEnvValue: 'test',
+		};
+		const overwritten = overwrite(setting);
+
+		expect(setting).to.be.equal(overwritten);
+	});
+});

apps/meteor/tests/unit/server/settings/functions/settings.tests.ts

@@ -0,0 +1,721 @@
+import { expect, spy } from 'chai';
+import { beforeEach, describe, it } from 'mocha';
+
+import { CachedSettings } from '../../../../../server/settings/CachedSettings';
+import { SettingsRegistry } from '../../../../../server/settings/SettingsRegistry';
+import { getSettingDefaults } from '../../../../../server/settings/functions/getSettingDefaults';
+import { getSettingSchemaValidator, registerSettingSchema } from '../../../../../server/settings/functions/settingSchemas';
+import { Settings } from '../../../../../server/settings/functions/settings.mocks';
+
+const testSetting = getSettingDefaults({
+	_id: 'my_dummy_setting',
+	type: 'string',
+	value: 'dummy',
+});
+
+describe('Settings', () => {
+	beforeEach(() => {
+		Settings.insertCalls = 0;
+		Settings.upsertCalls = 0;
+		process.env = {};
+		Settings.setDelay(0);
+	});
+
+	it('should not insert the same setting twice', async () => {
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+		settings.initialized();
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+		await settingsRegistry.addGroup('group', async function () {
+			await this.section('section', async function () {
+				await this.add('my_setting', true, {
+					type: 'boolean',
+					sorter: 0,
+				});
+			});
+		});
+
+		expect(Settings.upsertCalls).to.be.equal(0);
+		expect(Settings.insertCalls).to.be.equal(2);
+
+		expect(Settings.findOne({ _id: 'my_setting' })).to.be.include({
+			type: 'boolean',
+			sorter: 0,
+			group: 'group',
+			section: 'section',
+			packageValue: true,
+			value: true,
+			valueSource: 'packageValue',
+			hidden: false,
+			blocked: false,
+			secret: false,
+			i18nLabel: 'my_setting',
+			i18nDescription: 'my_setting_Description',
+			autocomplete: true,
+		});
+
+		await settingsRegistry.addGroup('group', async function () {
+			await this.section('section', async function () {
+				await this.add('my_setting', true, {
+					type: 'boolean',
+					sorter: 0,
+				});
+			});
+		});
+
+		expect(Settings.upsertCalls).to.be.equal(0);
+		expect(Settings.insertCalls).to.be.equal(2);
+
+		expect(Settings.findOne({ _id: 'my_setting' }).value).to.be.equal(true);
+
+		await settingsRegistry.addGroup('group', async function () {
+			await this.section('section', async function () {
+				await this.add('my_setting2', false, {
+					type: 'boolean',
+					sorter: 0,
+				});
+			});
+		});
+
+		expect(Settings.upsertCalls).to.be.equal(0);
+		expect(Settings.insertCalls).to.be.equal(3);
+
+		expect(Settings.findOne({ _id: 'my_setting' }).value).to.be.equal(true);
+		expect(Settings.findOne({ _id: 'my_setting2' }).value).to.be.equal(false);
+	});
+
+	it('should keep the schema option in memory instead of persisting it', async () => {
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+		settings.initialized();
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+
+		await settingsRegistry.addGroup('group', async function () {
+			await this.add('my_json_setting', ' ', {
+				type: 'code',
+				code: 'application/json',
+				schema: { type: 'object' },
+			});
+		});
+
+		expect(Settings.findOne({ _id: 'my_json_setting' })).to.not.have.property('schema');
+		expect(getSettingSchemaValidator('my_json_setting')).to.be.a('function');
+	});
+
+	it('should throw at registration when the schema does not compile', () => {
+		expect(() => registerSettingSchema('my_broken_setting', { type: 'not-a-type' })).to.throw();
+	});
+
+	it('should respect override via environment as int', async () => {
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+		settings.initialized();
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+
+		process.env.OVERWRITE_SETTING_my_setting = '1';
+
+		await settingsRegistry.addGroup('group', async function () {
+			await this.section('section', async function () {
+				await this.add('my_setting', 0, {
+					type: 'int',
+					sorter: 0,
+				});
+			});
+		});
+
+		const expectedSetting = {
+			value: 1,
+			processEnvValue: 1,
+			valueSource: 'processEnvValue',
+			type: 'int',
+			sorter: 0,
+			group: 'group',
+			section: 'section',
+			packageValue: 0,
+			hidden: false,
+			blocked: false,
+			secret: false,
+			i18nLabel: 'my_setting',
+			i18nDescription: 'my_setting_Description',
+			autocomplete: true,
+		};
+
+		expect(Settings).to.have.property('insertCalls').to.be.equal(2);
+		expect(Settings).to.have.property('upsertCalls').to.be.equal(0);
+		expect(Settings.findOne({ _id: 'my_setting' })).to.include(expectedSetting);
+
+		process.env.OVERWRITE_SETTING_my_setting = '2';
+
+		await settingsRegistry.addGroup('group', async function () {
+			await this.section('section', async function () {
+				await this.add('my_setting', 0, {
+					type: 'int',
+					sorter: 0,
+				});
+			});
+		});
+
+		expect(Settings).to.have.property('insertCalls').to.be.equal(2);
+		expect(Settings).to.have.property('upsertCalls').to.be.equal(1);
+		expect(Settings.findOne({ _id: 'my_setting' })).to.include({
+			...expectedSetting,
+			value: 2,
+			processEnvValue: 2,
+		});
+	});
+
+	it('should stamp the env source when the override equals the stored value', async () => {
+		const addSetting = (registry: SettingsRegistry) =>
+			registry.addGroup('group', async function () {
+				await this.section('section', async function () {
+					await this.add('my_setting_stamped', 0, {
+						type: 'int',
+						sorter: 0,
+					});
+				});
+			});
+
+		const bootRegistry = () => {
+			const settings = new CachedSettings();
+			Settings.settings = settings;
+			for (const _id of ['group', 'my_setting_stamped']) {
+				const stored = Settings.findOne({ _id });
+				if (stored) {
+					settings.set(stored);
+				}
+			}
+			settings.initialized();
+			return new SettingsRegistry({ store: settings, model: Settings as any });
+		};
+
+		await addSetting(bootRegistry());
+
+		expect(Settings.findOne({ _id: 'my_setting_stamped' })).to.include({ value: 0, valueSource: 'packageValue' });
+
+		process.env.OVERWRITE_SETTING_my_setting_stamped = '0';
+
+		await addSetting(bootRegistry());
+
+		expect(Settings).to.have.property('upsertCalls').to.be.equal(1);
+		expect(Settings.findOne({ _id: 'my_setting_stamped' })).to.include({
+			value: 0,
+			processEnvValue: 0,
+			valueSource: 'processEnvValue',
+		});
+
+		await addSetting(bootRegistry());
+
+		expect(Settings).to.have.property('upsertCalls').to.be.equal(1);
+	});
+
+	it('should respect override via environment as boolean', async () => {
+		process.env.OVERWRITE_SETTING_my_setting_bool = 'true';
+
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+		settings.initialized();
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+		await settingsRegistry.addGroup('group', async function () {
+			await this.section('section', async function () {
+				await this.add('my_setting_bool', false, {
+					type: 'boolean',
+					sorter: 0,
+				});
+			});
+		});
+
+		const expectedSetting = {
+			value: true,
+			processEnvValue: true,
+			valueSource: 'processEnvValue',
+			type: 'boolean',
+			sorter: 0,
+			group: 'group',
+			section: 'section',
+			packageValue: false,
+			hidden: false,
+			blocked: false,
+			secret: false,
+			i18nLabel: 'my_setting_bool',
+			i18nDescription: 'my_setting_bool_Description',
+			autocomplete: true,
+		};
+
+		expect(Settings.insertCalls).to.be.equal(2);
+		expect(Settings.upsertCalls).to.be.equal(0);
+		expect(Settings.findOne({ _id: 'my_setting_bool' })).to.include(expectedSetting);
+
+		process.env.OVERWRITE_SETTING_my_setting_bool = 'false';
+
+		await settingsRegistry.addGroup('group', async function () {
+			await this.section('section', async function () {
+				await this.add('my_setting_bool', true, {
+					type: 'boolean',
+					sorter: 0,
+				});
+			});
+		});
+
+		expect(Settings.insertCalls).to.be.equal(2);
+		expect(Settings.upsertCalls).to.be.equal(1);
+		expect(Settings.findOne({ _id: 'my_setting_bool' })).to.include({
+			value: false,
+			processEnvValue: false,
+			packageValue: true,
+		});
+	});
+
+	it('should respect override via environment as string', async () => {
+		process.env.OVERWRITE_SETTING_my_setting_str = 'hey';
+
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+		settings.initialized();
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+		await settingsRegistry.addGroup('group', async function () {
+			await this.section('section', async function () {
+				await this.add('my_setting_str', '', {
+					type: 'string',
+					sorter: 0,
+				});
+			});
+		});
+
+		const expectedSetting = {
+			value: 'hey',
+			processEnvValue: 'hey',
+			valueSource: 'processEnvValue',
+			type: 'string',
+			sorter: 0,
+			group: 'group',
+			section: 'section',
+			packageValue: '',
+			hidden: false,
+			blocked: false,
+			secret: false,
+			i18nLabel: 'my_setting_str',
+			i18nDescription: 'my_setting_str_Description',
+			autocomplete: true,
+		};
+
+		expect(Settings.insertCalls).to.be.equal(2);
+		expect(Settings.upsertCalls).to.be.equal(0);
+		expect(Settings.findOne({ _id: 'my_setting_str' })).to.include(expectedSetting);
+
+		process.env.OVERWRITE_SETTING_my_setting_str = 'hey ho';
+
+		await settingsRegistry.addGroup('group', async function () {
+			await this.section('section', async function () {
+				await this.add('my_setting_str', 'hey', {
+					type: 'string',
+					sorter: 0,
+				});
+			});
+		});
+
+		expect(Settings.insertCalls).to.be.equal(2);
+		expect(Settings.upsertCalls).to.be.equal(1);
+		expect(Settings.findOne({ _id: 'my_setting_str' })).to.include({
+			...expectedSetting,
+			value: 'hey ho',
+			processEnvValue: 'hey ho',
+			packageValue: 'hey',
+		});
+	});
+
+	it('should work with a setting type multiSelect with a default value', async () => {
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+		settings.initialized();
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+		await settingsRegistry.addGroup('group', async function () {
+			await this.section('section', async function () {
+				await this.add('my_setting_multiselect', ['a'], {
+					type: 'multiSelect',
+					sorter: 0,
+					values: [
+						{ key: 'a', i18nLabel: 'a' },
+						{ key: 'b', i18nLabel: 'b' },
+						{ key: 'c', i18nLabel: 'c' },
+					],
+				});
+			});
+		});
+
+		expect(Settings.insertCalls).to.be.equal(2);
+		expect(Settings.upsertCalls).to.be.equal(0);
+		expect(Settings.findOne({ _id: 'my_setting_multiselect' }).value).to.be.deep.equal(['a']);
+	});
+	it('should respect override via environment as multiSelect', async () => {
+		process.env.OVERWRITE_SETTING_my_setting_multiselect = '["a","b"]';
+
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+		settings.initialized();
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+
+		await settingsRegistry.addGroup('group', async function () {
+			await this.section('section', async function () {
+				await this.add('my_setting_multiselect', ['a'], {
+					type: 'multiSelect',
+					sorter: 0,
+					values: [
+						{ key: 'a', i18nLabel: 'a' },
+						{ key: 'b', i18nLabel: 'b' },
+						{ key: 'c', i18nLabel: 'c' },
+					],
+				});
+			});
+		});
+
+		expect(Settings.insertCalls).to.be.equal(2);
+		expect(Settings.upsertCalls).to.be.equal(0);
+		expect(Settings.findOne({ _id: 'my_setting_multiselect' }).value).to.be.deep.equal(['a', 'b']);
+		expect(Settings.findOne({ _id: 'my_setting_multiselect' }).processEnvValue).to.be.deep.equal(['a', 'b']);
+		expect(Settings.findOne({ _id: 'my_setting_multiselect' }).valueSource).to.be.equal('processEnvValue');
+	});
+
+	it('should ignore override via environment as multiSelect if value is invalid', async () => {
+		process.env.OVERWRITE_SETTING_my_setting_multiselect = '[INVALID_ARRAY]';
+
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+		settings.initialized();
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+
+		await settingsRegistry.addGroup('group', async function () {
+			await this.section('section', async function () {
+				await this.add('my_setting_multiselect', ['a'], {
+					type: 'multiSelect',
+					sorter: 0,
+					values: [
+						{ key: 'a', i18nLabel: 'a' },
+						{ key: 'b', i18nLabel: 'b' },
+						{ key: 'c', i18nLabel: 'c' },
+					],
+				});
+			});
+		});
+
+		expect(Settings.insertCalls).to.be.equal(2);
+		expect(Settings.upsertCalls).to.be.equal(0);
+		expect(Settings.findOne({ _id: 'my_setting_multiselect' }).value).to.be.deep.equal(['a']);
+		expect(Settings.findOne({ _id: 'my_setting_multiselect' }).processEnvValue).to.be.equal(undefined);
+		expect(Settings.findOne({ _id: 'my_setting_multiselect' }).valueSource).to.be.equal('packageValue');
+	});
+
+	it('should respect initial value via environment', async () => {
+		process.env.my_setting = '1';
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+		settings.initialized();
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+
+		await settingsRegistry.addGroup('group', async function () {
+			await this.section('section', async function () {
+				await this.add('my_setting', 0, {
+					type: 'int',
+					sorter: 0,
+				});
+			});
+		});
+
+		const expectedSetting = {
+			value: 1,
+			processEnvValue: 1,
+			valueSource: 'processEnvValue',
+			type: 'int',
+			sorter: 0,
+			group: 'group',
+			section: 'section',
+			packageValue: 0,
+			hidden: false,
+			blocked: false,
+			secret: false,
+			i18nLabel: 'my_setting',
+			i18nDescription: 'my_setting_Description',
+			autocomplete: true,
+		};
+
+		expect(Settings.insertCalls).to.be.equal(2);
+		expect(Settings.upsertCalls).to.be.equal(0);
+		expect(Settings.findOne({ _id: 'my_setting' })).to.include(expectedSetting);
+
+		await settingsRegistry.addGroup('group', async function () {
+			await this.section('section', async function () {
+				await this.add('my_setting', 0, {
+					type: 'int',
+					sorter: 0,
+				});
+			});
+		});
+
+		expect(Settings.insertCalls).to.be.equal(2);
+		expect(Settings.upsertCalls).to.be.equal(0);
+		expect(Settings.findOne({ _id: 'my_setting' })).to.include({ ...expectedSetting });
+	});
+
+	it('should respect override via environment when changing settings props', async () => {
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+		settings.initialized();
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+
+		await settingsRegistry.addGroup('group', async function () {
+			await this.section('section', async function () {
+				await this.add('my_setting', 0, {
+					type: 'int',
+					sorter: 0,
+				});
+			});
+		});
+
+		const expectedSetting = {
+			value: 0,
+			type: 'int',
+			sorter: 0,
+			group: 'group',
+			section: 'section',
+			packageValue: 0,
+			hidden: false,
+			blocked: false,
+			secret: false,
+			i18nLabel: 'my_setting',
+			i18nDescription: 'my_setting_Description',
+			autocomplete: true,
+		};
+
+		expect(Settings.insertCalls).to.be.equal(2);
+		expect(Settings.upsertCalls).to.be.equal(0);
+		expect(Settings.findOne({ _id: 'my_setting' })).to.include(expectedSetting);
+
+		process.env.OVERWRITE_SETTING_my_setting = '1';
+		await settingsRegistry.addGroup('group', async function () {
+			// removed section
+			await this.add('my_setting', 0, {
+				type: 'int',
+				sorter: 0,
+			});
+		});
+
+		expect(Settings.insertCalls).to.be.equal(2);
+		expect(Settings.upsertCalls).to.be.equal(1);
+
+		const { section: _section, ...removedSection } = expectedSetting;
+
+		const settingWithoutSection = {
+			...removedSection,
+			value: 1,
+			processEnvValue: 1,
+			valueSource: 'processEnvValue',
+		};
+
+		expect(Settings.findOne({ _id: 'my_setting' }))
+			.to.include({ ...settingWithoutSection })
+			.to.not.have.any.keys('section');
+	});
+
+	it('should ignore setting object from code if only value changes in code and setting already stored', async () => {
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+		settings.initialized();
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+
+		await settingsRegistry.add(testSetting._id, testSetting.value, testSetting);
+
+		expect(Settings.insertCalls).to.be.equal(1);
+		Settings.insertCalls = 0;
+
+		const settingFromCodeFaked = { ...testSetting, value: Date.now().toString() };
+
+		await settingsRegistry.add(settingFromCodeFaked._id, settingFromCodeFaked.value, settingFromCodeFaked);
+
+		expect(Settings.insertCalls).to.be.equal(0);
+		expect(Settings.upsertCalls).to.be.equal(0);
+	});
+
+	it('should not update (reset) cached setting with value in code if some prop in code changes (including value)', async () => {
+		Settings.setDelay(1000);
+		const settings = new CachedSettings();
+		process.env[`OVERWRITE_SETTING_${testSetting._id}`] = 'false';
+		const storedSetting = { ...testSetting, value: true, packageValue: true };
+		settings.set(storedSetting);
+
+		Settings.settings = settings;
+
+		settings.initialized();
+
+		expect(settings.get(storedSetting._id)).to.be.equal(true);
+
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+
+		const settingFromCodeFaked = {
+			...storedSetting,
+			value: true,
+			enterprise: true,
+			invalidValue: '',
+		};
+
+		await settingsRegistry.add(settingFromCodeFaked._id, settingFromCodeFaked.value, settingFromCodeFaked);
+
+		expect(Settings.insertCalls).to.be.equal(0);
+		expect(Settings.upsertCalls).to.be.equal(1);
+
+		expect(settings.get(storedSetting._id)).to.be.equal(false);
+	});
+
+	it('should update cached setting with value from environment if some prop including value in code changes', async () => {
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+		settings.initialized();
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+
+		await settingsRegistry.add(testSetting._id, testSetting.value, testSetting);
+
+		expect(Settings.insertCalls).to.be.equal(1);
+		Settings.insertCalls = 0;
+
+		const settingFromCodeFaked = { ...testSetting, value: Date.now().toString(), enterprise: true, invalidValue: '' };
+
+		process.env[`OVERWRITE_SETTING_${testSetting._id}`] = Date.now().toString();
+
+		await settingsRegistry.add(settingFromCodeFaked._id, settingFromCodeFaked.value, settingFromCodeFaked);
+
+		expect(Settings.insertCalls).to.be.equal(0);
+		expect(Settings.upsertCalls).to.be.equal(1);
+
+		expect(settings.get(testSetting._id)).to.be.equal(process.env[`OVERWRITE_SETTING_${testSetting._id}`]);
+	});
+
+	it('should ignore default value from environment if setting is already stored', async () => {
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+		settings.initialized();
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+
+		await settingsRegistry.add(testSetting._id, testSetting.value, testSetting);
+
+		process.env[testSetting._id] = Date.now().toString();
+
+		await settingsRegistry.add(testSetting._id, testSetting.value, testSetting);
+
+		expect(Settings.findOne({ _id: testSetting._id }).value).to.be.equal(testSetting.value);
+	});
+
+	it('should update setting cache synchronously if overwrite is available in environment', async () => {
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+		settings.initialized();
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+
+		settings.set(testSetting);
+
+		process.env[`OVERWRITE_SETTING_${testSetting._id}`] = Date.now().toString();
+
+		await settingsRegistry.add(testSetting._id, testSetting.value, testSetting);
+
+		expect(settings.get(testSetting._id)).to.be.equal(process.env[`OVERWRITE_SETTING_${testSetting._id}`]);
+	});
+
+	it('should update cached value with OVERWRITE_SETTING value even if both overwrite and default overwrite variables both exist', async () => {
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+		settings.initialized();
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+
+		process.env[`OVERWRITE_SETTING_${testSetting._id}`] = Date.now().toString();
+		process.env[testSetting._id] = Date.now().toString();
+
+		await settingsRegistry.add(testSetting._id, testSetting.value, testSetting);
+
+		expect(Settings.insertCalls).to.be.equal(1);
+		expect(settings.get(testSetting._id)).to.be.equal(process.env[`OVERWRITE_SETTING_${testSetting._id}`]);
+	});
+
+	it('should call `settings.get` callback on setting added', async () => {
+		return new Promise(async (resolve) => {
+			const settings = new CachedSettings();
+			Settings.settings = settings;
+			settings.initialized();
+			const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+
+			const spiedCallback1 = spy();
+			const spiedCallback2 = spy();
+
+			await settingsRegistry.addGroup('group', async function () {
+				await this.section('section', async function () {
+					await this.add('setting_callback', 'value1', {
+						type: 'string',
+					});
+				});
+			});
+
+			settings.watch('setting_callback', spiedCallback1, { debounce: 10 });
+			settings.watchByRegex(/setting_callback/, spiedCallback2, { debounce: 10 });
+
+			setTimeout(
+				() => {
+					expect(spiedCallback1).to.have.been.called.exactly(1);
+					expect(spiedCallback2).to.have.been.called.exactly(1);
+					expect(spiedCallback1).to.have.been.called.always.with('value1');
+					expect(spiedCallback2).to.have.been.called.always.with('setting_callback', 'value1');
+					resolve();
+				},
+				settings.getConfig({ debounce: 10 }).debounce,
+			);
+		});
+	});
+
+	it('should call `settings.watch` callback on setting changed registering before initialized', async () => {
+		return new Promise(async (resolve) => {
+			const spiedCallback1 = spy();
+			const spiedCallback2 = spy();
+			const settings = new CachedSettings();
+			Settings.settings = settings;
+			const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+
+			settings.watch('setting_callback', spiedCallback1, { debounce: 1 });
+			settings.watchByRegex(/setting_callback/gi, spiedCallback2, { debounce: 1 });
+
+			settings.initialized();
+			await settingsRegistry.addGroup('group', async function () {
+				await this.section('section', async function () {
+					await this.add('setting_callback', 'value2', {
+						type: 'string',
+					});
+				});
+			});
+			setTimeout(
+				() => {
+					Settings.updateValueById('setting_callback', 'value3');
+					setTimeout(
+						() => {
+							expect(spiedCallback1).to.have.been.called.exactly(2);
+							expect(spiedCallback2).to.have.been.called.exactly(2);
+							expect(spiedCallback1).to.have.been.called.with('value2');
+							expect(spiedCallback1).to.have.been.called.with('value3');
+							resolve();
+						},
+						settings.getConfig({ debounce: 10 }).debounce,
+					);
+				},
+				settings.getConfig({ debounce: 10 }).debounce,
+			);
+		});
+	});
+
+	it('should update the stored value on setting change', async () => {
+		Settings.setDelay(10);
+		process.env[`OVERWRITE_SETTING_${testSetting._id}`] = 'false';
+		const settings = new CachedSettings();
+		Settings.settings = settings;
+
+		settings.set(testSetting);
+		settings.initialized();
+
+		const settingsRegistry = new SettingsRegistry({ store: settings, model: Settings as any });
+		await settingsRegistry.add(testSetting._id, testSetting.value, testSetting);
+
+		expect(settings.get(testSetting._id)).to.be.equal(false);
+	});
+});

apps/meteor/tests/unit/server/settings/functions/validateSettings.tests.ts

@@ -0,0 +1,36 @@
+import { expect } from 'chai';
+
+import { validateSetting } from '../../../../../server/settings/functions/validateSetting';
+
+describe('validateSettings', () => {
+	it('should validate the type string', () => {
+		expect(() => validateSetting('test', 'string', 'value')).to.not.throw();
+	});
+	it('should throw an error expecting string receiving int', () => {
+		expect(() => validateSetting('test', 'string', 10)).to.throw();
+	});
+	it('should validate the type int', () => {
+		expect(() => validateSetting('test', 'int', 10)).to.not.throw();
+	});
+	it('should throw an error expecting int receiving string', () => {
+		expect(() => validateSetting('test', 'int', '10')).to.throw();
+	});
+	it('should validate the type boolean', () => {
+		expect(() => validateSetting('test', 'boolean', true)).to.not.throw();
+	});
+	it('should throw an error expecting boolean receiving string', () => {
+		expect(() => validateSetting('test', 'boolean', 'true')).to.throw();
+	});
+	it('should validate the type date', () => {
+		expect(() => validateSetting('test', 'date', new Date())).to.not.throw();
+	});
+	it('should throw an error expecting date receiving string', () => {
+		expect(() => validateSetting('test', 'date', '2019-01-01')).to.throw();
+	});
+	it('should validate the type multiSelect', () => {
+		expect(() => validateSetting('test', 'multiSelect', [])).to.not.throw();
+	});
+	it('should throw an error expecting multiSelect receiving string', () => {
+		expect(() => validateSetting('test', 'multiSelect', '[]')).to.throw();
+	});
+});