@creativefeather/config/test/utils.tests.js

const assert = require('assert'),
      common = require('./common'),
      path = require('path');

const { _getDeploymentConfig,
        _getIndexConfig,
        clone,
        get,
        getAllConfigs,
        getConfig,
        merge,
        mergeWith } = require('../src/lib');

const { compressEnv,
        _defaultMerge,
        _getMerger,
        _isEnvProp,
        _isValueType,
        _parseKey } = require('../src/lib/object');

const configPath = path.join(__dirname, './config');
const options = { path: configPath };

describe('lib module', function() {
  
  describe('"dir"', function() {
    const dir = require('../src/lib/dir');

    it('rootPath()', function() {
      assert.strictEqual(dir.appRoot(), path.join(__dirname, '..'));
    });
  });

  describe('"env"', function() {
    const env = require('../src/lib/env');

    it('_isNpmEnvSet()', function() {
      process.env.npm_ = "set for testing";
      assert.strictEqual(env._isNpmEnvSet(), true);
      delete process.env.npm_;
      assert.ok(!process.env.npm_);
    });

    it('_getPackageConfigPath()', function() {
      let dir = path.join(__dirname, '../');
      let packageConfigPath = env._getPackageConfigPath(dir);
      assert.ok(packageConfigPath);
      assert.strictEqual(
        packageConfigPath,
        './test/config');
    });

    it('_getEnvConfigPath()', function() {
      const APP_CONFIG_PATH = "CONFIG_PATH";
      process.env[APP_CONFIG_PATH] = './test/config';
      let envConfigPath = env._getEnvConfigPath();
      assert.ok(envConfigPath);
      assert.strictEqual(
        envConfigPath,
        './test/config');
      delete process.env[APP_CONFIG_PATH];
      assert.ok(!process.env[APP_CONFIG_PATH]);

      // npm_packag_config_configPath
      // process.env.npm_package_config_config_path = './test/config';
      // envConfigPath = env._getEnvConfigPath();
      // assert.ok(envConfigPath);
      // assert.strictEqual(
      //   envConfigPath,
      //   './test/config');
      // delete process.env.npm_package_config_config_path;
      // assert.ok(!process.env.npm_package_config_config_path);

    });

    it('getConfigPath()', function() {
      assert.strictEqual(
        env.getConfigPath(),
        configPath);
      
      // package.json has a config value for config path but the module isn't defaulting to ./config.  How would I test for that since it will pick up the value if there is one in package.json.
    });
  });
  
  describe('file', function() {
    //const file = require('../src/lib/file');
    
    describe('_getIndexConfig', function() {
      let indexConfig = _getIndexConfig(options);

      it('gets index config object', function() {
        assert.ok(indexConfig);
      });

      it('all values are as expected', function() {
        assert.strictEqual(indexConfig.logging, false);
        //console.log(indexConfig.get("db"));
        assert.strictEqual(
          get(indexConfig, "db.username"), null);
        assert.strictEqual(indexConfig.db.password, null);
        assert.strictEqual(indexConfig.db.host, null);
        assert.strictEqual(indexConfig.db.port, 27017);
        assert.strictEqual(indexConfig.db.database, null);
      });
    });


    describe('_getDeploymentConfig', function() {
      let saved = {};

      before(function() {
        saved.NODE_ENV = process.env.NODE_ENV;
        saved.TEST = process.env.TEST;
      });

      describe('development values', function() {
        let dev; 

        before(function() {
          process.env.NODE_ENV = "development";
          delete process.env.TEST;

          dev = _getDeploymentConfig("development", options);
        });

        it('NODE_ENV = "development"', function() {
          assert.strictEqual(process.env.NODE_ENV, "development");
        });

        it('TEST = undefined', function() {
          assert.strictEqual(process.env.hasOwnProperty("TEST"), false);
          assert.strictEqual(process.env.TEST, undefined);
        });

        it('logging ok', function() {
          assert.strictEqual(dev.logging, true);
        });
        
        it('username ok', function() {
          assert.strictEqual(dev.db.username, "app");
        });

        it('password ok', function() {
          assert.strictEqual(dev.db.password, "password123");
        });

        it('host ok', function() {
          assert.strictEqual(dev.db.host, "localhost");
        });

        it('port ok', function() {
          assert.strictEqual(dev.db.port, 27017);
        });

        it('database ok', function() {
          assert.strictEqual(dev.db.database, "dev");
        });
      });

      describe('testing values', function() {
        let test; 

        before(function() {
          process.env.NODE_ENV = "development";
          process.env.TEST = "TEST";
          test = _getDeploymentConfig("development", options);
        });

        it('NODE_ENV = "development"', function() {
          assert.strictEqual(process.env.NODE_ENV, "development");
        });

        it('TEST = "TEST"', function() {
          assert.strictEqual(process.env.TEST, "TEST");
        });

        it('logging ok', function() {
          assert.strictEqual(test.logging, false);
        });
        
        it('db username ok', function() {
          assert.strictEqual(test.db.username, "app");
        });

        it('db password ok', function() {
          assert.strictEqual(test.db.password, "password123");
        });

        it('db host ok', function() {
          assert.strictEqual(test.db.host, "127.0.0.1");
        });

        it('db port ok', function() {
          assert.strictEqual(test.db.port, 27017);
        });

        it('db database ok', function() {
          assert.strictEqual(test.db.database, "test");
        });
      });

      after(function() {
        process.env.NODE_ENV = saved.NODE_ENV;
        process.env.TEST = saved.TEST;
      });

    });  // getDeployment


    describe('getConfig', function() {
      let saved = {};

      before(function() {
        saved.NODE_ENV = process.env.NODE_ENV;
        saved.TEST = process.env.TEST;
      });

      beforeEach(function() {
        delete process.env.NODE_ENV;
        delete process.env.TEST;
      });

      it('default config validates', function() {
        let config = getConfig();

        assert.strictEqual(config('#env'), 'development');
        common.assert_development_config(config);        
      });

      it('development config validates', function() {
        let config = getConfig('development');

        common.assert_development_config(config);
      });

      it('development+TEST config validates', function() {
        process.env.TEST = "TEST";
        let config = getConfig('development');

        common.assert_development_plus_TEST_config(config);
      });

      it('staging config validates', function() {
        process.env.NODE_ENV = 'staging';
        let config = getConfig('staging', options);

        common.assert_staging_config(config);
      });

      after(function() {
        process.env.NODE_ENV = saved.NODE_ENV;
        process.env.TEST = saved.TEST;
      });
    });


    describe('getAllConfigs', function() {
      // TODO:!!!
      // ...w/out options passed?
      let dev = getConfig("development", options);
      let staging = getConfig("staging", options);
      let configs = getAllConfigs(options);

      it('gets 2 configs', function() {
        assert.strictEqual(Object.keys(configs).length, 2);
      });

      it('development config validates', function() {
        common.assert_development_plus_TEST_config(dev);
      });

      it('staging config validates', function() {
        common.assert_staging_config(staging);
      });

      it('from all: development config validates', function() {
        common.assert_development_plus_TEST_config(configs.development);
      });

      it('from all: staging config validates', function() {
        common.assert_staging_config(configs.staging);
      });

      // I didn't see that the values in the configs were different.  Maybe something about the deepEqual is causing it to be different.  The only weird thing, is that it was working before I made some changes.  Nothing is wrong with the other ways of checking the configs returned.  So, all is well enough.
      // it('deepStrict validates', function() {
      //   let obj1 = { 
      //     "development": dev,
      //     "staging": staging
      //   };

      //   assert.deepEqual(configs, obj1);
      // });
    });
  });
});