ambari/ambari-web/test/utils/config_test.js

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

var App = require('app');
require('config');
require('utils/configs_collection');
require('utils/config');
require('models/service/hdfs');
var setups = require('test/init_model_test');

describe('App.config', function () {

  describe('#trimProperty',function() {
    var testMessage = 'displayType `{0}`, value `{1}`{3} should return `{2}`';
    var tests = [
      {
        config: {
          displayType: 'directory',
          value: ' /a /b /c'
        },
        e: '/a,/b,/c'
      },
      {
        config: {
          displayType: 'directories',
          value: ' /a /b '
        },
        e: '/a,/b'
      },
      {
        config: {
          displayType: 'directories',
          name: 'dfs.datanode.data.dir',
          value: ' [DISK]/a [SSD]/b '
        },
        e: '[DISK]/a,[SSD]/b'
      },
      {
        config: {
          displayType: 'directories',
          name: 'dfs.datanode.data.dir',
          value: '/a,/b, /c\n/d,\n/e  /f'
        },
        e: '/a,/b,/c,/d,/e,/f'
      },
      {
        config: {
          displayType: 'host',
          value: ' localhost '
        },
        e: 'localhost'
      },
      {
        config: {
          displayType: 'password',
          value: ' passw ord '
        },
        e: ' passw ord '
      },
      {
        config: {
          displayType: 'string',
          value: ' value'
        },
        e: ' value'
      },
      {
        config: {
          displayType: 'string',
          value: ' value'
        },
        e: ' value'
      },
      {
        config: {
          displayType: 'string',
          value: 'http://localhost ',
          name: 'javax.jdo.option.ConnectionURL'
        },
        e: 'http://localhost'
      },
      {
        config: {
          displayType: 'string',
          value: 'http://localhost    ',
          name: 'oozie.service.JPAService.jdbc.url'
        },
        e: 'http://localhost'
      },
      {
        config: {
          displayType: 'custom',
          value: ' custom value '
        },
        e: ' custom value'
      },
      {
        config: {
          displayType: 'componentHosts',
          value: ['host1.com', 'host2.com']
        },
        e: ['host1.com', 'host2.com']
      }
    ];

    tests.forEach(function(test) {
      it(testMessage.format(test.config.displayType, test.config.value, test.e, !!test.config.name ? ', name `' + test.config.name + '`' : ''), function() {
        expect(App.config.trimProperty(test.config)).to.eql(test.e);
        expect(App.config.trimProperty(Em.Object.create(test.config), true)).to.eql(test.e);
      });
    });
  });

  describe('#mapCustomStack', function() {
    before(function() {
      setups.setupStackVersion(this, 'HDF-2.2');
    });

    it('versions of HDF > 2.0 should map with HDP 2.3 stack based property definitions', function() {
      var baseStackFolder = App.config.mapCustomStack();
      expect(baseStackFolder).to.equal("HDP2.3");
    });

    it('versions of HDF = 2.0 should map with HDP 2.3 stack based property definitions', function() {
      App.set('currentStackVersion', 'HDF-2.0');
      var baseStackFolder = App.config.mapCustomStack();
      expect(baseStackFolder).to.equal("HDP2.3");
    });


    after(function() {
      setups.restoreStackVersion(this);
    });
  });

  describe('#preDefinedConfigFile', function() {
    before(function() {
      setups.setupStackVersion(this, 'BIGTOP-0.8');
    });

    it('bigtop site properties should be ok.', function() {
      var bigtopSiteProperties = App.config.preDefinedConfigFile('BIGTOP', 'site_properties');
      expect(bigtopSiteProperties).to.be.ok;
    });

    it('a non-existing file should not be ok.', function () {
      var notExistingSiteProperty = App.config.preDefinedConfigFile('notExisting');
      expect(notExistingSiteProperty).to.not.be.ok;
    });

    after(function() {
      setups.restoreStackVersion(this);
    });
  });

  describe('#preDefinedSiteProperties-bigtop', function () {
    before(function() {
      setups.setupStackVersion(this, 'BIGTOP-0.8');
    });

    it('bigtop should use New PostgreSQL Database as its default hive metastore database', function () {
      App.StackService.createRecord({serviceName: 'HIVE'});
      expect(App.config.get('preDefinedSiteProperties').findProperty('recommendedValue', 'New PostgreSQL Database')).to.be.ok;
    });

    after(function() {
      setups.restoreStackVersion(this);
    });
  });

  describe('#generateConfigPropertiesByName', function() {
    var tests = [
      {
        names: ['property_1', 'property_2'],
        properties: undefined,
        e: {
          keys: ['name']
        },
        m: 'Should generate base property object without additional fields'
      },
      {
        names: ['property_1', 'property_2'],
        properties: { category: 'SomeCat', serviceName: 'SERVICE_NAME' },
        e: {
          keys: ['name', 'category', 'serviceName']
        },
        m: 'Should generate base property object without additional fields'
      }
    ];

    tests.forEach(function(test) {
      it(test.m, function() {
        expect(App.config.generateConfigPropertiesByName(test.names, test.properties).length).to.eql(test.names.length);
        expect(App.config.generateConfigPropertiesByName(test.names, test.properties).map(function(property) {
          return Em.keys(property);
        }).reduce(function(p, c) {
          return p.concat(c);
        }).uniq()).to.eql(test.e.keys);
      });
    });

  });

  describe('#setPreDefinedServiceConfigs', function() {
    beforeEach(function() {
      sinon.stub(App.StackService, 'find', function() {
        return [
          Em.Object.create({
            id: 'HDFS',
            serviceName: 'HDFS',
            configTypes: {
              'hadoop-env': {},
              'hdfs-site': {}
            }
          }),
          Em.Object.create({
            id: 'OOZIE',
            serviceName: 'OOZIE',
            configTypes: {
              'oozie-env': {},
              'oozie-site': {}
            }
          })
        ];
      });
      App.config.setPreDefinedServiceConfigs(true);
    });
    afterEach(function() {
      App.StackService.find.restore();
    });

    it('should include service MISC', function() {
      expect(App.config.get('preDefinedServiceConfigs').findProperty('serviceName', 'MISC')).to.be.ok;
    });

    it('should include -env config types according to stack services', function() {
      var miscCategory = App.config.get('preDefinedServiceConfigs').findProperty('serviceName', 'MISC');
      expect(Em.keys(miscCategory.get('configTypes'))).to.eql(['cluster-env', 'hadoop-env', 'oozie-env']);
    });
  });
  
  describe('#isManagedMySQLForHiveAllowed', function () {

    var cases = [
      {
        osFamily: 'redhat5',
        expected: false
      },
      {
        osFamily: 'redhat6',
        expected: true
      },
      {
        osFamily: 'suse11',
        expected: false
      }
    ],
      title = 'should be {0} for {1}';

    cases.forEach(function (item) {
      it(title.format(item.expected, item.osFamily), function () {
        expect(App.config.isManagedMySQLForHiveAllowed(item.osFamily)).to.equal(item.expected);
      });
    });

  });

  describe('#shouldSupportFinal', function () {

    var cases = [
      {
        shouldSupportFinal: false,
        title: 'no service name specified'
      },
      {
        serviceName: 's0',
        shouldSupportFinal: false,
        title: 'no filename specified'
      },
      {
        serviceName: 'MISC',
        shouldSupportFinal: false,
        title: 'MISC'
      },
      {
        serviceName: 's0',
        filename: 's0-site',
        shouldSupportFinal: true,
        title: 'final attribute supported'
      },
      {
        serviceName: 's0',
        filename: 's0-env',
        shouldSupportFinal: false,
        title: 'final attribute not supported'
      },
      {
        serviceName: 'Cluster',
        filename: 'krb5-conf.xml',
        shouldSupportFinal: false,
        title: 'kerberos descriptor identities don\'t support final'
      }
    ];

    beforeEach(function () {
      sinon.stub(App.StackService, 'find').returns([
        {
          serviceName: 's0'
        }
      ]);
      sinon.stub(App.config, 'getConfigTypesInfoFromService').returns({
        supportsFinal: ['s0-site']
      });
    });

    afterEach(function () {
      App.StackService.find.restore();
      App.config.getConfigTypesInfoFromService.restore();
    });

    cases.forEach(function (item) {
      it(item.title, function () {
        expect(App.config.shouldSupportFinal(item.serviceName, item.filename)).to.equal(item.shouldSupportFinal);
      });
    });

  });

  describe('#shouldSupportAddingForbidden', function () {

    var cases = [
      {
        shouldSupportAddingForbidden: false,
        title: 'no service name specified'
      },
      {
        serviceName: 's0',
        shouldSupportAddingForbidden: false,
        title: 'no filename specified'
      },
      {
        serviceName: 'MISC',
        shouldSupportAddingForbidden: false,
        title: 'MISC'
      },
      {
        serviceName: 's0',
        filename: 's0-site',
        shouldSupportAddingForbidden: true,
        title: 'adding forbidden supported'
      },
      {
        serviceName: 's0',
        filename: 's0-properties',
        shouldSupportAddingForbidden: false,
        title: 'adding forbidden not supported'
      }
    ];

    beforeEach(function () {
      sinon.stub(App.StackService, 'find').returns([
        Em.Object.create({
          serviceName: 's0',
          configTypes: {
            's0-size': {},
            's0-properties': {}
          }
        })
      ]);
      sinon.stub(App.config, 'getConfigTypesInfoFromService').returns({
        supportsAddingForbidden: ['s0-site']
      });
    });

    afterEach(function () {
      App.StackService.find.restore();
      App.config.getConfigTypesInfoFromService.restore();
    });

    cases.forEach(function (item) {
      it(item.title, function () {
        expect(App.config.shouldSupportAddingForbidden(item.serviceName, item.filename)).to.equal(item.shouldSupportAddingForbidden);
      });
    });

  });

  describe('#removeRangerConfigs', function () {

    it('should remove ranger configs and categories', function () {
      var configs = [
        Em.Object.create({
          configs: [
            Em.Object.create({filename: 'filename'}),
            Em.Object.create({filename: 'ranger-filename'})
          ],
          configCategories: [
            Em.Object.create({name: 'ranger-name'}),
            Em.Object.create({name: 'name'}),
            Em.Object.create({name: 'also-ranger-name'})
          ]
        })
      ];
      App.config.removeRangerConfigs(configs);
      expect(configs).eql(
          [
            Em.Object.create({
              configs: [
                Em.Object.create({filename: 'filename'})
              ],
              configCategories: [
                Em.Object.create({name: 'name'})
              ]
            })
          ]
      );
    });

  });

  describe("#createOverride", function() {
    var template = {
      name: "p1",
      filename: "f1",
      value: "v1",
      recommendedValue: "rv1",
      savedValue: "sv1",
      isFinal: true,
      recommendedIsFinal: false,
      savedIsFinal: true
    };

    var configProperty = App.ServiceConfigProperty.create(template);

    var group = Em.Object.create({name: "group1", properties: []});

    Object.keys(template).forEach(function (key) {
      it(key, function () {
        var override = App.config.createOverride(configProperty, {}, group);
        if (['savedValue', 'savedIsFinal'].contains(key)) {
          expect(override.get(key)).to.equal(null);
        } else {
          expect(override.get(key)).to.equal(template[key]);
        }
      });
    });

    describe('overrides some values that should be different for override', function() {
      var override;
      beforeEach(function () {
        override = App.config.createOverride(configProperty, {}, group);
      });
      it('isOriginalSCP is false', function () {
        expect(override.get('isOriginalSCP')).to.be.false;
      });
      it('overrides is null', function () {
        expect(override.get('overrides')).to.be.null;
      });
      it('group is valid', function () {
        expect(override.get('group')).to.eql(group);
      });
      it('parentSCP is valid', function () {
        expect(override.get('parentSCP')).to.eql(configProperty);
      });
    });

    var overriddenTemplate = {
      value: "v2",
      recommendedValue: "rv2",
      savedValue: "sv2",
      isFinal: true,
      recommendedIsFinal: false,
      savedIsFinal: true
    };

    Object.keys(overriddenTemplate).forEach(function (key) {
      it('overrides some specific values `' + key + '`', function () {
        var override = App.config.createOverride(configProperty, overriddenTemplate, group);
        expect(override.get(key)).to.equal(overriddenTemplate[key]);
      });
    });

    it('throws error due to undefined configGroup', function() {
      expect(App.config.createOverride.bind(App.config, configProperty, {}, null)).to.throw(App.EmberObjectTypeError);
    });

    it('throws error due to undefined originalSCP', function() {
      expect(App.config.createOverride.bind(App.config, null, {}, group)).to.throw(App.ObjectTypeError);
    });

    describe('updates originalSCP object ', function() {

      var overridenTemplate2;
      var override;

      beforeEach(function () {
        configProperty.set('overrides', null);
        configProperty.set('overrideValues', []);
        configProperty.set('overrideIsFinalValues', []);
        overridenTemplate2 = {
          value: "v12",
          recommendedValue: "rv12",
          savedValue: "sv12",
          isFinal: true,
          recommendedIsFinal: false,
          savedIsFinal: false
        };
        override = App.config.createOverride(configProperty, overridenTemplate2, group);
      });

      it('overrides.0 is valid', function () {
        expect(configProperty.get('overrides')[0]).to.be.eql(override);
      });
      it('overrideValues is valid', function () {
        expect(configProperty.get('overrideValues')).to.be.eql([overridenTemplate2.savedValue]);
      });
      it('overrideIsFinalValues is valid', function () {
        expect(configProperty.get('overrideIsFinalValues')).to.be.eql([overridenTemplate2.savedIsFinal]);
      });

    });
  });

  describe('#getIsSecure', function() {
    var secureConfigs = App.config.get('secureConfigs');
    before(function() {
      App.config.set('secureConfigs', [{name: 'secureConfig'}]);
    });
    after(function() {
      App.config.set('secureConfigs', secureConfigs);
    });

    it('config is secure', function() {
      expect(App.config.getIsSecure('secureConfig')).to.equal(true);
    });
    it('config is not secure', function() {
      expect(App.config.getIsSecure('NotSecureConfig')).to.equal(false);
    });
  });

  describe('#getDefaultCategory', function() {
    it('returns custom category', function() {
      expect(App.config.getDefaultCategory(null, 'filename.xml')).to.equal('Custom filename');
    });
    it('returns advanced category', function() {
      expect(App.config.getDefaultCategory(Em.Object.create, 'filename.xml')).to.equal('Advanced filename');
    });
  });

  describe('#getDefaultDisplayType', function() {
    it('returns singleLine displayType', function() {
      expect(App.config.getDefaultDisplayType('v1')).to.equal('string');
    });
    it('returns multiLine displayType', function() {
      expect(App.config.getDefaultDisplayType('v1\nv2')).to.equal('multiLine');
    });
  });

  describe('#formatValue', function() {
    it('formatValue for componentHosts', function () {
      var serviceConfigProperty = Em.Object.create({'displayType': 'componentHosts', value: "['h1','h2']"});
      expect(App.config.formatPropertyValue(serviceConfigProperty)).to.eql(['h1','h2']);
    });

    it('formatValue for int', function () {
      var serviceConfigProperty = Em.Object.create({'displayType': 'int', value: '4.0'});
      expect(App.config.formatPropertyValue(serviceConfigProperty)).to.equal('4');
    });

    it('formatValue for int with m', function () {
      var serviceConfigProperty = Em.Object.create({'displayType': 'int', value: '4m'});
      expect(App.config.formatPropertyValue(serviceConfigProperty)).to.equal('4');
    });

    it('formatValue for float', function () {
      var serviceConfigProperty = Em.Object.create({'displayType': 'float', value: '0.40'});
      expect(App.config.formatPropertyValue(serviceConfigProperty)).to.equal('0.4');
    });

    it('formatValue for kdc_type', function () {
      var serviceConfigProperty = Em.Object.create({'name': 'kdc_type', value: 'mit-kdc'});
      expect(App.config.formatPropertyValue(serviceConfigProperty)).to.equal(Em.I18n.t('admin.kerberos.wizard.step1.option.kdc'));
    });

    it('don\'t format value', function () {
      var serviceConfigProperty = Em.Object.create({'name': 'any', displayType: 'any', value: 'any'});
      expect(App.config.formatPropertyValue(serviceConfigProperty)).to.equal('any');
    });
  });

  describe('#getPropertyIfExists', function() {
    [
      {
        propertyName: 'someProperty',
        defaultValue: 'default',
        firstObject: { someProperty: '1' },
        secondObject: { someProperty: '2' },
        res: '1',
        m: 'use value from first object'
      },
      {
        propertyName: 'someProperty',
        defaultValue: 'default',
        firstObject: { someOtherProperty: '1' },
        secondObject: { someProperty: '2' },
        res: '2',
        m: 'use value from second object'
      },
      {
        propertyName: 'someProperty',
        defaultValue: 'default',
        firstObject: { someOtherProperty: '1' },
        secondObject: { someOtherProperty: '2' },
        res: 'default',
        m: 'use default value'
      },
      {
        propertyName: 'someProperty',
        defaultValue: 'default',
        res: 'default',
        m: 'use default value'
      },
      {
        propertyName: 'someProperty',
        defaultValue: true,
        firstObject: { someProperty: false },
        secondObject: { someProperty: true },
        res: false,
        m: 'use value from first object, check booleans'
      },
      {
        propertyName: 'someProperty',
        defaultValue: true,
        firstObject: { someProperty: 0 },
        secondObject: { someProperty: 1 },
        res: 0,
        m: 'use value from first object, check 0'
      },
      {
        propertyName: 'someProperty',
        defaultValue: true,
        firstObject: { someProperty: '' },
        secondObject: { someProperty: '1' },
        res: '',
        m: 'use value from first object, check empty string'
      }
    ].forEach(function (t) {
        it(t.m, function () {
          expect(App.config.getPropertyIfExists(t.propertyName, t.defaultValue, t.firstObject, t.secondObject)).to.equal(t.res);
        })
      });
  });

  describe('#createDefaultConfig', function() {
    before(function() {
      sinon.stub(App.config, 'getDefaultDisplayType', function() {
        return 'pDisplayType';
      });
      sinon.stub(App.config, 'getDefaultCategory', function() {
        return 'pCategory';
      });
      sinon.stub(App.config, 'getIsSecure', function() {
        return false;
      });
      sinon.stub(App.config, 'shouldSupportFinal', function() {
        return true;
      });
      sinon.stub(App.config, 'get', function(param) {
        if (param === 'serviceByConfigTypeMap') {
          return { 'pFileName': Em.Object.create({serviceName: 'pServiceName' }) };
        }
        return Em.get(App.config, param);
      });
    });

    after(function() {
      App.config.getDefaultDisplayType.restore();
      App.config.getDefaultCategory.restore();
      App.config.getIsSecure.restore();
      App.config.shouldSupportFinal.restore();
      App.config.get.restore();
    });

    var res = {
      /** core properties **/
      id: 'pName__pFileName',
      name: 'pName',
      filename: 'pFileName.xml',
      value: '',
      savedValue: null,
      isFinal: false,
      savedIsFinal: null,
      /** UI and Stack properties **/
      recommendedValue: null,
      recommendedIsFinal: null,
      supportsFinal: true,
      supportsAddingForbidden: false,
      serviceName: 'pServiceName',
      displayName: 'pName',
      displayType: 'pDisplayType',
      description: '',
      category: 'pCategory',
      isSecureConfig: false,
      showLabel: true,
      isVisible: true,
      isUserProperty: false,
      isRequired: true,
      group: null,
      isRequiredByAgent:  true,
      isReconfigurable: true,
      unit: null,
      hasInitialValue: false,
      isOverridable: true,
      index: Infinity,
      dependentConfigPattern: null,
      options: null,
      radioName: null,
      widgetType: null,
      errorMessage: '',
      warnMessage: ''
    };
    it('create default config object', function () {
      expect(App.config.createDefaultConfig('pName', 'pFileName', true)).to.eql(res);
    });
    it('getDefaultDisplayType is called', function() {
      expect(App.config.getDefaultDisplayType.called).to.be.true;
    });
    it('getDefaultCategory is called with correct arguments', function() {
      expect(App.config.getDefaultCategory.calledWith(true, 'pFileName')).to.be.true;
    });
    it('getIsSecure is called with correct arguments', function() {
      expect(App.config.getIsSecure.calledWith('pName')).to.be.true;
    });
    it('shouldSupportFinal is called with correct arguments', function() {
      expect(App.config.shouldSupportFinal.calledWith('pServiceName', 'pFileName')).to.be.true;
    });
  });

  describe('#mergeStackConfigsWithUI', function() {
    beforeEach(function() {
      sinon.stub(App.config, 'getPropertyIfExists', function(key, value) {return 'res_' + value});
    });

    afterEach(function() {
      App.config.getPropertyIfExists.restore();
    });

    var template = {
      name: 'pName',
      filename: 'pFileName',
      value: 'pValue',
      savedValue: 'pValue',
      isFinal: true,
      savedIsFinal: true,

      serviceName: 'pServiceName',
      displayName: 'pDisplayName',
      displayType: 'pDisplayType',
      category: 'pCategory'
    };

    var result = {
      name: 'pName',
      filename: 'pFileName',
      value: 'pValue',
      savedValue: 'pValue',
      isFinal: true,
      savedIsFinal: true,

      serviceName: 'res_pServiceName',
      displayName: 'res_pDisplayName',
      displayType: 'res_pDisplayType',
      category: 'res_pCategory'
    };

    it('called generate property object', function () {
      expect(App.config.mergeStaticProperties(template, {}, {})).to.eql(result);
    });
  });

  describe('#updateHostsListValue', function() {
    var tests = [
      {
        siteConfigs: {
          'hadoop.registry.zk.quorum': 'host1,host2'
        },
        propertyName: 'hadoop.registry.zk.quorum',
        hostsList: 'host1',
        e: 'host1'
      },
      {
        siteConfigs: {
          'hadoop.registry.zk.quorum': 'host1:10,host2:10'
        },
        propertyName: 'hadoop.registry.zk.quorum',
        hostsList: 'host2:10,host1:10',
        e: 'host1:10,host2:10'
      },
      {
        siteConfigs: {
          'hadoop.registry.zk.quorum': 'host1:10,host2:10,host3:10'
        },
        propertyName: 'hadoop.registry.zk.quorum',
        hostsList: 'host2:10,host1:10',
        e: 'host2:10,host1:10'
      },
      {
        siteConfigs: {
          'hadoop.registry.zk.quorum': 'host1:10,host2:10,host3:10'
        },
        propertyName: 'hadoop.registry.zk.quorum',
        hostsList: 'host2:10,host1:10,host3:10,host4:11',
        e: 'host2:10,host1:10,host3:10,host4:11'
      },
      {
        siteConfigs: {
          'hive.zookeeper.quorum': 'host1'
        },
        propertyName: 'some.new.property',
        hostsList: 'host2,host1:10',
        e: 'host2,host1:10'
      }
    ];
    tests.forEach(function(test) {
      it('ZK located on {0}, current prop value is "{1}" "{2}" value should be "{3}"'.format(test.hostsList, ''+test.siteConfigs[test.propertyName], test.propertyName, test.e), function() {
        var result = App.config.updateHostsListValue(test.siteConfigs, test.propertyName, test.hostsList);
        expect(result).to.be.eql(test.e);
        expect(test.siteConfigs[test.propertyName]).to.be.eql(test.e);
      });
    });
  });

  describe('#createHostNameProperty', function () {
    it('create host property', function () {
      expect(App.config.createHostNameProperty('service1', 'component1', ['host1'], Em.Object.create({
        isMultipleAllowed: false,
        displayName: 'display name'
      }))).to.eql({
            "id": 'component1_host__service1-site',
            "name": 'component1_host',
            "displayName": 'display name host',
            "value": ['host1'],
            "recommendedValue": ['host1'],
            "description": "The host that has been assigned to run display name",
            "displayType": "componentHost",
            "isOverridable": false,
            "isRequiredByAgent": false,
            "serviceName": 'service1',
            "filename": "service1-site.xml",
            "category": 'component1',
            "index": 0
          })
    });

    it('create hosts property', function () {
      expect(App.config.createHostNameProperty('service1', 'component1', ['host1'], Em.Object.create({
        isMultipleAllowed: true,
        displayName: 'display name'
      }))).to.eql({
            "id": 'component1_hosts__service1-site',
            "name": 'component1_hosts',
            "displayName": 'display name host',
            "value": ['host1'],
            "recommendedValue": ['host1'],
            "description": "The hosts that has been assigned to run display name",
            "displayType": "componentHosts",
            "isOverridable": false,
            "isRequiredByAgent": false,
            "serviceName": 'service1',
            "filename": "service1-site.xml",
            "category": 'component1',
            "index": 0
          })
    });
  });

  describe("#truncateGroupName()", function() {

    it("name is empty", function() {
      expect(App.config.truncateGroupName('')).to.be.empty;
    });

    it("name has less than max chars", function() {
      expect(App.config.truncateGroupName('group1')).to.equal('group1');
    });

    it("name has more than max chars", function() {
      expect(App.config.truncateGroupName('group_has_more_than_max_characters')).to.equal('group_has...haracters');
    });
  });

  describe('#getComponentName', function () {
    [
      { configName: 'somename_host', componentName: 'SOMENAME' },
      { configName: 'somename_hosts', componentName: 'SOMENAME' },
      { configName: 'somenamehost', componentName: '' },
      { configName: 'somenamehosts', componentName: '' }
    ].forEach(function (t) {
      it('format config name ' + t.configName + ' to component ', function() {
        expect(App.config.getComponentName(t.configName)).to.equal(t.componentName);
      });
    });
  });

  describe('#getDescription', function () {

    it('should add extra-message to the description for `password`-configs', function () {
      var extraMessage = Em.I18n.t('services.service.config.password.additionalDescription');
      expect(App.config.getDescription('', 'password')).to.contain(extraMessage);
    });

    it('should not add extra-message to the description if it already contains it', function () {

      var extraMessage = Em.I18n.t('services.service.config.password.additionalDescription');
      var res = App.config.getDescription(extraMessage, 'password');
      expect(res).to.contain(extraMessage);
      expect(res).to.contain(extraMessage);
      var subd = res.replace(extraMessage, '');
      expect(subd).to.not.contain(extraMessage);
    });

    it('should add extra-message to the description if description is not defined', function () {

      var extraMessage = Em.I18n.t('services.service.config.password.additionalDescription');
      expect(App.config.getDescription(undefined, 'password')).to.contain(extraMessage);
    });

  });

  describe('#parseIdentities', function() {
    var testObject = {
      identities: [
        {
          name: "/spnego"
        },
        {
          principal: {
            configuration: "hbase-env/hbase_principal_name",
            type: "user",
            local_username: "${hbase-env/hbase_user}",
            value: "${hbase-env/hbase_user}-${cluster_name|toLower()}@${realm}"
          },
          name: "hbase",
          keytab: {
            owner: {
              access: "r",
              name: "${hbase-env/hbase_user}"
            },
            file: "${keytab_dir}/hbase.headless.keytab",
            configuration: "hbase-env/hbase_user_keytab",
            group: {
              access: "r",
              name: "${cluster-env/user_group}"
            }
          }
        },
        {
          name: "/smokeuser"
        }
      ]
    };
    var result = {
      "hbase_principal_name__hbase-env": true,
      "hbase_user_keytab__hbase-env": true
    };

    it('generates map with identities', function() {
      expect(App.config.parseIdentities(testObject, {})).to.eql(result);
    });
  });

  describe('#kerberosIdentitiesDescription', function () {
    it('update empty description', function() {
      expect(App.config.kerberosIdentitiesDescription()).to.eql(Em.I18n.t('services.service.config.secure.additionalDescription'));
    });

    it('update description for identities (without dot)', function() {
      expect(App.config.kerberosIdentitiesDescription('some text')).to.eql('some text. '
        + Em.I18n.t('services.service.config.secure.additionalDescription'));
    });

    it('update description for identities (with dot)', function() {
      expect(App.config.kerberosIdentitiesDescription('some text.')).to.eql('some text. '
        + Em.I18n.t('services.service.config.secure.additionalDescription'));
    });

    it('update description for identities (with dot and spaces at the end)', function() {
      expect(App.config.kerberosIdentitiesDescription('some text. ')).to.eql('some text. '
        + Em.I18n.t('services.service.config.secure.additionalDescription'));
    });
  });
});