/**
 * 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('views/common/quick_view_link_view');
var testHelpers = require('test/helpers');

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

  var quickViewLinks = App.QuickLinksView.create({
    content: Em.Object.create()
  });

  describe("#ambariProperties", function () {
    beforeEach(function () {
      sinon.stub(App.router, 'get').returns({p: 1});
    });
    afterEach(function () {
      App.router.get.restore();
    });
    it("ambariProperties are updated", function () {
      expect(quickViewLinks.get('ambariProperties')).to.eql({p: 1});
    });
  });

  describe("#didInsertElement()", function () {
    beforeEach(function () {
      sinon.stub(App.router, 'get').returns({p: 1});
      sinon.stub(quickViewLinks, 'loadQuickLinksConfigurations');
    });
    afterEach(function () {
      App.router.get.restore();
      quickViewLinks.loadQuickLinksConfigurations.restore();
    });
    it("loadQuickLinksConfigurations is called once", function () {
      quickViewLinks.didInsertElement();
      expect(quickViewLinks.loadQuickLinksConfigurations.calledOnce).to.be.true;
    });
  });

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

    beforeEach(function () {
      quickViewLinks.setProperties({
        configProperties: [{}],
        quickLinks: [{}]
      });
      quickViewLinks.willDestroyElement();
    });

    it("configProperties empty", function () {
      expect(quickViewLinks.get('configProperties')).to.be.empty;
    });

    it("quickLinks empty", function () {
      expect(quickViewLinks.get('quickLinks')).to.be.empty;
    });
  });

  describe("#setQuickLinks()", function () {
    beforeEach(function () {
      var mock = {
        done: Em.clb
      };
      sinon.stub(quickViewLinks, 'setConfigProperties').returns(mock);
      sinon.stub(quickViewLinks, 'getQuickLinksHosts');
      sinon.stub(App, 'get').returns(true);
    });
    afterEach(function () {
      quickViewLinks.setConfigProperties.restore();
      quickViewLinks.getQuickLinksHosts.restore();
      App.get.restore();
    });
    it("getQuickLinksHosts should be called", function () {
      quickViewLinks.setQuickLinks();
      expect(quickViewLinks.getQuickLinksHosts.calledOnce).to.be.true;
    });
  });


  describe("#loadQuickLinksConfigSuccessCallback()", function () {
    var mock;

    beforeEach(function () {
      sinon.stub(App.store, 'commit', Em.K);
      mock = sinon.stub(quickViewLinks, 'getQuickLinksConfiguration');
    });
    afterEach(function () {
      App.store.commit.restore();
      mock.restore();
    });
    it("requiredSites consistent", function () {
      var quickLinksConfigHBASE = {
        protocol: {
          type: "http"
        },
        links: [
          {
            port: {
              site: "hbase-site"
            }
          }
        ]
      };
      var quickLinksConfigYARN = {
        protocol: {
          checks: [
            {
              site: "yarn-site"
            }
          ],
          type: "https"
        },
        links: [
          {
            port: {
              site: "yarn-site"
            },
            host: {
              site: "yarn-env"
            }
          }
        ]
      };
      quickViewLinks.set('content.serviceName', 'HBASE');
      mock.returns(quickLinksConfigHBASE);
      quickViewLinks.loadQuickLinksConfigSuccessCallback({items: []});
      quickViewLinks.set('content.serviceName', 'YARN');
      mock.returns(quickLinksConfigYARN);
      quickViewLinks.loadQuickLinksConfigSuccessCallback({items: []});
      expect(quickViewLinks.get('requiredSiteNames')).to.be.eql(["core-site", "hdfs-site", "admin-properties", "hbase-site", "yarn-site", "yarn-env"]);
    });
  });

  describe("#getQuickLinksHosts()", function () {
    beforeEach(function () {
      sinon.stub(App.HostComponent, 'find').returns([
        Em.Object.create({
          componentName: 'HBASE_MASTER',
          hostName: 'host1'
        })
      ]);
      sinon.stub(App.QuickLinksConfig, 'find').returns([
        {
          links: [
            {
              component_name: 'HBASE_MASTER'
            }
          ]
        }
      ]);
    });
    afterEach(function () {
      App.HostComponent.find.restore();
      App.QuickLinksConfig.find.restore();
    });
    it("call $.ajax", function () {
      quickViewLinks.getQuickLinksHosts();
      var args = testHelpers.findAjaxRequest('name', 'hosts.for_quick_links');
      expect(args[0]).exists;
      expect(args[0].sender).to.be.eql(quickViewLinks);
      expect(args[0].data).to.be.eql({
        clusterName: App.get('clusterName'),
        hosts: 'host1',
        urlParams: ''
      });
    });
    it("call $.ajax, HBASE service", function () {
      quickViewLinks.set('content.serviceName', 'HBASE');
      quickViewLinks.getQuickLinksHosts();
      var args = testHelpers.findAjaxRequest('name', 'hosts.for_quick_links');
      expect(args[0]).exists;
      expect(args[0].sender).to.be.eql(quickViewLinks);
      expect(args[0].data).to.be.eql({
        clusterName: App.get('clusterName'),
        hosts: 'host1',
        urlParams: ',host_components/metrics/hbase/master/IsActiveMaster'
      });
    });
  });

  describe("#setQuickLinksSuccessCallback()", function () {
    var getQuickLinks;
    beforeEach(function () {
      this.mock = sinon.stub(quickViewLinks, 'getHosts');
      getQuickLinks = sinon.stub(quickViewLinks, 'getQuickLinksConfiguration');
      getQuickLinks.returns({});
      sinon.stub(quickViewLinks, 'setEmptyLinks');
      sinon.stub(quickViewLinks, 'setSingleHostLinks');
      sinon.stub(quickViewLinks, 'setMultipleHostLinks');
      sinon.stub(quickViewLinks, 'setMultipleGroupLinks');
      quickViewLinks.set('content.quickLinks', []);
    });
    afterEach(function () {
      this.mock.restore();
      getQuickLinks.restore();
      quickViewLinks.setEmptyLinks.restore();
      quickViewLinks.setSingleHostLinks.restore();
      quickViewLinks.setMultipleHostLinks.restore();
      quickViewLinks.setMultipleGroupLinks.restore();
      quickViewLinks.get('masterGroups').clear();
    });
    it("no hosts", function () {
      this.mock.returns([]);
      quickViewLinks.setQuickLinksSuccessCallback();
      expect(quickViewLinks.setEmptyLinks.calledOnce).to.be.true;
    });
    it("has overridden hosts", function () {
      this.mock.returns([]);
      getQuickLinks.returns({ links: [{ host: {site: "yarn-env"} }] });
      quickViewLinks.setQuickLinksSuccessCallback();
      expect(quickViewLinks.setEmptyLinks.calledOnce).to.be.false;
    });
    it("quickLinks is not configured", function () {
      this.mock.returns([{}]);
      quickViewLinks.setQuickLinksSuccessCallback();
      expect(quickViewLinks.setEmptyLinks.calledOnce).to.be.false;
    });
    it("single host", function () {
      this.mock.returns([{hostName: 'host1'}]);
      quickViewLinks.setQuickLinksSuccessCallback();
      expect(quickViewLinks.setSingleHostLinks.calledWith([{hostName: 'host1'}])).to.be.true;
    });
    it("multiple hosts", function () {
      this.mock.returns([{hostName: 'host1'}, {hostName: 'host2'}]);
      quickViewLinks.setQuickLinksSuccessCallback();
      expect(quickViewLinks.setMultipleHostLinks.calledWith(
        [{hostName: 'host1'}, {hostName: 'host2'}]
      )).to.be.true;
    });
    it("multiple grouped hosts", function () {
      this.mock.returns([{hostName: 'host1'}, {hostName: 'host2'}]);
      quickViewLinks.set('masterGroups', [{}, {}]);
      quickViewLinks.setQuickLinksSuccessCallback();
      expect(quickViewLinks.setMultipleGroupLinks.calledWith(
        [{hostName: 'host1'}, {hostName: 'host2'}]
      )).to.be.true;
    });
  });

  describe("#getPublicHostName()", function () {
    it("host present", function () {
      var hosts = [{
        Hosts: {
          host_name: 'host1',
          public_host_name: 'public_name'
        }
      }];
      expect(quickViewLinks.getPublicHostName(hosts, 'host1')).to.equal('public_name');
    });
    it("host absent", function () {
      expect(quickViewLinks.getPublicHostName([], 'host1')).to.be.null;
    });
  });

  describe("#setConfigProperties()", function () {
    beforeEach(function () {
      sinon.stub(App.router.get('configurationController'), 'getCurrentConfigsBySites');
    });
    afterEach(function () {
      App.router.get('configurationController').getCurrentConfigsBySites.restore();
    });
    it("getCurrentConfigsBySites called with correct data", function () {
      quickViewLinks.set('requiredSiteNames', ['hdfs-site']);
      quickViewLinks.setConfigProperties();
      expect(App.router.get('configurationController').getCurrentConfigsBySites.calledWith(['hdfs-site'])).to.be.true;
    });
  });

  describe("#setEmptyLinks()", function () {
    it("empty links are set", function () {
      quickViewLinks.setEmptyLinks();
      expect(quickViewLinks.get('quickLinks')).to.eql([{
        label: quickViewLinks.get('quickLinksErrorMessage'),
      }]);
      expect(quickViewLinks.get('isLoaded')).to.be.true;
    });
  });

  describe("#processOozieHosts()", function () {
    it("host status is valid", function () {
      quickViewLinks.set('content.hostComponents', [Em.Object.create({
        componentName: 'OOZIE_SERVER',
        workStatus: 'STARTED',
        hostName: 'host1'
      })]);
      var host = {hostName: 'host1'};
      quickViewLinks.processOozieHosts([host]);
      expect(host.status).to.equal(Em.I18n.t('quick.links.label.active'));
    });
    it("host status is invalid", function () {
      quickViewLinks.set('content.hostComponents', [Em.Object.create({
        componentName: 'OOZIE_SERVER',
        workStatus: 'INSTALLED',
        hostName: 'host1'
      })]);
      var host = {hostName: 'host1'};
      quickViewLinks.processOozieHosts([host]);
      expect(quickViewLinks.get('quickLinksErrorMessage')).to.equal(Em.I18n.t('quick.links.error.oozie.label'));
    });
  });

  describe("#processHdfsHosts()", function () {
    beforeEach(function () {
      quickViewLinks.set('content.activeNameNodes', []);
      quickViewLinks.set('content.standbyNameNodes', []);
    });
    it("active namenode host", function () {
      quickViewLinks.get('content.activeNameNodes').pushObject(Em.Object.create({hostName: 'host1'}));
      var host = {hostName: 'host1'};
      quickViewLinks.processHdfsHosts([host]);
      expect(host.status).to.equal(Em.I18n.t('quick.links.label.active'));
    });
    it("standby namenode host", function () {
      quickViewLinks.get('content.standbyNameNodes').pushObject(Em.Object.create({hostName: 'host1'}));
      var host = {hostName: 'host1'};
      quickViewLinks.processHdfsHosts([host]);
      expect(host.status).to.equal(Em.I18n.t('quick.links.label.standby'));
    });
  });

  describe("#processHbaseHosts()", function () {
    it("isActiveMaster is true", function () {
      var response = {
        items: [
          {
            Hosts: {
              host_name: 'host1'
            },
            host_components: [
              {
                HostRoles: {
                  component_name: 'HBASE_MASTER'
                },
                metrics: {
                  hbase: {
                    master: {
                      IsActiveMaster: 'true'
                    }
                  }
                }
              }
            ]
          }
        ]
      };
      var host = {hostName: 'host1'};
      quickViewLinks.processHbaseHosts([host], response);
      expect(host.status).to.equal(Em.I18n.t('quick.links.label.active'));
    });
    it("isActiveMaster is false", function () {
      var response = {
        items: [
          {
            Hosts: {
              host_name: 'host1'
            },
            host_components: [
              {
                HostRoles: {
                  component_name: 'HBASE_MASTER'
                },
                metrics: {
                  hbase: {
                    master: {
                      IsActiveMaster: 'false'
                    }
                  }
                }
              }
            ]
          }
        ]
      };
      var host = {hostName: 'host1'};
      quickViewLinks.processHbaseHosts([host], response);
      expect(host.status).to.equal(Em.I18n.t('quick.links.label.standby'));
    });
    it("isActiveMaster is undefined", function () {
      var response = {
        items: [
          {
            Hosts: {
              host_name: 'host1'
            },
            host_components: [
              {
                HostRoles: {
                  component_name: 'HBASE_MASTER'
                }
              }
            ]
          }
        ]
      };
      var host = {hostName: 'host1'};
      quickViewLinks.processHbaseHosts([host], response);
      expect(host.status).to.be.undefined;
    });
  });

  describe("#processYarnHosts()", function () {
    it("haStatus is ACTIVE", function () {
      quickViewLinks.set('content.hostComponents', [Em.Object.create({
        componentName: 'RESOURCEMANAGER',
        hostName: 'host1',
        haStatus: 'ACTIVE'
      })]);
      var host = {hostName: 'host1'};
      quickViewLinks.processYarnHosts([host]);
      expect(host.status).to.equal(Em.I18n.t('quick.links.label.active'));
    });
    it("haStatus is STANDBY", function () {
      quickViewLinks.set('content.hostComponents', [Em.Object.create({
        componentName: 'RESOURCEMANAGER',
        hostName: 'host1',
        haStatus: 'STANDBY'
      })]);
      var host = {hostName: 'host1'};
      quickViewLinks.processYarnHosts([host]);
      expect(host.status).to.equal(Em.I18n.t('quick.links.label.standby'));
    });
    it("haStatus is undefined", function () {
      quickViewLinks.set('content.hostComponents', [Em.Object.create({
        componentName: 'RESOURCEMANAGER',
        hostName: 'host1'
      })]);
      var host = {hostName: 'host1'};
      quickViewLinks.processYarnHosts([host]);
      expect(host.status).to.be.undefined;
    });
  });

  describe("#findHosts()", function () {
    beforeEach(function () {
      sinon.stub(quickViewLinks, 'getPublicHostName').returns('public_name');
      sinon.stub(App.MasterComponent, 'find').returns([
        Em.Object.create({
          componentName: "C1",
          hostNames: ["host1", "host2"]
        })
      ]);
    });
    afterEach(function () {
      quickViewLinks.getPublicHostName.restore();
      App.MasterComponent.find.restore();
    });
    it("public_name from getPublicHostName", function () {
      expect(quickViewLinks.findHosts('C1', {})).to.eql([
        {
          hostName: 'host1',
          publicHostName: 'public_name',
          componentName: 'C1'
        },
        {
          hostName: 'host2',
          publicHostName: 'public_name',
          componentName: 'C1'
        }
      ]);
    });
  });

  describe('#setProtocol', function () {
    var tests = [
      //Yarn
      {
        serviceName: "YARN",
        configProperties: [
          {type: 'yarn-site', properties: {'yarn.http.policy': 'HTTPS_ONLY'}}
        ],
        quickLinksConfig: {
          protocol:{
            type:"https",
            checks:[
              {property:"yarn.http.policy",
                desired:"HTTPS_ONLY",
                site:"yarn-site"}
            ]
          }
        },
        m: "https for yarn (checks for https passed)",
        result: "https"
      },
      {
        serviceName: "YARN",
        configProperties: [
          {type: 'yarn-site', properties: {'yarn.http.policy': 'HTTP_ONLY'}}
        ],
        quickLinksConfig: {
          protocol:{
            type:"http",
            checks:[
              {property:"yarn.http.policy",
                desired:"HTTP_ONLY",
                site:"yarn-site"}
            ]
          }
        },
        m: "http for yarn (checks for http passed)",
        result: "http"
      },
      {
        serviceName: "YARN",
        configProperties: [
          {type: 'yarn-site', properties: {'yarn.http.policy': 'HTTP_ONLY'}}
        ],
        quickLinksConfig: {
          protocol:{
            type:"https",
            checks:[
              {property:"yarn.http.policy",
                desired:"HTTPS_ONLY",
                site:"yarn-site"}
            ]
          }
        },
        m: "http for yarn (checks for https did not pass)",
        result: "http"
      },
      {
        serviceName: "YARN",
        configProperties: [
          {type: 'yarn-site', properties: {'yarn.http.policy': 'HTTPS_ONLY'}}
        ],
        quickLinksConfig: {
          protocol:{
            type:"http",
            checks:[
              {property:"yarn.http.policy",
                desired:"HTTP_ONLY",
                site:"yarn-site"}
            ]
          }
        },
        m: "https for yarn (checks for http did not pass)",
        result: "https"
      },
      {
        serviceName: "YARN",
        configProperties: [
          {type: 'yarn-site', properties: {'yarn.http.policy': 'HTTP_ONLY'}}
        ],
        quickLinksConfig: {
          protocol:{
            type:"HTTP_ONLY",
            checks:[
              {property:"yarn.http.policy",
                desired:"HTTPS_ONLY",
                site:"yarn-site"}
            ]
          }
        },
        m: "http for yarn (override checks with specific protocol type)",
        result: "http"
      },
      {
        serviceName: "YARN",
        configProperties: [
          {type: 'yarn-site', properties: {'yarn.http.policy': 'HTTPS_ONLY'}}
        ],
        quickLinksConfig: {
          protocol:{
            type:"HTTPS_ONLY",
            checks:[
              {property:"yarn.http.policy",
                desired:"HTTPS_ONLY",
                site:"yarn-site"}
            ]
          }
        },
        m: "https for yarn (override checks with specific protocol type)",
        result: "https"
      },
      //Any service - override hadoop.ssl.enabled
      {
        serviceName: "MyService",
        configProperties: [
          {type: 'myservice-site', properties: {'myservice.http.policy': 'HTTPS_ONLY'}},
          {type: 'hdfs-site', properties: {'dfs.http.policy':'HTTP_ONLY'}}
        ],
        quickLinksConfig: {
          protocol:{
            type:"https",
            checks:[
              {property:"myservice.http.policy",
                desired:"HTTPS_ONLY",
                site:"myservice-site"}
            ]
          }
        },
        m: "https for MyService (checks for https passed, override hadoop.ssl.enabled)",
        result: "https"
      },
      //Oozie
      {
        serviceName: "OOZIE",
        configProperties: [
          {type: 'oozie-site', properties: {'oozie.https.port': '12345', 'oozie.https.keystore.file':'/tmp/oozie.jks', 'oozie.https.keystore.pass':'mypass'}}
        ],
        quickLinksConfig: {
          protocol:{
            type:"HTTPS",
            checks:
              [
                {
                  "property":"oozie.https.port",
                  "desired":"EXIST",
                  "site":"oozie-site"
                },
                {
                  "property":"oozie.https.keystore.file",
                  "desired":"EXIST",
                  "site":"oozie-site"
                },
                {
                  "property":"oozie.https.keystore.pass",
                  "desired":"EXIST",
                  "site":"oozie-site"
                }
              ]
          }
        },
        m: "https for oozie (checks for https passed)",
        result: "https"
      },
      {
        serviceName: "OOZIE",
        configProperties: [
          {type: 'oozie-site', properties: {"oozie.base.url":"http://c6401.ambari.apache.org:11000/oozie"}}
        ],
        quickLinksConfig: {
          protocol:{
            type:"https",
            checks:
              [
                {
                  "property":"oozie.https.port",
                  "desired":"EXIST",
                  "site":"oozie-site"
                },
                {
                  "property":"oozie.https.keystore.file",
                  "desired":"EXIST",
                  "site":"oozie-site"
                },
                {
                  "property":"oozie.https.keystore.pass",
                  "desired":"EXIST",
                  "site":"oozie-site"
                }
              ]
          }
        },
        m: "http for oozie (checks for https did not pass)",
        result: "http"
      },
      //Ranger: HDP 2.2
      {
        serviceName: "RANGER",
        configProperties: [{type: 'ranger-site', properties: {'http.enabled': 'false'}}],
        quickLinksConfig: {
          protocol:{
            type:"https",
            checks:
              [
                {
                  "property":"http.enabled",
                  "desired":"false",
                  "site":"ranger-site"
                }
              ]
          }
        },
        m: "https for ranger (HDP2.2, checks passed)",
        result: "https"
      },
      {
        serviceName: "RANGER",
        configProperties: [{type: 'ranger-site', properties: {'http.enabled': 'true'}}],
        quickLinksConfig: {
          protocol:{
            type:"HTTPS",
            checks:
              [
                {
                  "property":"http.enabled",
                  "desired":"false",
                  "site":"ranger-site"
                }
              ]
          }
        },
        m: "http for ranger (HDP2.2, checks for https did not pass)",
        result: "http"
      },
      //Ranger: HDP 2.3
      {
        serviceName: "RANGER",
        configProperties:
          [
            {
              type: 'ranger-admin-site',
              properties: {'ranger.service.http.enabled': 'false', 'ranger.service.https.attrib.ssl.enabled': 'true'}
            }
          ],
        quickLinksConfig: {
          protocol:{
            type:"https",
            checks:
              [
                {
                  "property":"ranger.service.http.enabled",
                  "desired":"false",
                  "site":"ranger-admin-site"
                },
                {
                  "property":"ranger.service.https.attrib.ssl.enabled",
                  "desired":"true",
                  "site":"ranger-admin-site"
                }
              ]
          }
        },

        m: "https for ranger (HDP2.3, checks passed)",
        result: "https"
      },
      {
        serviceName: "RANGER",
        configProperties:
          [
            {
              type: 'ranger-admin-site',
              properties: {'ranger.service.http.enabled': 'true', 'ranger.service.https.attrib.ssl.enabled': 'false'}
            }
          ],
        quickLinksConfig: {
          protocol:{
            type:"https",
            checks:
              [
                {
                  "property":"ranger.service.http.enabled",
                  "desired":"false",
                  "site":"ranger-admin-site"
                },
                {
                  "property":"ranger.service.https.attrib.ssl.enabled",
                  "desired":"true",
                  "site":"ranger-admin-site"
                }
              ]
          }
        },
        m: "http for ranger (HDP2.3, checks for https did not pass)",
        result: "http"
      }
    ];

    tests.forEach(function (t) {
      it(t.m, function () {
        quickViewLinks.set('servicesSupportsHttps', t.servicesSupportsHttps);
        expect(quickViewLinks.setProtocol(t.configProperties, t.quickLinksConfig.protocol)).to.equal(t.result);
      });
    });
  });

  describe('#resolvePlaceholders', function() {
    beforeEach(function() {
      quickViewLinks.setProperties({
      configProperties: [{
          'type': 'config-type1',
          'properties': {'property1': 'value1'}
        }],
        actualTags: [""],
        quickLinks: [{}]
      });
    }),
    it("replaces placeholders from config", function () {
      expect(quickViewLinks.resolvePlaceholders('${config-type1/property1}')).to.equal('value1');
    }),
    it("leaves url as it is if config-type was not found", function () {
      expect(quickViewLinks.resolvePlaceholders('${unknown-config-type/property1}')).to.equal('${unknown-config-type/property1}');
    }),
    it("leaves url as it is if property was not found", function () {
      expect(quickViewLinks.resolvePlaceholders('${config-type1/unknown-property}')).to.equal('${config-type1/unknown-property}');
    })
  }),

  describe('#setPort', function () {
    var testData = [
      Em.Object.create({
        'protocol': 'http',
        'port':{
          'http_property':'yarn.timeline-service.webapp.address',
          'http_default_port':'8188',
          'https_property':'yarn.timeline-service.webapp.https.address',
          'https_default_port':'8090',
          'regex': '\\w*:(\\d+)',
          'site':'yarn-site'
        },
        'configProperties':
          [
            {
              'type': 'yarn-site',
              'properties': {'yarn.timeline-service.webapp.address': 'c6401.ambari.apache.org:8188'}
            }
          ],
        'result': '8188'
      }),

      Em.Object.create({
        'protocol': 'https',
        'port':{
          'http_property':'yarn.timeline-service.webapp.address',
          'http_default_port':'8188',
          'https_property':'yarn.timeline-service.webapp.https.address',
          'https_default_port':'8090',
          'regex': '\\w*:(\\d+)',
          'site':'yarn-site'
        },
        'configProperties':
          [
            {
              'type': 'yarn-site',
              'properties': {'yarn.timeline-service.webapp.https.address': 'c6401.ambari.apache.org:8090'}
            }
          ],
        'result': '8090'
      }),

      Em.Object.create({
        'protocol': 'https',
        'port':{
          'http_property':'oozie.base.url',
          'http_default_port':'11000',
          'https_property':'oozie.https.port',
          'https_default_port':'11443',
          'regex': '\\w*:(\\d+)',
          'https_regex': '(\\d+)',
          'site':'oozie-site'
        },
        'configProperties':
          [
            {
              'type': 'oozie-site',
              'properties':
                {
                  'oozie.base.url': 'c6401.ambari.apache.org:11000/oozie',
                  'oozie.https.port' : '11444'
                }
            }
          ],
        'result': '11444'
      }),

      Em.Object.create({
        'protocol': 'http',
        'port':{
          'http_property':'oozie.base.url',
          'http_default_port':'11000',
          'https_property':'oozie.https.port',
          'https_default_port':'11443',
          'regex': '\\w*:(\\d+)',
          'https_regex': '(\\d+)',
          'site':'oozie-site'
        },
        'configProperties':
          [
            {
              'type': 'oozie-site',
              'properties':
                {
                  'oozie.base.url': 'c6401.ambari.apache.org:11002/oozie',
                  'oozie.https.port' : '11444'
                }
            }
          ],
        'result': '11002'
      })
    ];

    after(function () {
      quickViewLinks.set('configProperties', []);
    });

    testData.forEach(function (item) {
      it(item.service_id + ' ' + item.protocol, function () {
        quickViewLinks.set('configProperties', item.configProperties || []);
        expect(quickViewLinks.setPort(item.port, item.protocol, item.configProperties)).to.equal(item.result);
      })
    }, this);
  });

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

    beforeEach(function() {
      sinon.stub(quickViewLinks, 'processOozieHosts').returns(['oozieHost']);
      sinon.stub(quickViewLinks, 'processHdfsHosts').returns(['hdfsHost']);
      sinon.stub(quickViewLinks, 'processHbaseHosts').returns(['hbaseHost']);
      sinon.stub(quickViewLinks, 'processYarnHosts').returns(['yarnHost']);
      sinon.stub(quickViewLinks, 'findHosts').returns(['host1']);
      sinon.stub(App.QuickLinksConfig, 'find').returns([
        Em.Object.create({
          id: 'OOZIE',
          links: [
            {
              component_name: 'OOZIE_SERVER'
            }
          ]
        }),
        Em.Object.create({
          id: 'HDFS',
          links: [
            {
              component_name: 'NAMENODE'
            }
          ]
        }),
        Em.Object.create({
          id: 'HBASE',
          links: [
            {
              component_name: 'HBASE_MASTER'
            }
          ]
        }),
        Em.Object.create({
          id: 'YARN',
          links: [
            {
              component_name: 'RESOURCEMANAGER'
            }
          ]
        }),
        Em.Object.create({
          id: 'STORM',
          links: [
            {
              component_name: 'STORM_UI_SERVER'
            }
          ]
        }),
        Em.Object.create({
          id: 'ACCUMULO',
          links: [
            {
              component_name: 'ACCUMULO_MONITOR'
            }
          ]
        }),
        Em.Object.create({
          id: 'ATLAS',
          links: [
            {
              component_name: 'ATLAS_SERVER'
            }
          ]
        }),
        Em.Object.create({
          id: 'MAPREDUCE2',
          links: [
            {
              component_name: 'HISTORYSERVER'
            }
          ]
        }),
        Em.Object.create({
          id: 'AMBARI_METRICS',
          links: [
            {
              component_name: 'METRICS_GRAFANA'
            }
          ]
        }),
        Em.Object.create({
          id: 'LOGSEARCH',
          links: [
            {
              component_name: 'LOGSEARCH_SERVER'
            }
          ]
        }),
        Em.Object.create({
          id: 'HIVE',
          links: [
            {
              component_name: 'METRICS_GRAFANA'
            },
            {
              component_name: 'HIVE_SERVER_INTERACTIVE'
            }
          ]
        })
      ]);
    });
    afterEach(function() {
      quickViewLinks.processOozieHosts.restore();
      quickViewLinks.processHdfsHosts.restore();
      quickViewLinks.processHbaseHosts.restore();
      quickViewLinks.findHosts.restore();
      quickViewLinks.processYarnHosts.restore();
      App.QuickLinksConfig.find.restore();
    });

    var tests = [
      {
        serviceName: 'OOZIE',
        callback: 'processOozieHosts',
        result: ['oozieHost']
      },
      {
        serviceName: 'HDFS',
        callback: 'processHdfsHosts',
        result: ['hdfsHost']
      },
      {
        serviceName: 'HBASE',
        callback: 'processHbaseHosts',
        result: ['hbaseHost']
      },
      {
        serviceName: 'YARN',
        callback: 'processYarnHosts',
        result: ['yarnHost']
      },
      {
        serviceName: 'STORM'
      },
      {
        serviceName: 'ACCUMULO'
      },
      {
        serviceName: 'ATLAS'
      },
      {
        serviceName: 'MAPREDUCE2'
      },
      {
        serviceName: 'AMBARI_METRICS'
      },
      {
        serviceName: 'LOGSEARCH'
      },
      {
        serviceName: 'HIVE',
        result: ['host1', 'host1']
      }
    ];

    tests.forEach(function (_test) {
      var serviceName = _test.serviceName;
      describe(serviceName, function () {
        var componentNames;

        beforeEach(function () {
          componentNames = App.QuickLinksConfig.find().findProperty('id', serviceName).get('links').mapProperty('component_name');
          this.result = quickViewLinks.getHosts({}, serviceName);
        });

        it('hosts', function () {
          expect(this.result).to.be.eql(_test.result || ['host1']);
        });

        it('components', function () {
          expect(quickViewLinks.findHosts.callCount).to.be.equal(componentNames.length);
        });

        if (_test.callback) {
          it('callback is called once', function () {
            expect(quickViewLinks[_test.callback].calledOnce).to.be.true;
          });
        }
      });
    });

    it("custom service without master", function() {
      expect(quickViewLinks.getHosts({}, 'S1')).to.be.empty;
    });
  });

  describe('#reverseType', function () {

    Em.A([
      {
        input: 'https',
        output: 'http'
      },
      {
        input: 'http',
        output: 'https'
      },
      {
        input: 'some',
        output: ''
      }
    ]).forEach(function (test) {
      it(JSON.stringify(test.input) + ' -> ' + JSON.stringify(test.output), function () {
        expect(quickViewLinks.reverseType(test.input)).to.be.equal(test.output)
      });
    });

  });

  describe('#meetDesired', function () {

    var configProperties = [
      {type: 't1', properties: {p1: 1234, p2: null, p3: 'CUSTOM'}}
    ];

    it('no needed config property', function () {
      expect(quickViewLinks.meetDesired([], '', '', '')).to.be.false;
    });

    it('desiredState is `NOT_EXIST` and currentPropertyValue is null', function () {
      expect(quickViewLinks.meetDesired(configProperties, 't1', 'p2', 'NOT_EXIST')).to.be.true;
    });

    it('desiredState is `NOT_EXIST` and currentPropertyValue is not null', function () {
      expect(quickViewLinks.meetDesired(configProperties, 't1', 'p1', 'NOT_EXIST')).to.be.false;
    });

    it('desiredState is `EXIST` and currentPropertyValue is null', function () {
      expect(quickViewLinks.meetDesired(configProperties, 't1', 'p2', 'EXIST')).to.be.false;
    });

    it('desiredState is `EXIST` and currentPropertyValue is not null', function () {
      expect(quickViewLinks.meetDesired(configProperties, 't1', 'p1', 'EXIST')).to.be.true;
    });

    it('desiredState is `CUSTOM` and currentPropertyValue is `CUSTOM`', function () {
      expect(quickViewLinks.meetDesired(configProperties, 't1', 'p3', 'CUSTOM')).to.be.true;
    });

    it('desiredState is `CUSTOM` and currentPropertyValue is not `CUSTOM`', function () {
      expect(quickViewLinks.meetDesired(configProperties, 't1', 'p2', 'CUSTOM')).to.be.false;
    });

  });

});