ambari-web/test/views/main/host/combo_search_box_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');
var view;

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

  beforeEach(function () {
    view = App.MainHostComboSearchBoxView.create({
      parentView: Em.Object.create(),
      controller: Em.Object.create({
        isComponentStateFacet: Em.K,
        isComplexHealthStatusFacet: Em.K
      })
    });
    window.visualSearch = {
      searchQuery: {
        values: function() {
          return [];
        },
        toJSON: Em.K
      },
      searchBox: {
        setQuery: Em.K
      }
    }
  });

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

    beforeEach(function() {
      sinon.stub(view, 'initVS');
      sinon.stub(view, 'showHideClearButton');
      sinon.stub(view, 'restoreComboFilterQuery');
      view.didInsertElement();
    });
    afterEach(function() {
      view.initVS.restore();
      view.showHideClearButton.restore();
      view.restoreComboFilterQuery.restore();
    });

    it("initVS should be called", function() {
      expect(view.initVS.calledOnce).to.be.true;
    });

    it("showHideClearButton should be called", function() {
      expect(view.showHideClearButton.calledOnce).to.be.true;
    });

    it("restoreComboFilterQuery should be called", function() {
      expect(view.restoreComboFilterQuery.calledOnce).to.be.true;
    });
  });

  describe("#setupLabelMap", function () {

    beforeEach(function() {
      sinon.stub(view, 'setupLabelMap');
      sinon.stub(VS, 'init').returns({init: 'init'});
      view.initVS();
    });

    afterEach(function() {
      view.setupLabelMap.restore();
      VS.init.restore();
    });

    it("setupLabelMap should be called", function() {
      expect(view.setupLabelMap.calledOnce).to.be.true;
    });

    it("window.visualSearch should be set", function() {
      expect(window.visualSearch).to.be.eql({init: 'init'});
    });
  });

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

    beforeEach(function() {
      view.set('parentView', Em.Object.create({
        updateComboFilter: Em.K,
        controller: {name: 'ctrl1'}
      }));
      sinon.stub(view.get('parentView'), 'updateComboFilter');
      sinon.stub(view, 'createFilterConditions').returns([{}]);
      sinon.stub(App.db, 'setComboSearchQuery');
    });

    afterEach(function() {
      App.db.setComboSearchQuery.restore();
      view.createFilterConditions.restore();
      view.get('parentView').updateComboFilter.restore();
    });

    it("App.db.setComboSearchQuery should be called", function() {
      view.search('query', {});
      expect(App.db.setComboSearchQuery.calledWith('ctrl1', 'query')).to.be.true;
    });

    it("updateComboFilter should be called", function() {
      view.search('query', {});
      expect(view.get('parentView').updateComboFilter.calledWith([{}])).to.be.true;
    });
  });

  describe("#facetMatches()", function () {
    var container = {
      callback: Em.K
    };

    beforeEach(function() {
      sinon.stub(view, 'showHideClearButton');
      sinon.stub(view, 'getHostComponentList').returns([
        Em.Object.create({componentName: 'C1'})
      ]);
      this.mock = sinon.stub(view, 'getComponentStateFacets').returns([]);
      sinon.stub(view, 'filterOutOneFacetOnlyOptions', function(list) {
        return list;
      });
      sinon.stub(container, 'callback');
    });

    afterEach(function() {
      view.showHideClearButton.restore();
      view.getHostComponentList.restore();
      this.mock.restore();
      view.filterOutOneFacetOnlyOptions.restore();
      container.callback.restore();
    });

    it("showHideClearButton should be called", function() {
      view.facetMatches(container.callback);
      expect(view.showHideClearButton.calledOnce).to.be.true;
    });

    it("callback should be called", function() {
      view.facetMatches(container.callback);
      expect(container.callback.calledWith(
        [
          {label: 'Host Name', category: 'Host'},
          {label: 'IP', category: 'Host'},
          {label: 'Host Status', category: 'Host'},
          {label: 'Cores', category: 'Host'},
          {label: 'RAM', category: 'Host'},
          {label: 'Stack Version', category: 'Host'},
          {label: 'Version State', category: 'Host'},
          {label: 'Rack', category: 'Host'},
          {label: 'Service', category: 'Service'},
          Em.Object.create({componentName: 'C1'})
        ],
        {preserveOrder: true}
      )).to.be.true;
    });

    it("callback should be called, facets not empty", function() {
      this.mock.returns([{}]);
      view.facetMatches(container.callback);
      expect(container.callback.calledWith(
        [
          {label: 'Host Name', category: 'Host'},
          {label: 'IP', category: 'Host'},
          {label: 'Host Status', category: 'Host'},
          {label: 'Cores', category: 'Host'},
          {label: 'RAM', category: 'Host'},
          {label: 'Stack Version', category: 'Host'},
          {label: 'Version State', category: 'Host'},
          {label: 'Rack', category: 'Host'},
          {label: 'Service', category: 'Service'}
        ],
        {preserveOrder: true}
      )).to.be.true;
    });
  });

  describe("#valueMatches()", function () {
    var controller = {
      isComponentStateFacet: Em.K
    };
    var container = {
      callback: Em.K
    };

    beforeEach(function() {
      sinon.stub(view, 'showHideClearButton');
      this.mockRouter = sinon.stub(App.router, 'get');
      this.mockRouter.withArgs('mainHostComboSearchBoxController').returns(controller);
      this.mockRouter.withArgs('mainHostController.labelValueMap').returns({
        key1: 'hostName'
      });
      this.mockIsComp = sinon.stub(controller, 'isComponentStateFacet').returns(false);
      sinon.stub(container, 'callback');
      sinon.stub(view, 'searchByHostname');
      sinon.stub(view, 'searchByRack');
      sinon.stub(view, 'searchByVersion');
      sinon.stub(view, 'searchByVersionState');
      sinon.stub(view, 'searchByHealthClass');
      sinon.stub(view, 'searchByServices');
      sinon.stub(view, 'searchByComponentState');
    });

    afterEach(function() {
      view.showHideClearButton.restore();
      this.mockRouter.restore();
      this.mockIsComp.restore();
      container.callback.restore();
      view.searchByHostname.restore();
      view.searchByRack.restore();
      view.searchByVersion.restore();
      view.searchByVersionState.restore();
      view.searchByHealthClass.restore();
      view.searchByServices.restore();
      view.searchByComponentState.restore();
    });

    it("showHideClearButton should be called", function() {
      view.valueMatches('', '', container.callback);
      expect(view.showHideClearButton.calledOnce).to.be.true;
    });

    it("searchByHostname should be called", function() {
      view.valueMatches('key1', 'term1', container.callback);
      expect(view.searchByHostname.calledWith(
        'hostName', 'term1', 'key1', container.callback
      )).to.be.true;
    });

    it("searchByRack should be called", function() {
      view.valueMatches('rack', 'term1', container.callback);
      expect(view.searchByRack.calledWith('rack', container.callback)).to.be.true;
    });

    it("searchByVersion should be called", function() {
      view.valueMatches('version', 'term1', container.callback);
      expect(view.searchByVersion.calledWith('version', container.callback)).to.be.true;
    });

    it("searchByVersionState should be called", function() {
      view.valueMatches('versionState', 'term1', container.callback);
      expect(view.searchByVersionState.calledWith('versionState', container.callback, {
        key1: 'hostName'
      })).to.be.true;
    });

    it("searchByHealthClass should be called", function() {
      view.valueMatches('healthClass', 'term1', container.callback);
      expect(view.searchByHealthClass.calledWith('healthClass', container.callback, {
        key1: 'hostName'
      })).to.be.true;
    });

    it("searchByServices should be called", function() {
      view.valueMatches('services', 'term1', container.callback);
      expect(view.searchByServices.calledWith('services', container.callback)).to.be.true;
    });

    it("searchByComponentState should be called", function() {
      this.mockIsComp.returns(true);
      view.valueMatches('componentState', 'term1', container.callback);
      expect(view.searchByComponentState.calledWith('componentState', container.callback, {
        key1: 'hostName'
      })).to.be.true;
    });
  });

  describe("#searchByHostname()", function () {
    var controller = Em.Object.create({
      getPropertySuggestions: Em.K,
      currentSuggestion: ['sg1', 'sg2']
    });
    var container = {
      callback: Em.K
    };


    beforeEach(function() {
      sinon.stub(App.router, 'get').returns(controller);
      sinon.stub(controller, 'getPropertySuggestions').returns({
        done: function(callback) {
          callback();
        }
      });
      sinon.stub(container, 'callback');
      sinon.stub(visualSearch.searchQuery, 'values').returns(['sg1']);
    });

    afterEach(function() {
      App.router.get.restore();
      controller.getPropertySuggestions.restore();
      container.callback.restore();
      visualSearch.searchQuery.values.restore();
    });

    it("callback should be called", function() {
      view.searchByHostname('fv1', 'term1', 'f1', container.callback);
      expect(container.callback.calledWith(['sg2'], {preserveMatches: true})).to.be.true;
    });
  });

  describe("#searchByRack()", function () {
    var container = {
      callback: Em.K
    };

    beforeEach(function() {
      sinon.stub(container, 'callback');
      sinon.stub(visualSearch.searchQuery, 'values').returns(['r1']);
      sinon.stub(App.Host, 'find').returns([{rack: 'r1'}, {rack: 'r2'}]);
    });

    afterEach(function() {
      container.callback.restore();
      visualSearch.searchQuery.values.restore();
      App.Host.find.restore();
    });

    it("callback should be called", function() {
      view.searchByRack('f1', container.callback);
      expect(container.callback.calledWith(['r2'])).to.be.true;
    });
  });

  describe("#searchByVersion()", function () {
    var container = {
      callback: Em.K
    };

    beforeEach(function() {
      sinon.stub(container, 'callback');
      sinon.stub(visualSearch.searchQuery, 'values').returns(['v1']);
      sinon.stub(App.HostStackVersion, 'find').returns([
        {
          isVisible: true,
          displayName: 'v1'
        },
        {
          isVisible: true,
          displayName: 'v2'
        },
        {
          isVisible: false,
          displayName: 'v3'
        }
      ]);
    });

    afterEach(function() {
      container.callback.restore();
      visualSearch.searchQuery.values.restore();
      App.HostStackVersion.find.restore();
    });

    it("callback should be called", function() {
      view.searchByVersion('f1', container.callback);
      expect(container.callback.calledWith(['v2'])).to.be.true;
    });
  });

  describe("#searchByVersionState()", function () {
    var container = {
      callback: Em.K
    };

    beforeEach(function() {
      sinon.stub(container, 'callback');
      sinon.stub(visualSearch.searchQuery, 'values').returns(['INSTALLED']);
      sinon.stub(App.HostStackVersion, 'formatStatus', function(status) {
        return status;
      });
    });

    afterEach(function() {
      container.callback.restore();
      visualSearch.searchQuery.values.restore();
      App.HostStackVersion.formatStatus.restore();
    });

    it("callback should be called", function() {
      view.searchByVersionState('f1', container.callback, {});
      expect(container.callback.getCall(0).args[0]).to.be.eql([
        "INSTALLING",
        "INSTALL_FAILED",
        "OUT_OF_SYNC",
        "CURRENT",
        "UPGRADING",
        "UPGRADE_FAILED"
      ]);
    });
  });

  describe("#searchByHealthClass()", function () {
    var container = {
      callback: Em.K
    };

    beforeEach(function() {
      sinon.stub(container, 'callback');
      sinon.stub(visualSearch.searchQuery, 'values').returns(['c1']);
      view.set('healthStatusCategories', [
        {value: 'All'},
        {value: 'c1'},
        {value: 'c2'}
      ]);
    });

    afterEach(function() {
      container.callback.restore();
      visualSearch.searchQuery.values.restore();
    });

    it("callback should be called", function() {
      view.searchByHealthClass('f1', container.callback, {});
      expect(container.callback.getCall(0).args).to.be.eql([
        ['c2'], {preserveOrder: true}
      ]);
    });
  });

  describe("#searchByServices()", function () {
    var container = {
      callback: Em.K
    };

    beforeEach(function() {
      sinon.stub(container, 'callback');
      sinon.stub(visualSearch.searchQuery, 'values').returns(['s1']);
      sinon.stub(App.Service, 'find').returns([
        Em.Object.create({serviceName: 'S1'}),
        Em.Object.create({serviceName: 'S2'})
      ]);
    });

    afterEach(function() {
      container.callback.restore();
      visualSearch.searchQuery.values.restore();
      App.Service.find.restore();
    });

    it("callback should be called", function() {
      view.searchByServices('f1', container.callback);
      expect(container.callback.getCall(0).args).to.be.eql([
        ['S2'], {preserveOrder: true}
      ]);
    });
  });


  describe("#searchByComponentState()", function () {
    var container = {
      callback: Em.K
    };

    beforeEach(function() {
      sinon.stub(container, 'callback');
      this.mock = sinon.stub(view, 'getComponentStateFacets').returns(['cf1']);
      sinon.stub(App.HostComponentStatus, 'getStatusesList').returns([
        'UPGRADE_FAILED', 'ST1'
      ]);
      sinon.stub(App.HostComponentStatus, 'getTextStatus', function(status) {
        return status;
      });
    });

    afterEach(function() {
      container.callback.restore();
      this.mock.restore();
      App.HostComponentStatus.getStatusesList.restore();
      App.HostComponentStatus.getTextStatus.restore();
    });

    it("callback should be called, client", function() {
      view.searchByComponentState('client', container.callback, {});
      expect(container.callback.getCall(0).args).to.be.eql([
        ['All'], {preserveOrder: true}
      ]);
    });

    it("callback should be called", function() {
      view.searchByComponentState('f1', container.callback, {});
      expect(container.callback.getCall(0).args).to.be.eql([
        ['All'], {preserveOrder: true}
      ]);
    });

    it("callback should be called, empty state facets", function() {
      this.mock.returns([]);
      view.searchByComponentState('f1', container.callback, {});
      expect(container.callback.getCall(0).args).to.be.eql([
        [
          "All",
          "ST1",
          "Inservice",
          "Decommissioned",
          "Decommissioning",
          "RS Decommissioned",
          "Maintenance Mode On",
          "Maintenance Mode Off"
        ], {preserveOrder: true}
      ]);
    });
  });

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

    it("errMsg should be set", function() {
      view.showErrMsg({attributes: {value: 'val1'}});
      expect(view.get('errMsg')).to.be.equal('val1 ' + Em.I18n.t('hosts.combo.search.invalidCategory'));
    });
  });

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

    it("errMsg should be empty", function() {
      view.clearErrMsg();
      expect(view.get('errMsg')).to.be.empty;
    });
  });

  describe("#getHostComponentList()", function () {
    var labelValueMap = {};

    beforeEach(function() {
      sinon.stub(App.MasterComponent, 'find').returns([
        Em.Object.create({totalCount: 0}),
        Em.Object.create({totalCount: 1}),
        Em.Object.create({totalCount: 1, displayName: 'mc1', componentName: 'MC1'})
      ]);
      sinon.stub(App.SlaveComponent, 'find').returns([
        Em.Object.create({totalCount: 0}),
        Em.Object.create({totalCount: 1}),
        Em.Object.create({totalCount: 1, displayName: 'sc1', componentName: 'SC1'})
      ]);
      sinon.stub(App.ClientComponent, 'find').returns([
        Em.Object.create({totalCount: 0}),
        Em.Object.create({totalCount: 1}),
        Em.Object.create({totalCount: 1, displayName: 'cc1', componentName: 'CC1'})
      ]);
      sinon.stub(App.router, 'get').returns(labelValueMap);
    });

    afterEach(function() {
      App.MasterComponent.find.restore();
      App.SlaveComponent.find.restore();
      App.ClientComponent.find.restore();
      App.router.get.restore();
    });

    it("should return sorted host-component list", function() {
      expect(view.getHostComponentList()).to.be.eql([
        {label: 'cc1', category: 'Component'},
        {label: 'mc1', category: 'Component'},
        {label: 'sc1', category: 'Component'}
      ]);
      expect(labelValueMap).to.be.eql({
        mc1: 'MC1',
        sc1: 'SC1',
        cc1: 'CC1'
      });
    });
  });

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

    beforeEach(function() {
      sinon.stub(visualSearch.searchQuery, 'toJSON').returns([
        {category: 'cat1', value: 'val'},
        {category: 'cat2', value: null},
        {category: 'cat3', value: 'All'}
      ]);
      sinon.stub(view, 'getHostComponentList').returns([{label: ''}]);
    });

    afterEach(function() {
      visualSearch.searchQuery.toJSON.restore();
      view.getHostComponentList.restore();
    });

    it("label='', includeAllValue=true", function() {
      expect(view.getComponentStateFacets(null, true)).to.be.empty;
    });

    it("label=cat2, includeAllValue=true", function() {
      expect(view.getComponentStateFacets([{label: 'cat2'}], true)).to.be.empty;
    });

    it("label=cat1, includeAllValue=true", function() {
      expect(view.getComponentStateFacets([{label: 'cat1'}], true)).to.be.eql([
        {category: 'cat1', value: 'val'}
      ]);
    });

    it("label=cat1, includeAllValue=false", function() {
      expect(view.getComponentStateFacets([{label: 'cat1'}], false)).to.be.eql([
        {category: 'cat1', value: 'val'}
      ]);
    });

    it("label=cat3, includeAllValue=false", function() {
      expect(view.getComponentStateFacets([{label: 'cat3'}], false)).to.be.empty;
    });
  });

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

    beforeEach(function() {
      sinon.stub(visualSearch.searchQuery, 'toJSON').returns([
        {category: 'f1'},
        {category: 'f2'}
      ]);
    });

    afterEach(function() {
      visualSearch.searchQuery.toJSON.restore();
    });

    it("should return facets", function() {
      expect(view.getFacetsByName('f1')).to.be.eql([{category: 'f1'}]);
    });
  });

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

    beforeEach(function() {
      this.mock = sinon.stub(view, 'getFacetsByName');
    });

    afterEach(function() {
      view.getFacetsByName.restore();
    });

    it("should return empty, no facets", function() {
      this.mock.returns([]);
      expect(view.filterOutOneFacetOnlyOptions([])).to.be.empty;
    });

    it("should return empty", function() {
      this.mock.returns([{}]);
      expect(view.filterOutOneFacetOnlyOptions([{label: 'Cores'}])).to.be.empty;
    });

    it("should return options", function() {
      this.mock.returns([{}]);
      expect(view.filterOutOneFacetOnlyOptions([{label: 'f1'}])).to.be.eql([{label: 'f1'}]);
    });
  });

  describe("#setupLabelMap()", function () {
    var map = {
      'init': 'init'
    };

    beforeEach(function() {
      sinon.stub(App.router, 'get').returns(map);
    });

    afterEach(function() {
      App.router.get.restore();
    });

    it("should set map", function() {
      view.setupLabelMap();
      expect(map).to.be.eql({
        'init': 'init',
        'All': 'ALL',
        'Host Name': 'hostName',
        'IP': 'ip',
        'Host Status': 'healthClass',
        'Cores': 'cpu',
        'RAM': 'memoryFormatted',
        'Stack Version': 'version',
        'Version State': 'versionState',
        'Rack': 'rack',
        'Service': 'services',
        'Inservice': 'INSERVICE',
        'Decommissioned': 'DECOMMISSIONED',
        'Decommissioning': 'DECOMMISSIONING',
        'RS Decommissioned': 'RS_DECOMMISSIONED',
        'Maintenance Mode On': 'ON',
        'Maintenance Mode Off': 'OFF'
      });
    });
  });

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

    beforeEach(function() {
      sinon.stub(view, 'getFilterColumn').returns(1);
      sinon.stub(view, 'getFilterValue').returns('filterValue');
      sinon.stub(App.router, 'get').returns({'k1': 'services'});
      sinon.stub(view, 'createCondition').returns({
        skipFilter: false,
        iColumn: 1,
        value: 'val1',
        type: 't1'
      });
      view.set('serviceMap', {k2: 'val2'});
    });

    afterEach(function() {
      view.getFilterColumn.restore();
      view.getFilterValue.restore();
      App.router.get.restore();
      view.createCondition.restore();
    });

    it("empty models", function() {
      var searchCollection = {
        models: []
      };
      expect(view.createFilterConditions(searchCollection)).to.be.empty;
    });

    it("should return conditions, string value", function() {
      var searchCollection = {
        models: [
          {
            attributes: {
              category: 'k1',
              value: 'k2'
            }
          },
          {
            attributes: {
              category: 'k1',
              value: 'k2'
            }
          }
        ]
      };
      expect(JSON.stringify(view.createFilterConditions(searchCollection))).to.be.equal(JSON.stringify([
        {
          "skipFilter": false,
          "iColumn": 1,
          "value": [
            "val1",
            "filterValue"
          ],
          "type": "t1"
        }
      ]));
    });


    it("should return conditions, array value", function() {
      var searchCollection = {
        models: [
          {
            attributes: {
              category: 'cat1',
              value: ['val1']
            }
          },
          {
            attributes: {
              category: 'cat2',
              value: 'val2'
            }
          }
        ]
      };
      expect(JSON.stringify(view.createFilterConditions(searchCollection))).to.be.equal(JSON.stringify([
        {
          "skipFilter": false,
          "iColumn": 1,
          "value": [
            "val1",
            "filterValue"
          ],
          "type": "t1"
        }
      ]));
    });
  });

  describe("#createCondition()", function () {
    var testCases = [
      {
        category: 'cpu',
        iColumn: 1,
        filterValue: 'val1',
        expected: {
          skipFilter: false,
          iColumn: 1,
          value: 'val1',
          type: 'number'
        }
      },
      {
        category: 'memoryFormatted',
        iColumn: 2,
        filterValue: 'val2',
        expected: {
          skipFilter: false,
          iColumn: 2,
          value: 'val2',
          type: 'ambari-bandwidth'
        }
      },
      {
        category: 'cat1',
        iColumn: 3,
        filterValue: ['val2'],
        expected: {
          skipFilter: false,
          iColumn: 3,
          value: ['val2'],
          type: 'string'
        }
      }
    ];

    testCases.forEach(function(test) {
      it("category = " + test.category +
         " iColumn = " + test.iColumn +
         " filterValue = " + test.filterValue, function() {
        expect(view.createCondition(test.category, test.iColumn, test.filterValue)).to.be.eql(test.expected);
      });
    });
  });

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

    beforeEach(function() {
      this.mockComponentState = sinon.stub(view.get('controller'), 'isComponentStateFacet');
      this.mockComplexHealth = sinon.stub(view.get('controller'), 'isComplexHealthStatusFacet');
      sinon.stub(App.router, 'get').returns(['componentState', 'cat1']);
      view.set('healthStatusCategories', [{healthStatus: 'val1', column: 2}]);
    });

    afterEach(function() {
      this.mockComponentState.restore();
      this.mockComplexHealth.restore();
      App.router.get.restore();
    });

    it("should return componentState column", function() {
      this.mockComponentState.returns(true);
      expect(view.getFilterColumn('cat1', 'val1')).to.be.equal(0);
    });

    it("should return healthStatus column", function() {
      this.mockComplexHealth.returns(true);
      expect(view.getFilterColumn('cat1', 'val1')).to.be.equal(2);
    });

    it("should return custom column", function() {
      expect(view.getFilterColumn('cat1', 'val1')).to.be.equal(1);
    });
  });

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

    beforeEach(function() {
      this.mockComponentState = sinon.stub(view.get('controller'), 'isComponentStateFacet');
      this.mockComplexHealth = sinon.stub(view.get('controller'), 'isComplexHealthStatusFacet');
      view.set('healthStatusCategories', [{healthStatus: 'val1', filterValue: 'filterValue'}]);
    });

    afterEach(function() {
      this.mockComponentState.restore();
      this.mockComplexHealth.restore();
    });

    it("should return componentState filter value", function() {
      this.mockComponentState.returns(true);
      expect(view.getFilterValue('cat1', 'val1')).to.be.equal('cat1:val1');
    });

    it("should return health filter value", function() {
      this.mockComplexHealth.returns(true);
      expect(view.getFilterValue('cat1', 'val1')).to.be.equal('filterValue');
    });

    it("should return other filter value", function() {
      expect(view.getFilterValue('cat1', 'val1')).to.be.equal('val1');
    });
  });
});