AMBARI-5738 Unit test and refactoring for controllers/main/service/info/config.js part 2. (ababiichuk)

ambari-web/app/controllers/main/service/info/configs.js

@@ -1167,7 +1167,7 @@ App.MainServiceInfoConfigsController = Em.Controller.extend({
   formatConfigValues: function(serviceConfigProperties){
     serviceConfigProperties.forEach(function (_config) {
       if (typeof _config.get('value') === "boolean") _config.set('value', _config.value.toString());
-      _config.set('value', App.config.trimProperty(_config), true);
+      _config.set('value', App.config.trimProperty(_config, true));
     });
   },
 
@@ -1290,71 +1290,77 @@ App.MainServiceInfoConfigsController = Em.Controller.extend({
   /**
    * Saves cluster level configurations for all necessary sites.
    * PUT calls are made to /api/v1/clusters/clusterName for each site.
-   *
    * @return {Boolean}
+   * @method doPUTClusterConfigurations
    */
   doPUTClusterConfigurations: function () {
     var result = true;
     var serviceConfigTags = this.get('serviceConfigTags');
     this.setNewTagNames(serviceConfigTags);
     var siteNameToServerDataMap = {};
-    var configController = App.router.get('configurationController');
-    var filenameExceptions = App.config.get('filenameExceptions');
 
     serviceConfigTags.forEach(function (_serviceTags) {
-      var loadedProperties;
-      if (_serviceTags.siteName === 'global') {
-        console.log("TRACE: Inside global");
-        var serverGlobalConfigs = this.createGlobalSiteObj(_serviceTags.newTagName, this.get('globalConfigs'));
-        siteNameToServerDataMap['global'] = serverGlobalConfigs;
-        loadedProperties = configController.getConfigsByTags([{siteName: 'global', tagName: this.loadedClusterSiteToTagMap['global']}]);
-        if (loadedProperties && loadedProperties[0]) {
-          loadedProperties = loadedProperties[0].properties;
-        }
-        if (this.isConfigChanged(loadedProperties, serverGlobalConfigs.properties)) {
-          result = result && this.doPUTClusterConfigurationSite(serverGlobalConfigs);
-        }
-      }
-      else {
-        if (_serviceTags.siteName === 'core-site') {
-          console.log("TRACE: Inside core-site");
-          if (this.get('content.serviceName') === 'HDFS' || this.get('content.serviceName') === 'GLUSTERFS') {
-            var coreSiteConfigs = this.createCoreSiteObj(_serviceTags.newTagName);
-            siteNameToServerDataMap['core-site'] = coreSiteConfigs;
-            loadedProperties = configController.getConfigsByTags([{siteName: 'core-site', tagName: this.loadedClusterSiteToTagMap['core-site']}]);
-            if (loadedProperties && loadedProperties[0]) {
-              loadedProperties = loadedProperties[0].properties;
-            }
-            if (this.isConfigChanged(loadedProperties, coreSiteConfigs.properties)) {
-              result = result && this.doPUTClusterConfigurationSite(coreSiteConfigs);
-            }
-          }
-        }
-        else {
-          var filename = (filenameExceptions.contains(_serviceTags.siteName)) ? _serviceTags.siteName : _serviceTags.siteName + '.xml';
-          var siteConfigs = this.get('uiConfigs').filterProperty('filename', filename);
-          var serverConfigs = this.createSiteObj(_serviceTags.siteName, _serviceTags.newTagName, siteConfigs);
-          siteNameToServerDataMap[_serviceTags.siteName] = serverConfigs;
-          loadedProperties = configController.getConfigsByTags([{siteName: _serviceTags.siteName, tagName: this.loadedClusterSiteToTagMap[_serviceTags.siteName]}]);
-          if (loadedProperties && loadedProperties[0]) {
-            loadedProperties = loadedProperties[0].properties;
-          }
-          if (!loadedProperties) {
-            loadedProperties = {};
-          }
-          if (filename === 'mapred-queue-acls' && !App.supports.capacitySchedulerUi) {
-            return;
-          }
-          if (this.isConfigChanged(loadedProperties, serverConfigs.properties)) {
-            result = result && this.doPUTClusterConfigurationSite(serverConfigs);
-          }
-        }
+      var configs = this.createConfigObject(_serviceTags.siteName, _serviceTags.newTagName);
+      if (configs) {
+        result = result && this.doPUTClusterConfiguration(siteNameToServerDataMap, _serviceTags.siteName, configs);
       }
     }, this);
-    this.savedSiteNameToServerServiceConfigDataMap = siteNameToServerDataMap;
+    this.set("savedSiteNameToServerServiceConfigDataMap", siteNameToServerDataMap);
     return result;
   },
 
+  /**
+   * create different config object depending on siteName
+   * @param {String} siteName
+   * @param {String} tagName
+   * @returns {Object|undefined}
+   * @method createConfigObject
+   */
+  createConfigObject: function(siteName, tagName) {
+    console.log("TRACE: Inside " + siteName);
+    switch(siteName) {
+      case 'global':
+        return this.createGlobalSiteObj(tagName, this.get('globalConfigs'));
+      case 'core-site':
+        if(this.get('content.serviceName') === 'HDFS' || this.get('content.serviceName') === 'GLUSTERFS') {
+          return this.createCoreSiteObj(tagName);
+        }
+        return;
+      default:
+        var filename = (App.config.get('filenameExceptions').contains(siteName)) ? siteName : siteName + '.xml';
+        if (filename === 'mapred-queue-acls.xml' && !App.supports.capacitySchedulerUi) {
+          return;
+        }
+      return this.createSiteObj(siteName, tagName, this.get('uiConfigs').filterProperty('filename', filename));
+    }
+  },
+
+  /**
+   * load existen properties and compare them with current if there are
+   * differences - trigger doPUTClusterConfigurationSite to save new properties
+   * @param {Object} siteNameToServerDataMap
+   * @param {String} siteName
+   * @param {Object} configs
+   * @returns {Boolean} true if config successfully saved or there
+   *                    is no need to save them
+   * @method doPUTClusterConfiguration
+   */
+  doPUTClusterConfiguration: function(siteNameToServerDataMap, siteName, configs) {
+    var loadedProperties;
+    siteNameToServerDataMap[siteName] = configs;
+    loadedProperties = App.router.get('configurationController').getConfigsByTags([{siteName: siteName, tagName: this.loadedClusterSiteToTagMap[siteName]}]);
+    if (loadedProperties && loadedProperties[0]) {
+      loadedProperties = loadedProperties[0].properties;
+    }
+    if (!loadedProperties) {
+      loadedProperties = {};
+    }
+    if (this.isConfigChanged(loadedProperties, configs.properties)) {
+      return this.doPUTClusterConfigurationSite(configs);
+    }
+    return true;
+  },
+
 
   /**
    * Compares the loaded config values with the saving config values.
@@ -1551,134 +1557,192 @@ App.MainServiceInfoConfigsController = Em.Controller.extend({
     }
   },
 
+  /**
+   * Array of Objects
+   * {
+   *  hostProperty - hostName property name for current component
+   *  componentName - master componentName
+   *  serviceName - serviceName of component
+   *  serviceUseThis - services that use hostname property of component(componentName)
+   *  m(multiple) - true if can be more than one components installed on cluster
+   * }
+   */
+
+  hostComponentsmapping: [
+    {
+      hostProperty: 'namenode_host',
+      componentName: 'NAMENODE',
+      serviceName: 'HDFS',
+      serviceUseThis: [],
+      m: true
+    },
+    {
+      hostProperty: 'snamenode_host',
+      componentName: 'SECONDARY_NAMENODE',
+      serviceName: 'HDFS',
+      serviceUseThis: []
+    },
+    {
+      hostProperty: 'jobtracker_host',
+      componentName: 'JOBTRACKER',
+      serviceName: 'MAPREDUCE',
+      serviceUseThis: []
+    },
+    {
+      hostProperty: 'jobtracker_host',
+      componentName: 'JOBTRACKER',
+      serviceName: 'MAPREDUCE2',
+      serviceUseThis: []
+    },
+    {
+      hostProperty: 'hs_host',
+      componentName: 'HISTORYSERVER',
+      serviceName: 'MAPREDUCE2',
+      serviceUseThis: ['YARN']
+    },
+    {
+      hostProperty: 'ats_host',
+      componentName: 'APP_TIMELINE_SERVER',
+      serviceName: 'YARN',
+      serviceUseThis: []
+    },
+    {
+      hostProperty: 'rm_host',
+      componentName: 'RESOURCEMANAGER',
+      serviceName: 'YARN',
+      serviceUseThis: []
+    },
+    {
+      hostProperty: 'hivemetastore_host',
+      componentName: 'HIVE_SERVER',
+      serviceName: 'HIVE',
+      serviceUseThis: ['WEBHCAT']
+    },
+    {
+      hostProperty: 'oozieserver_host',
+      componentName: 'OOZIE_SERVER',
+      serviceName: 'OOZIE',
+      serviceUseThis: []
+    },
+    {
+      hostProperty: 'hbasemaster_host',
+      componentName: 'HBASE_MASTER',
+      serviceName: 'HBASE',
+      serviceUseThis: [],
+      m: true
+    },
+    {
+      hostProperty: 'hueserver_host',
+      componentName: 'HUE_SERVER',
+      serviceName: 'HUE',
+      serviceUseThis: []
+    },
+    {
+      hostProperty: 'webhcatserver_host',
+      componentName: 'WEBHCAT_SERVER',
+      serviceName: 'WEBHCAT',
+      serviceUseThis: [],
+      m: true
+    },
+    {
+      hostProperty: 'zookeeperserver_hosts',
+      componentName: 'ZOOKEEPER_SERVER',
+      serviceName: 'ZOOKEEPER',
+      serviceUseThis: ['HBASE', 'WEBHCAT'],
+      m: true
+    },
+    {
+      hostProperty: 'stormuiserver_host',
+      componentName: 'STORM_UI_SERVER',
+      serviceName: 'STORM',
+      serviceUseThis: []
+    },
+    {
+      hostProperty: 'drpcserver_host',
+      componentName: 'DRPC_SERVER',
+      serviceName: 'STORM',
+      serviceUseThis: []
+    },
+    {
+      hostProperty: 'storm_rest_api_host',
+      componentName: 'STORM_REST_API',
+      serviceName: 'STORM',
+      serviceUseThis: []
+    },
+    {
+      hostProperty: 'supervisor_hosts',
+      componentName: 'SUPERVISOR',
+      serviceName: 'STORM',
+      serviceUseThis: [],
+      m: true
+    }
+  ],
+
   /**
    * Adds host name of master component to global config;
+   * @method addHostNamesToGlobalConfig
    */
   addHostNamesToGlobalConfig: function () {
     var serviceName = this.get('content.serviceName');
     var globalConfigs = this.get('globalConfigs');
-    var serviceConfigs = this.get('serviceConfigs').findProperty('serviceName', serviceName).configs;
-    var hostComponents = App.HostComponent.find();
     //namenode_host is required to derive "fs.default.name" a property of core-site
-    var nameNodeHost = this.get('serviceConfigs').findProperty('serviceName', 'HDFS').configs.findProperty('name', 'namenode_host');
     try {
-      nameNodeHost.defaultValue = hostComponents.filterProperty('componentName', 'NAMENODE').mapProperty('host.hostName');
-      globalConfigs.push(nameNodeHost);
+      this.setHostForService('HDFS', 'NAMENODE', 'namenode_host', true);
     } catch (err) {
       console.log("No NameNode Host available.  This is expected if you're using GLUSTERFS rather than HDFS.");
     }
 
-    //zooKeeperserver_host
-    var zooKeperHost = this.get('serviceConfigs').findProperty('serviceName', 'ZOOKEEPER').configs.findProperty('name', 'zookeeperserver_hosts');
-    if (serviceName === 'ZOOKEEPER' || serviceName === 'HBASE' || serviceName === 'WEBHCAT') {
-      zooKeperHost.defaultValue = hostComponents.filterProperty('componentName', 'ZOOKEEPER_SERVER').mapProperty('host.hostName');
-      globalConfigs.push(zooKeperHost);
-    }
-
-    switch (serviceName) {
-      case 'HDFS':
-        if (hostComponents.someProperty('componentName', 'SECONDARY_NAMENODE') && hostComponents.findProperty('componentName', 'SECONDARY_NAMENODE').get('workStatus') != 'DISABLED') {
-          var sNameNodeHost = serviceConfigs.findProperty('name', 'snamenode_host');
-          sNameNodeHost.defaultValue = hostComponents.findProperty('componentName', 'SECONDARY_NAMENODE').get('host.hostName');
-          globalConfigs.push(sNameNodeHost);
-        }
-        break;
-      case 'MAPREDUCE':
-        var jobTrackerHost = serviceConfigs.findProperty('name', 'jobtracker_host');
-        jobTrackerHost.defaultValue = hostComponents.findProperty('componentName', 'JOBTRACKER').get('host.hostName');
-        globalConfigs.push(jobTrackerHost);
-      case 'MAPREDUCE2':
-        var historyServerHost = serviceConfigs.findProperty('name', 'hs_host');
-        historyServerHost.defaultValue = hostComponents.findProperty('componentName', 'HISTORYSERVER').get('host.hostName');
-        globalConfigs.push(historyServerHost);
-        break;
-      case 'YARN':
-        var resourceManagerHost = serviceConfigs.findProperty('name', 'rm_host');
-        var ATSHost = this.getMasterComponentHostValue('APP_TIMELINE_SERVER');
-        if (ATSHost) {
-          var ATSProperty = serviceConfigs.findProperty('name', 'ats_host');
-          ATSProperty.defaultValue = ATSHost
-          globalConfigs.push(ATSProperty);
-        }
-        resourceManagerHost.defaultValue = hostComponents.findProperty('componentName', 'RESOURCEMANAGER').get('host.hostName');
-        globalConfigs.push(resourceManagerHost);
-        //yarn.log.server.url config dependent on HistoryServer host
-        if (hostComponents.someProperty('componentName', 'HISTORYSERVER')) {
-          historyServerHost = this.get('serviceConfigs').findProperty('serviceName', 'MAPREDUCE2').configs.findProperty('name', 'hs_host');
-          historyServerHost.defaultValue = hostComponents.findProperty('componentName', 'HISTORYSERVER').get('host.hostName');
-          globalConfigs.push(historyServerHost);
-        }
-        break;
-      case 'HIVE':
-        var hiveMetastoreHost = serviceConfigs.findProperty('name', 'hivemetastore_host');
-        hiveMetastoreHost.defaultValue = hostComponents.findProperty('componentName', 'HIVE_SERVER').get('host.hostName');
-        globalConfigs.push(hiveMetastoreHost);
-        var hiveDb = globalConfigs.findProperty('name', 'hive_database').value;
-        if (['Existing MySQL Database', 'Existing Oracle Database'].contains(hiveDb)) {
-          globalConfigs.findProperty('name', 'hive_hostname').isVisible = true;
-        }
-        break;
-
-      case 'OOZIE':
-        var oozieServerHost = serviceConfigs.findProperty('name', 'oozieserver_host');
-        oozieServerHost.defaultValue = hostComponents.findProperty('componentName', 'OOZIE_SERVER').get('host.hostName');
-        globalConfigs.push(oozieServerHost);
-        var oozieDb = globalConfigs.findProperty('name', 'oozie_database').value;
-        if (['Existing MySQL Database', 'Existing Oracle Database'].contains(oozieDb)) {
-          globalConfigs.findProperty('name', 'oozie_hostname').isVisible = true;
-        }
-        break;
-      case 'HBASE':
-        var hbaseMasterHost = serviceConfigs.findProperty('name', 'hbasemaster_host');
-        hbaseMasterHost.defaultValue = hostComponents.filterProperty('componentName', 'HBASE_MASTER').mapProperty('host.hostName');
-        globalConfigs.push(hbaseMasterHost);
-        break;
-      case 'HUE':
-        var hueServerHost = serviceConfigs.findProperty('name', 'hueserver_host');
-        hueServerHost.defaultValue = hostComponents.findProperty('componentName', 'HUE_SERVER').get('host.hostName');
-        globalConfigs.push(hueServerHost);
-        break;
-      case 'WEBHCAT':
-        var webhcatMasterHost = serviceConfigs.findProperty('name', 'webhcatserver_host');
-        webhcatMasterHost.defaultValue = hostComponents.filterProperty('componentName', 'WEBHCAT_SERVER').mapProperty('host.hostName');
-        globalConfigs.push(webhcatMasterHost);
-        var hiveMetastoreHost = this.get('serviceConfigs').findProperty('serviceName', 'HIVE').configs.findProperty('name', 'hivemetastore_host');
-        hiveMetastoreHost.defaultValue = hostComponents.findProperty('componentName', 'HIVE_SERVER').get('host.hostName');
-        globalConfigs.push(hiveMetastoreHost);
-        break;
-      case 'STORM':
-        var masterHostComponents = [
-          { name: 'STORM_UI_SERVER', propertyName: 'stormuiserver_host' },
-          { name: 'DRPC_SERVER', propertyName: 'drpcserver_host' },
-          { name: 'STORM_REST_API', propertyName: 'storm_rest_api_host' }
-        ];
-
-        masterHostComponents.forEach(function(component) {
-          var hostValue = this.getMasterComponentHostValue(component.name);
-          var config = serviceConfigs.findProperty('name', component.propertyName);
-          config.defaultValue = hostValue;
-          globalConfigs.push(config);
-        }, this);
+    var hostProperties = this.get('hostComponentsmapping').filter(function(h) {
+      return h.serviceUseThis.contains(serviceName) || h.serviceName == serviceName;
+    });
+    hostProperties.forEach(function(h) {
+      this.setHostForService(h.serviceName, h.componentName, h.hostProperty, h.m);
+    }, this);
 
-        var supervisorHosts = hostComponents.filterProperty('componentName','SUPERVISOR').mapProperty('host.hostName');
-        if (supervisorHosts.length > 0) {
-          var supervisorHostsConfig = serviceConfigs.findProperty('name', 'supervisor_hosts');
-          supervisorHostsConfig.defaultValue = supervisorHosts;
-          globalConfigs.push(supervisorHostsConfig);
-        }
-        break;
+    if (serviceName === 'HIVE') {
+      var hiveDb = globalConfigs.findProperty('name', 'hive_database').value;
+      if (['Existing MySQL Database', 'Existing Oracle Database'].contains(hiveDb)) {
+        globalConfigs.findProperty('name', 'hive_hostname').isVisible = true;
+      }
+    }
+    if (serviceName === 'OOZIE') {
+      var oozieDb = globalConfigs.findProperty('name', 'oozie_database').value;
+      if (['Existing MySQL Database', 'Existing Oracle Database'].contains(oozieDb)) {
+        globalConfigs.findProperty('name', 'oozie_hostname').isVisible = true;
+      }
+    }
+  },
+  /**
+   * set host name(s) property for component
+   * @param {String} serviceName - service name of component
+   * @param {String} componentName - component name whic host we want to know
+   * @param {String} hostProperty - name of host property for current component
+   * @param {Boolean} multiple - true if can be more than one component
+   * @method setHostForService
+   */
+  setHostForService: function(serviceName, componentName, hostProperty, multiple) {
+    var globalConfigs = this.get('globalConfigs');
+    var serviceConfigs = this.get('serviceConfigs').findProperty('serviceName', serviceName).configs;
+    var hostConfig = serviceConfigs.findProperty('name', hostProperty);
+    if (hostConfig) {
+      hostConfig.defaultValue = this.getMasterComponentHostValue(componentName, multiple);
+      globalConfigs.push(hostConfig);
     }
   },
 
   /**
    * get hostName of component
    * @param {String} componentName
-   * @return {String} hostName
+   * @param {Boolean} multiple - true if can be more than one component installed on cluster
+   * @return {String|Array|Boolean} hostName|hostNames|false if missing component
    * @method getMasterComponentHostValue
    */
-  getMasterComponentHostValue: function(componentName) {
-    var component = this.get('content.hostComponents').findProperty('componentName', componentName);
-    return component ? component.get('host.hostName') : false;
+  getMasterComponentHostValue: function(componentName, multiple) {
+    var components = this.get('content.hostComponents').filterProperty('componentName', componentName);
+    if (components.length > 0) {
+      return multiple ? components.mapProperty('host.hostName') : components[0].get('host.hostName');
+    }
+    return false;
   },
   /**
    * Provides service component name and display-name information for

ambari-web/test/controllers/main/service/info/config_test.js

@@ -435,26 +435,53 @@ describe("App.MainServiceInfoConfigsController", function () {
   });
 
   describe("#getMasterComponentHostValue", function () {
-    var t = Em.Object.create({
-      content: Em.Object.create({
-        hostComponents: [
-          Em.Object.create({
-            componentName: "componentName2",
-            displayName: "displayName2",
-            host: Em.Object.create({
-              hostName: "hostName"
+    var tests = [
+      {
+        content: {
+          hostComponents: [
+            Em.Object.create({
+              componentName: "componentName1",
+              host: {
+                hostName: "hostName"
+              }
             })
-          })
-        ]
-      })
-    });
-    beforeEach(function () {
-      mainServiceInfoConfigsController.set("content", { hostComponents: Em.A([])});
-    });
+          ]
+        },
+        result: "hostName",
+        multiple: false,
+        m: "returns hostname"
+      },
+      {
+        content: {
+          hostComponents: [
+            Em.Object.create({
+              componentName: "componentName2",
+              host: {
+                  hostName: "hostName1"
+              }
+            }),
+            Em.Object.create({
+              componentName: "componentName2",
+              host: {
+                hostName: "hostName2"
+              }
+            })
+          ]
+        },
+        result: ["hostName1","hostName2"],
+        multiple: true,
+        m: "returns hostnames"
+      }
+    ];
+    tests.forEach(function(t){
+      beforeEach(function () {
+        mainServiceInfoConfigsController.set("content", { hostComponents: []});
+      });
 
-    it("returns hostname", function () {
-      mainServiceInfoConfigsController.get("content.hostComponents").push(t.content.hostComponents[0]);
-      expect(mainServiceInfoConfigsController.getMasterComponentHostValue(t.content.hostComponents[0].componentName)).to.equal(t.content.hostComponents[0].host.hostName);
+      it(t.m, function () {
+        mainServiceInfoConfigsController.set("content.hostComponents", t.content.hostComponents);
+        expect(mainServiceInfoConfigsController.getMasterComponentHostValue(t.content.hostComponents[0].componentName, t.multiple)).to.eql(t.result);
+      });
     });
   });
 
@@ -705,4 +732,494 @@ describe("App.MainServiceInfoConfigsController", function () {
     });
   });
 
+  describe("#addDynamicProperties", function() {
+
+    var tests = [
+      {
+        stepConfigs: [Em.Object.create({
+          serviceName: "WEBHCAT",
+          configs: []
+        })],
+        content: Em.Object.create({
+          serviceName: "WEBHCAT"
+        }),
+        m: "add dynamic property",
+        addDynamic: true
+      },
+      {
+        stepConfigs: [Em.Object.create({
+          serviceName: "WEBHCAT",
+          configs: [
+            Em.Object.create({
+              name: "templeton.hive.properties"
+            })
+          ]
+        })],
+        content: Em.Object.create({
+          serviceName: "WEBHCAT"
+        }),
+        m: "don't add dynamic property (already included)",
+        addDynamic: false
+      },
+      {
+        stepConfigs: [Em.Object.create({
+          serviceName: "HDFS",
+          configs: []
+        })],
+        content: Em.Object.create({
+          serviceName: "HDFS"
+        }),
+        m: "don't add dynamic property (wrong service)",
+        addDynamic: false
+      }
+    ];
+    var dynamicProperty = {
+      "name": "templeton.hive.properties",
+      "templateName": ["hivemetastore_host"],
+      "foreignKey": null,
+      "value": "hive.metastore.local=false,hive.metastore.uris=thrift://<templateName[0]>:9083,hive.metastore.sasl.enabled=yes,hive.metastore.execute.setugi=true,hive.metastore.warehouse.dir=/apps/hive/warehouse",
+      "filename": "webhcat-site.xml"
+    };
+
+
+
+    tests.forEach(function(t) {
+      it(t.m, function() {
+        mainServiceInfoConfigsController.set("content", t.content);
+        mainServiceInfoConfigsController.set("stepConfigs", t.stepConfigs);
+        var configs = [];
+        mainServiceInfoConfigsController.addDynamicProperties(configs);
+        if (t.addDynamic){
+          expect(configs.findProperty("name","templeton.hive.properties")).to.deep.eql(dynamicProperty);
+        }
+      });
+    });
+  });
+
+  describe("#loadUiSideConfigs", function () {
+
+    var t = {
+      configMapping: [
+        {
+          foreignKey: null,
+          templateName: "",
+          value: "default",
+          name: "name1",
+          filename: "filename1"
+        },
+        {
+          foreignKey: "notNull",
+          templateName: "",
+          value: "default2",
+          name: "name2",
+          filename: "filename2"
+        }
+      ],
+      configMappingf: [
+        {
+          foreignKey: null,
+          templateName: "",
+          value: "default",
+          name: "name1",
+          filename: "filename1"
+        }
+      ],
+      valueWithOverrides: {
+        "value": "default",
+        "overrides": {
+          "value1": "value1",
+          "value2": "value2"
+        }
+      },
+      uiConfigs: [
+        {
+          "id": "site property",
+          "name": "name1",
+          "value": "default",
+          "filename": "filename1",
+          "overrides": {
+            "value1": "value1",
+            "value2": "value2"
+          }
+        }
+      ]
+    };
+
+    beforeEach(function(){
+      sinon.stub(mainServiceInfoConfigsController, "addDynamicProperties", Em.K);
+      sinon.stub(mainServiceInfoConfigsController, "getGlobConfigValueWithOverrides", function () {
+        return t.valueWithOverrides
+      });
+    });
+
+    afterEach(function(){
+      mainServiceInfoConfigsController.addDynamicProperties.restore();
+      mainServiceInfoConfigsController.getGlobConfigValueWithOverrides.restore();
+    });
+
+    it("load ui config", function() {
+      expect(mainServiceInfoConfigsController.loadUiSideConfigs(t.configMapping)[0]).to.deep.equal(t.uiConfigs[0]);
+      expect(mainServiceInfoConfigsController.addDynamicProperties.calledWith(t.configMappingf)).to.equal(true);
+    });
+  });
+
+  describe("#formatConfigValues", function () {
+    var t = {
+      configs: [
+        Em.Object.create({ name: "p1", value: " v1 v1 ", displayType: "" }),
+        Em.Object.create({ name: "p2", value: true, displayType: "" }),
+        Em.Object.create({ name: "p3", value: " d1 ", displayType: "directory" }),
+        Em.Object.create({ name: "p4", value: " d1 d2 d3 ", displayType: "directories" }),
+        Em.Object.create({ name: "p5", value: " v1 ", displayType: "password" }),
+        Em.Object.create({ name: "p6", value: " v ", displayType: "host" }),
+        Em.Object.create({ name: "javax.jdo.option.ConnectionURL", value: " v1 ", displayType: "advanced" }),
+        Em.Object.create({ name: "oozie.service.JPAService.jdbc.url", value: " v1 ", displayType: "advanced" })
+      ],
+      result: [
+        Em.Object.create({ name: "p1", value: " v1 v1", displayType: "" }),
+        Em.Object.create({ name: "p2", value: "true", displayType: "" }),
+        Em.Object.create({ name: "p3", value: "d1", displayType: "directory" }),
+        Em.Object.create({ name: "p4", value: "d1,d2,d3", displayType: "directories" }),
+        Em.Object.create({ name: "p5", value: " v1 ", displayType: "password" }),
+        Em.Object.create({ name: "p6", value: "v", displayType: "host" }),
+        Em.Object.create({ name: "javax.jdo.option.ConnectionURL", value: " v1", displayType: "advanced" }),
+        Em.Object.create({ name: "oozie.service.JPAService.jdbc.url", value: " v1", displayType: "advanced" })
+      ]
+    };
+
+    it("format config values", function () {
+      mainServiceInfoConfigsController.formatConfigValues(t.configs);
+      expect(t.configs).to.deep.equal(t.result);
+    });
+
+  });
+
+  describe("#setHostForService", function () {
+    var tests = [
+      {
+        globalConfigs: [],
+        componentName: "ZOOKEEPER_SERVER",
+        serviceName: "ZOOKEEPER",
+        hostProperty: "zookeeperserver_hosts",
+        multiple: true,
+        result: ["hostName1", "hostName2"],
+        serviceConfigs: [
+          {
+            serviceName: "ZOOKEEPER",
+            configs: [
+              {
+                "name": "zookeeperserver_hosts",
+                "defaultValue": null
+              }
+            ]
+          }
+        ],
+        m: "set hostNames to globalConfigs for current service"
+      },
+      {
+        globalConfigs: [],
+        componentName: "STORM_UI_SERVER",
+        serviceName: "STORM",
+        hostProperty: "stormuiserver_host",
+        multiple: false,
+        result: "hostName1",
+        serviceConfigs: [
+          {
+            serviceName: "STORM",
+            configs: [
+              {
+                "name": "stormuiserver_host",
+                "defaultValue": null
+              }
+            ]
+          }
+        ],
+        m: "set hostName to globalConfigs for current service"
+      }
+    ];
+
+    beforeEach(function () {
+      sinon.stub(mainServiceInfoConfigsController, "getMasterComponentHostValue", function (a,m) {
+        if (m) {
+          return ["hostName1", "hostName2"];
+        } else {
+          return "hostName1";
+        }
+      });
+    });
+
+    afterEach(function () {
+      mainServiceInfoConfigsController.getMasterComponentHostValue.restore();
+    });
+
+    tests.forEach(function (t) {
+      it(t.m, function () {
+        mainServiceInfoConfigsController.set("globalConfigs", t.globalConfigs);
+        mainServiceInfoConfigsController.set("serviceConfigs", t.serviceConfigs);
+        mainServiceInfoConfigsController.setHostForService(t.serviceName, t.componentName, t.hostProperty, t.multiple);
+        expect(mainServiceInfoConfigsController.get("globalConfigs").findProperty("name", t.hostProperty).defaultValue).to.eql(t.result);
+
+      });
+    }, this);
+  });
+
+  describe("#addHostNamesToGlobalConfig", function () {
+    var tests = [
+      {
+        globalConfigs: [],
+        serviceName: "ZOOKEEPER",
+        hostProperty: "zookeeperserver_hosts",
+        nameNodeHost: "namenode_host",
+        serviceConfigs: [
+          {
+            serviceName: "ZOOKEEPER",
+            configs: [
+              {
+                "name": "zookeeperserver_hosts",
+                "defaultValue": null
+              },
+              {
+                "name": "namenode_host",
+                "defaultValue": null
+              }
+            ]
+          }
+        ],
+        result: ["hostName1", "hostName2"],
+        result2: ["hostName1", "hostName2"],
+        m: "set hostNames to globalConfigs for required services"
+      },
+      {
+        globalConfigs: [
+          {
+            "name": "hive_database",
+            "value": "Existing MySQL Database"
+          },
+          {
+            "name": "hive_hostname",
+            "isVisible": false
+          }
+        ],
+        serviceName: "HIVE",
+        hostProperty: "hivemetastore_host",
+        nameNodeHost: "namenode_host",
+        isVisible: true,
+        serviceConfigs: [
+          {
+            serviceName: "HIVE",
+            configs: [
+              {
+                "name": "hivemetastore_host",
+                "defaultValue": null
+              },
+              {
+                "name": "namenode_host",
+                "defaultValue": null
+              }
+            ]
+          }
+        ],
+        result: "hostName3",
+        result2: ["hostName1", "hostName2"],
+        m: "set hostNames to globalConfigs for required services and isVisible property for HIVE"
+      }
+    ];
+
+    beforeEach(function () {
+      mainServiceInfoConfigsController.set("content", Em.Object.create({}));
+      sinon.stub(mainServiceInfoConfigsController, "getMasterComponentHostValue", function (a,m) {
+        if (m) {
+          return ["hostName1", "hostName2"];
+        } else {
+          return "hostName3";
+        }
+      });
+    });
+
+    afterEach(function () {
+      mainServiceInfoConfigsController.getMasterComponentHostValue.restore();
+    });
+
+    tests.forEach(function (t) {
+      it(t.m, function () {
+        mainServiceInfoConfigsController.set("content.serviceName", t.serviceName);
+        mainServiceInfoConfigsController.set("globalConfigs", t.globalConfigs);
+        mainServiceInfoConfigsController.set("serviceConfigs", t.serviceConfigs);
+        mainServiceInfoConfigsController.addHostNamesToGlobalConfig();
+        expect(mainServiceInfoConfigsController.get("globalConfigs").findProperty("name", t.hostProperty).defaultValue).to.eql(t.result);
+        expect(mainServiceInfoConfigsController.get("globalConfigs").findProperty("name", t.nameNodeHost).defaultValue).to.eql(t.result2);
+        if (t.serviceName == "HIVE" || t.serviceName == "OOZIE") {
+          expect(mainServiceInfoConfigsController.get("globalConfigs").findProperty("name", t.hostProperty).isVisible).to.eql(t.isVisible);
+        }
+      });
+    }, this);
+  });
+
+  describe("#doPUTClusterConfiguration", function () {
+    var tests = [
+      {
+        configs: {
+          properties: {
+            property1: "1001",
+            property2: "text"
+          }
+        },
+        siteName: "global",
+        r: true,
+        m: "save changed properties"
+      },
+      {
+        configs: {
+          properties: {
+            property1: "1000",
+            property2: "text"
+          }
+        },
+        siteName: "global",
+        r: true,
+        m: "skip saving becouse nothing changed (returns true)"
+      },
+      {
+        configs: {
+          properties: {
+            property1: "1001",
+            property2: "text"
+          },
+          success: false
+        },
+        siteName: "global",
+        r: false,
+        m: "saving failed"
+      }
+    ];
+    var getConfigsByTags = {
+      property1: "1000",
+      property2: "text"
+    }
+    beforeEach(function () {
+      sinon.stub(App.router.get('configurationController'), "getConfigsByTags", function () {
+        return getConfigsByTags
+      });
+      sinon.stub(mainServiceInfoConfigsController, "doPUTClusterConfigurationSite", function (k) {
+        return k.success !== false;
+      });
+    });
+
+    afterEach(function () {
+      mainServiceInfoConfigsController.doPUTClusterConfigurationSite.restore();
+      App.router.get('configurationController').getConfigsByTags.restore();
+    });
+    tests.forEach(function (t) {
+      it(t.m, function () {
+        var siteNameToServerDataMap = {};
+        expect(mainServiceInfoConfigsController.doPUTClusterConfiguration(siteNameToServerDataMap, t.siteName, t.configs)).to.equal(t.r);
+        expect(siteNameToServerDataMap[t.siteName]).to.eql(t.configs);
+      })
+    });
+  });
+
+  describe("#createConfigObject", function() {
+    var tests = [
+      {
+        siteName: "global",
+        method: "createGlobalSiteObj"
+      },
+      {
+        siteName: "core-site",
+        serviceName: "HDFS",
+        method: "createCoreSiteObj"
+      },
+      {
+        siteName: "core-site",
+        serviceName: "ANY",
+        method: false
+      },
+      {
+        siteName: "any",
+        method: "createSiteObj"
+      },
+      {
+        siteName: "mapred-queue-acls",
+        method: false,
+        capacitySchedulerUi: false
+      },
+      {
+        siteName: "mapred-queue-acls",
+        method: "createSiteObj",
+        capacitySchedulerUi: true
+      }
+    ];
+
+    var capacitySchedulerUi = App.supports.capacitySchedulerUi;
+    beforeEach(function() {
+      sinon.stub(mainServiceInfoConfigsController, "createGlobalSiteObj", Em.K);
+      sinon.stub(mainServiceInfoConfigsController, "createCoreSiteObj", Em.K);
+      sinon.stub(mainServiceInfoConfigsController, "createSiteObj", Em.K);
+      mainServiceInfoConfigsController.set("content", {});
+    });
+
+    afterEach(function() {
+      mainServiceInfoConfigsController.createGlobalSiteObj.restore();
+      mainServiceInfoConfigsController.createCoreSiteObj.restore();
+      mainServiceInfoConfigsController.createSiteObj.restore();
+      App.supports.capacitySchedulerUi = capacitySchedulerUi;
+    });
+
+    tests.forEach(function(t) {
+      it("create object for " + t.siteName + " run method " + t.method, function() {
+        App.supports.capacitySchedulerUi = t.capacitySchedulerUi;
+        mainServiceInfoConfigsController.set("content.serviceName", t.serviceName);
+        mainServiceInfoConfigsController.createConfigObject(t.siteName, "versrion1");
+        if (t.method) {
+          expect(mainServiceInfoConfigsController[t.method].calledOnce).to.equal(true);
+        } else {
+          expect(mainServiceInfoConfigsController["createGlobalSiteObj"].calledOnce).to.equal(false);
+          expect(mainServiceInfoConfigsController["createCoreSiteObj"].calledOnce).to.equal(false);
+          expect(mainServiceInfoConfigsController["createSiteObj"].calledOnce).to.equal(false);
+        }
+      });
+    });
+  });
+
+  describe("#doPUTClusterConfigurations", function() {
+
+    var t = {
+     propertyName: "global",
+     properties: {
+       propertu1: "text",
+       property2: 1000
+     },
+     serviceConfigTags: [{
+       siteName: "global",
+       tagName: "version1"
+     }]
+    };
+
+    beforeEach(function() {
+      sinon.stub(mainServiceInfoConfigsController, "createConfigObject", Em.K);
+      sinon.stub(mainServiceInfoConfigsController, "setNewTagNames", Em.K);
+      sinon.stub(mainServiceInfoConfigsController, "doPUTClusterConfiguration", function (siteNameToServerDataMap) {
+        siteNameToServerDataMap[t.propertyName] = t.properties;
+        return true;
+      });
+    });
+
+    afterEach(function() {
+      mainServiceInfoConfigsController.createConfigObject.restore();
+      mainServiceInfoConfigsController.setNewTagNames.restore();
+      mainServiceInfoConfigsController.doPUTClusterConfiguration.restore();
+    });
+
+    it("Saves cluster level configurations", function() {
+      var siteNameToServerDataMap = {};
+      siteNameToServerDataMap[t.propertyName] = t.properties;
+      mainServiceInfoConfigsController.set("serviceConfigTags", t.serviceConfigTags);
+      expect(mainServiceInfoConfigsController.doPUTClusterConfigurations()).to.equal(true);
+      expect(mainServiceInfoConfigsController["createConfigObject"].calledOnce).to.equal(true);
+      expect(mainServiceInfoConfigsController["setNewTagNames"].calledOnce).to.equal(true);
+      expect(mainServiceInfoConfigsController["doPUTClusterConfiguration"].calledOnce).to.equal(true);
+      expect(mainServiceInfoConfigsController.get("savedSiteNameToServerServiceConfigDataMap")).to.eql(siteNameToServerDataMap);
+    });
+
+  });
 });