@rosen-bridge/config 0.3.0 → 1.0.0

package/tests/config.spec.ts

@@ -1,955 +0,0 @@
-import { configDir } from './configEnvSetup';
-import config from 'config';
-import fs from 'fs';
-import path from 'path';
-import { afterAll, beforeEach, describe, expect, it } from 'vitest';
-import { ConfigValidator } from '../lib';
-import { ConfigSchema } from '../lib/schema/types/fields';
-import * as testData from './configTestData';
-
-afterAll(() => {
-  fs.rmSync(configDir, { force: true, recursive: true });
-});
-
-beforeEach(() => {
-  fs.readdirSync(configDir).forEach((file) => {
-    fs.unlinkSync(path.join(configDir, file));
-  });
-  fs.cpSync(path.join(__dirname, 'configTestFiles'), configDir, {
-    recursive: true,
-  });
-});
-
-describe('ConfigValidator', () => {
-  describe('generateDefault', () => {
-    /**
-     * @target generateDefault should return default values object for the
-     * passed schema
-     * @dependencies
-     * @scenario
-     * - call generateDefault
-     * - check if correct default value object is returned
-     * @expected
-     * - correct default value object should have been returned
-     */
-    it(`should return default values object for the passed schema`, async () => {
-      const config = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaDefaultValuePairSample.schema
-      );
-      expect(config.generateDefault()).toEqual(
-        testData.apiSchemaDefaultValuePairSample.defaultVal
-      );
-    });
-  });
-
-  describe('validateSchema', () => {
-    /**
-     * @target validateSchema should not throw any exceptions when a correct
-     * schema is passed
-     * @dependencies
-     * @scenario
-     * - create a new instance of Config which calls Config.validateSchema
-     * - check if any exception is thrown
-     * @expected
-     * - no errors should be thrown
-     */
-    it(`should not throw any exceptions when a correct schema is passed`, async () => {
-      new ConfigValidator(<ConfigSchema>testData.correctApiSchema);
-    });
-
-    /**
-     * @target validateSchema should throw exception when a schema with
-     * incorrect default value type is passed
-     * @dependencies
-     * @scenario
-     * - create a new instance of Config which calls Config.validateSchema
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when a schema with incorrect default value type
-    is passed`, async () => {
-      expect(
-        () =>
-          new ConfigValidator(
-            <ConfigSchema>testData.schemaWithIncorrectPortDefaultValueTypeSample
-          )
-      ).toThrow();
-    });
-
-    /**
-     * @target validateSchema should throw exception when array type doesn't
-     * have an item property
-     * @dependencies
-     * @scenario
-     * - create a new instance of Config which calls Config.validateSchema
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when array type doesn't have an item property`, async () => {
-      expect(
-        () =>
-          new ConfigValidator(
-            <ConfigSchema>testData.arrayTypeSchemaWithoutItems
-          )
-      ).toThrow();
-    });
-
-    /**
-     * @target validateSchema should throw exception when object type doesn't
-     * have a children property
-     * @dependencies
-     * @scenario
-     * - create a new instance of Config which calls Config.validateSchema
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when object type doesn't have a children property`, async () => {
-      expect(
-        () =>
-          new ConfigValidator(
-            <ConfigSchema>testData.objectTypeSchemaWithoutChildren
-          )
-      ).toThrow();
-    });
-  });
-
-  describe('validateConfig', () => {
-    /**
-     * @target validateConfig should not throw any exceptions when a correct
-     * config is passed
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - no errors should be thrown
-     */
-    it(`should not throw any exceptions when a correct config is passed`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPair.schema
-      );
-      confValidator.validateConfig(testData.apiSchemaConfigPair.config);
-    });
-
-    /**
-     * @target validateConfig should throw exception when a config violating
-     * choices constraint is passed
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when a config violating choices constraint is
-    passed`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongChoice.schema
-      );
-
-      expect(() =>
-        confValidator.validateConfig(
-          testData.apiSchemaConfigPairWrongChoice.config
-        )
-      ).toThrow();
-    });
-
-    /**
-     * @target validateSchema should throw exception when a config violating
-     * regex constraint is passed
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when a config violating regex constraint is
-    passed`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongRegex.schema
-      );
-
-      expect(() =>
-        confValidator.validateConfig(
-          testData.apiSchemaConfigPairWrongRegex.config
-        )
-      ).toThrow();
-    });
-
-    /**
-     * @target validateSchema should throw exception when a config violating the
-     * "required" constraint is passed
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when a config violating the "required" constraint
-    is passed`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongRequired.schema
-      );
-
-      expect(() =>
-        confValidator.validateConfig(
-          testData.apiSchemaConfigPairWrongRequired.config
-        )
-      ).toThrow();
-    });
-
-    /**
-     * @target validateSchema should throw exception when a config violating the
-     * value type is passed
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when a config violating the value type is passed`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongPortType.schema
-      );
-
-      expect(() =>
-        confValidator.validateConfig(
-          testData.apiSchemaConfigPairWrongPortType.config
-        )
-      ).toThrow();
-    });
-
-    /**
-     * @target validateSchema should throw exception when a config violating the
-     * "greater than" constraint, is passed
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when a config violating the "greater than"
-    constraint, is passed`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongGreater.schema
-      );
-
-      expect(() =>
-        confValidator.validateConfig(
-          testData.apiSchemaConfigPairWrongGreater.config
-        )
-      ).toThrow();
-    });
-
-    /**
-     * @target validateSchema should throw exception when a config violating the
-     * "greater than or equal" constraint, is passed
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when a config violating the
-    "greater than or equal" constraint, is passed`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongGreaterEqual.schema
-      );
-
-      expect(() =>
-        confValidator.validateConfig(
-          testData.apiSchemaConfigPairWrongGreaterEqual.config
-        )
-      ).toThrow();
-    });
-
-    /**
-     * @target validateSchema should throw exception when a config violating the
-     * "less than" constraint, is passed
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when a config violating the "less than"
-    constraint, is passed`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongLess.schema
-      );
-
-      expect(() =>
-        confValidator.validateConfig(
-          testData.apiSchemaConfigPairWrongLess.config
-        )
-      ).toThrow();
-    });
-
-    /**
-     * @target validateSchema should throw exception when a config violating the
-     * "less than or equal" constraint, is passed
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when a config violating the "less than or equal"
-    constraint, is passed`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongLessEqual.schema
-      );
-
-      expect(() =>
-        confValidator.validateConfig(
-          testData.apiSchemaConfigPairWrongLessEqual.config
-        )
-      ).toThrow();
-    });
-
-    /**
-     * @target validateSchema should throw exception when a config violating the
-     * "greater than for bigint" constraint, is passed
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when a config violating the
-    "greater than for bigint" constraint, is passed`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongGreaterBigInt.schema
-      );
-
-      expect(() =>
-        confValidator.validateConfig(
-          testData.apiSchemaConfigPairWrongGreaterBigInt.config
-        )
-      ).toThrow();
-    });
-
-    /**
-     * @target validateSchema should throw exception when a config violating the
-     * "greater than or equal for bigint" constraint, is passed
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when a config violating the
-    "greater than or equal for bigint" constraint, is passed`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongGreaterEqualBigInt.schema
-      );
-
-      expect(() =>
-        confValidator.validateConfig(
-          testData.apiSchemaConfigPairWrongGreaterEqualBigInt.config
-        )
-      ).toThrow();
-    });
-
-    /**
-     * @target validateSchema should throw exception when a config violating the
-     * "less than for bigint" constraint, is passed
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when a config violating the
-    "less than for bigint" constraint, is passed`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongLessBigInt.schema
-      );
-
-      expect(() =>
-        confValidator.validateConfig(
-          testData.apiSchemaConfigPairWrongLessBigInt.config
-        )
-      ).toThrow();
-    });
-
-    /**
-     * @target validateSchema should throw exception when a config violating the
-     * "less than or equal for bigint" constraint, is passed
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when a config violating the
-    "less than or equal for bigint" constraint, is passed`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongLessEqualBigInt.schema
-      );
-
-      expect(() =>
-        confValidator.validateConfig(
-          testData.apiSchemaConfigPairWrongLessEqualBigInt.config
-        )
-      ).toThrow();
-    });
-
-    /**
-     * @target validateSchema should not throw exception when config violates
-     * "required" validation but the "when" clause is false
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should not throw exception when config violates "required" validation
-    but the "when" clause is false`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongRequiredFalseWhen.schema
-      );
-
-      confValidator.validateConfig(
-        testData.apiSchemaConfigPairWrongRequiredFalseWhen.config
-      );
-    });
-
-    /**
-     * @target validateSchema should not throw exception when config violates
-     * "regex" validation but the "when" clause is false
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should not throw exception when config violates "regex" validation but
-    the "when" clause is false`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongRegexFalseWhen.schema
-      );
-
-      confValidator.validateConfig(
-        testData.apiSchemaConfigPairWrongRegexFalseWhen.config
-      );
-    });
-
-    /**
-     * @target validateSchema should not throw exception when config violates
-     * "choices" validation but the "when" clause is false
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should not throw exception when config violates "choices" validation but
-    the "when" clause is false`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongChoiceFalseWhen.schema
-      );
-
-      confValidator.validateConfig(
-        testData.apiSchemaConfigPairWrongChoiceFalseWhen.config
-      );
-    });
-
-    /**
-     * @target validateSchema should not throw exception when config violates
-     * "gt" validation but the "when" clause is false
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should not throw exception when config violates "gt" validation but the
-    "when" clause is false`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongGreaterFalseWhen.schema
-      );
-
-      confValidator.validateConfig(
-        testData.apiSchemaConfigPairWrongGreaterFalseWhen.config
-      );
-    });
-
-    /**
-     * @target validateSchema should not throw exception when config violates
-     * "gte" validation but the "when" clause is false
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should not throw exception when config violates "gte" validation but
-     the "when" clause is false`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>(
-          testData.apiSchemaConfigPairWrongGreaterEqualFalseWhen.schema
-        )
-      );
-
-      confValidator.validateConfig(
-        testData.apiSchemaConfigPairWrongGreaterEqualFalseWhen.config
-      );
-    });
-
-    /**
-     * @target validateSchema should not throw exception when config violates
-     * "lt" validation but the "when" clause is false
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should not throw exception when config violates "lt" validation but the
-    "when" clause is false`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongLessFalseWhen.schema
-      );
-
-      confValidator.validateConfig(
-        testData.apiSchemaConfigPairWrongLessFalseWhen.config
-      );
-    });
-
-    /**
-     * @target validateSchema should not throw exception when config violates
-     * "lte" validation but the "when" clause is false
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should not throw exception when config violates "lte" validation but the
-    "when" clause is false`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongLessEqualFalseWhen.schema
-      );
-
-      confValidator.validateConfig(
-        testData.apiSchemaConfigPairWrongLessEqualFalseWhen.config
-      );
-    });
-
-    /**
-     * @target validateSchema should not throw exception when config violates
-     * "bigint gt" validation but the "when" clause is false
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should not throw exception when config violates "bigint gt" validation
-     but the "when" clause is false`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>(
-          testData.apiSchemaConfigPairWrongBigIntGreaterFalseWhen.schema
-        )
-      );
-
-      confValidator.validateConfig(
-        testData.apiSchemaConfigPairWrongBigIntGreaterFalseWhen.config
-      );
-    });
-
-    /**
-     * @target validateSchema should not throw exception when config violates
-     * "bigint gte" validation but the "when" clause is false
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should not throw exception when config violates "bigint gte" validation
-    but the "when" clause is false`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>(
-          testData.apiSchemaConfigPairWrongBigIntGreaterEqualFalseWhen.schema
-        )
-      );
-
-      confValidator.validateConfig(
-        testData.apiSchemaConfigPairWrongBigIntGreaterEqualFalseWhen.config
-      );
-    });
-
-    /**
-     * @target validateSchema should not throw exception when config violates
-     * "bigint lt" validation but the "when" clause is false
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should not throw exception when config violates "bigint lt" validation
-    but the "when" clause is false`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>(
-          testData.apiSchemaConfigPairWrongBigIntLessFalseWhen.schema
-        )
-      );
-
-      confValidator.validateConfig(
-        testData.apiSchemaConfigPairWrongBigIntLessFalseWhen.config
-      );
-    });
-
-    /**
-     * @target validateSchema should not throw exception when config violates
-     * "bigint lte" validation but the "when" clause is false
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should not throw exception when config violates "bigint lte" validation
-    but the "when" clause is false`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>(
-          testData.apiSchemaConfigPairWrongBigIntLessEqualFalseWhen.schema
-        )
-      );
-
-      confValidator.validateConfig(
-        testData.apiSchemaConfigPairWrongBigIntLessEqualFalseWhen.config
-      );
-    });
-
-    /**
-     * @target validateSchema should throw exception using the custom message
-     * when the validation has error property set
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown with the right message
-     * @expected
-     * - exception should be thrown with the right message
-     */
-    it(`should throw exception using the custom message when the validation has
-    error property set`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWrongChoice.schema
-      );
-
-      expect(() =>
-        confValidator.validateConfig(
-          testData.apiSchemaConfigPairWrongChoice.config
-        )
-      ).toThrow(
-        testData.apiSchemaConfigPairWrongChoice.schema.apiType.validations[1]
-          .error
-      );
-    });
-
-    /**
-     * @target validateSchema should not throw exception when "bigint" field is
-     * passed in string format
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should not be thrown
-     */
-    it(`should not throw exception when "bigint" field is passed in string
-    format`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWithStringBigInt.schema
-      );
-
-      confValidator.validateConfig(
-        testData.apiSchemaConfigPairWithStringBigInt.config
-      );
-    });
-
-    /**
-     * @target validateSchema should not throw exception when "number" field is
-     * passed in string format
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should not be thrown
-     */
-    it(`should not throw exception when "number" field is passed in string
-    format`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.apiSchemaConfigPairWithStringNumber.schema
-      );
-
-      confValidator.validateConfig(
-        testData.apiSchemaConfigPairWithStringNumber.config
-      );
-    });
-
-    /**
-     * @target validateConfig should throw exception when value doesn't match
-     * the schema array type
-     * @dependencies
-     * @scenario
-     * - call validateConfig with the config
-     * - check if any exception is thrown
-     * @expected
-     * - exception should be thrown
-     */
-    it(`should throw exception when value doesn't match the schema array type`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.arraySchemaConfigPairWrongValueType.schema
-      );
-
-      expect(() =>
-        confValidator.validateConfig(
-          testData.arraySchemaConfigPairWrongValueType.config
-        )
-      ).toThrow();
-    });
-  });
-
-  describe('valueAt', () => {
-    /**
-     * @target valueAt should return the value at specified path in config
-     * object
-     * @dependencies
-     * @scenario
-     * - call valueAt with the config and path
-     * - check if correct value is returned
-     * @expected
-     * - correct value should be returned
-     */
-    it(`should return the value at specified path in config object`, async () => {
-      const configObject = {
-        apiType: 'explorer',
-        servers: {
-          url: 'node256.mydomain.net',
-        },
-        apis: {
-          explorer: {
-            url: 'example.com',
-            port: 600,
-          },
-        },
-      };
-
-      const value = ConfigValidator.valueAt(configObject, [
-        'apis',
-        'explorer',
-        'url',
-      ]);
-
-      expect(value).toEqual('example.com');
-    });
-
-    /**
-     * @target valueAt should return undefined when invalid path is passed
-     * @dependencies
-     * @scenario
-     * - call valueAt with the config and path
-     * - check if undefined is returned
-     * @expected
-     * - undefined should be returned
-     */
-    it(`should return undefined when invalid path is passed`, async () => {
-      const configObject = {
-        apiType: 'explorer',
-        servers: {
-          url: 'node256.mydomain.net',
-        },
-        apis: {
-          explorer: {
-            url: 'example.com',
-            port: 600,
-          },
-        },
-      };
-
-      const value = ConfigValidator.valueAt(configObject, [
-        'apis',
-        'node',
-        'url',
-      ]);
-
-      expect(value).toEqual(undefined);
-    });
-  });
-
-  describe('generateTSTypes', () => {
-    /**
-     * @target generateTSTypes should return TypeScript interfaces for
-     * this.schema
-     * @dependencies
-     * @scenario
-     * - call generateTSTypes
-     * - check if correct types string is returned
-     * @expected
-     * - correct types string should be returned
-     */
-    it(`should return TypeScript interfaces for this.schema`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.schemaTypeScriptTypesPair.schema
-      );
-      const types = confValidator.generateTSTypes('Infrastructure');
-      expect(types).toEqual(testData.schemaTypeScriptTypesPair.types);
-    });
-  });
-
-  describe('getConfigForLevel', () => {
-    /**
-     * @target getConfigForLevel should return the correct characteristic object
-     * for passed level of node config package
-     * @dependencies
-     * @scenario
-     * - call getConfigForLevel
-     * - check if correct characteristic object is returned
-     * @expected
-     * - correct characteristic object should be returned
-     */
-    it(`should return the correct characteristic object for passed level of node
-    config package`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.schemaConfigCharPair.schema
-      );
-      const configCharacteristic = confValidator.getConfigForLevel(
-        config,
-        'local'
-      );
-
-      expect(configCharacteristic).toEqual(
-        testData.schemaConfigCharPair.characteristic
-      );
-    });
-  });
-
-  describe('validateAndWriteConfig', () => {
-    /**
-     * @target validateAndWriteConfig should validate config when merged with
-     * passed object and write it to the appropriate config file
-     * @dependencies
-     * @scenario
-     * - call validateAndWriteConfig
-     * - check validateAndWriteConfig to throw no exception
-     * - check the config file to be correctly saved
-     * @expected
-     * - validateAndWriteConfig should throw no exception
-     * - the config file should be correctly saved
-     */
-    it(`should validate config when merged with passed object and write it to
-    the appropriate config file`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.schemaConfigCharPair.schema
-      );
-      const obj = { apiType: 'node' };
-      confValidator.validateAndWriteConfig(obj, config, 'default', 'json');
-      const savedObj = JSON.parse(
-        fs.readFileSync(path.join(configDir, 'default.json'), 'utf-8')
-      );
-
-      expect(savedObj).toEqual(obj);
-    });
-
-    /**
-     * @target validateAndWriteConfig should throw exception when config after
-     * being merged with passed object is not valid and preserve the original
-     * config file
-     * @dependencies
-     * @scenario
-     * - call validateAndWriteConfig
-     * - check validateAndWriteConfig to throw exception
-     * - check the config file to be unchanged
-     * @expected
-     * - validateAndWriteConfig should throw exception
-     * - config file should be unchanged
-     */
-    it(`should throw exception when config after being merged with passed object
-    is not valid and preserve the original config file`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.schemaConfigCharPair.schema
-      );
-      const originalObj = JSON.parse(
-        fs.readFileSync(path.join(configDir, 'local.json'), 'utf-8')
-      );
-
-      const obj = { apiType: 'wrong-value' };
-
-      expect(() =>
-        confValidator.validateAndWriteConfig(obj, config, 'local', 'json')
-      ).toThrow();
-
-      const savedObj = JSON.parse(
-        fs.readFileSync(path.join(configDir, 'local.json'), 'utf-8')
-      );
-      expect(savedObj).toEqual(originalObj);
-    });
-
-    /**
-     * @target validateAndWriteConfig should not throw exception when config
-     * after being merged with passed object is valid even if the passed object
-     * itself is not valid
-     * @dependencies
-     * @scenario
-     * - call validateAndWriteConfig
-     * - check validateAndWriteConfig not to throw exception
-     * - check the config file to be correctly saved
-     * @expected
-     * - validateAndWriteConfig should throw exception
-     * - config file should be correctly saved
-     */
-    it(`should throw exception when config after being merged with passed object
-    is not valid and preserve the original config file`, async () => {
-      const confValidator = new ConfigValidator(
-        <ConfigSchema>testData.schemaConfigCharPair.schema
-      );
-      const originalObj = JSON.parse(
-        fs.readFileSync(path.join(configDir, 'local.json'), 'utf-8')
-      );
-
-      const obj = {
-        servers: {
-          url: 555,
-        },
-      };
-
-      confValidator.validateAndWriteConfig(obj, config, 'local', 'json');
-
-      const savedObj = JSON.parse(
-        fs.readFileSync(path.join(configDir, 'local.json'), 'utf-8')
-      );
-      expect(savedObj).toEqual(obj);
-    });
-  });
-});