| /** |
| * 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 validationUtils = require('utils/validator'); |
| require('utils/helper'); |
| require('controllers/wizard/step6_controller'); |
| var controller, |
| services = [ |
| Em.Object.create({ |
| serviceName: 'YARN', |
| isSelected: true |
| }), |
| Em.Object.create({ |
| serviceName: 'HBASE', |
| isSelected: true |
| }), |
| Em.Object.create({ |
| serviceName: 'HDFS', |
| isSelected: true |
| }), |
| Em.Object.create({ |
| serviceName: 'STORM', |
| isSelected: true |
| }), |
| Em.Object.create({ |
| serviceName: 'FLUME', |
| isSelected: true |
| }) |
| ]; |
| |
| function getController() { |
| var c = App.WizardStep6Controller.create({ |
| content: Em.Object.create({ |
| hosts: {}, |
| masterComponentHosts: {}, |
| services: services, |
| controllerName: '' |
| }) |
| }); |
| |
| var h = {}, m = []; |
| Em.A(['host0', 'host1', 'host2', 'host3']).forEach(function (hostName) { |
| var obj = Em.Object.create({ |
| name: hostName, |
| hostName: hostName, |
| bootStatus: 'REGISTERED' |
| }); |
| h[hostName] = obj; |
| m.push(obj); |
| }); |
| |
| c.set('content.hosts', h); |
| c.set('content.masterComponentHosts', m); |
| c.set('isMasters', false); |
| return c; |
| } |
| |
| describe('App.WizardStep6Controller', function () { |
| |
| beforeEach(function () { |
| controller = getController(); |
| }); |
| |
| App.TestAliases.testAsComputedEqual(getController(), 'isAddHostWizard', 'content.controllerName', 'addHostController'); |
| |
| describe('#installedServiceNames', function () { |
| it(' should filter content.services by isInstalled property', function () { |
| var _services = Em.A([]); |
| _services.pushObjects(Em.A([{isInstalled: true, serviceName: "service1"}, |
| {isInstalled: false, serviceName: "service2"}, |
| {isInstalled: true, serviceName: "service3"}, |
| {isInstalled: false, serviceName: "service4"}, |
| {isInstalled: true, serviceName: "service5"}])); |
| controller.set('content.services', _services); |
| expect(controller.get('installedServiceNames')).to.eql(["service1", "service3", "service5"]); |
| }); |
| }); |
| |
| describe('#showValidationIssuesAcceptBox', function () { |
| it('should return true if success callback', function () { |
| var deffer = jQuery.Deferred(); |
| function callback() { |
| deffer.resolve(true); |
| } |
| controller.showValidationIssuesAcceptBox(callback); |
| jQuery.when(deffer.promise()).then(function(data) { |
| expect(data).to.equal(true); |
| }); |
| }); |
| }); |
| |
| describe('#selectAllNodes', function () { |
| |
| var hostsObj = Em.A([Em.Object.create({ |
| hasMaster: false, |
| isInstalled: false, |
| checkboxes: Em.A([ |
| Em.Object.create({ |
| title: 'l1', |
| component: 'name', |
| isInstalled: false, |
| checked: false |
| }) |
| ]) |
| })]); |
| var obj = Em.Object.create({ |
| context: { |
| name: "name" |
| } |
| }); |
| var clientComponents = Em.A([{component_name: "name1"}]); |
| |
| it('should make checkbox checked', function () { |
| controller.set('hosts', hostsObj); |
| controller.set('content.clients', clientComponents); |
| controller.selectAllNodes(obj); |
| expect(controller.get('hosts')).to.eql(Em.A([Em.Object.create({ |
| hasMaster: false, |
| isInstalled: false, |
| checkboxes: Em.A([ |
| Em.Object.create({ |
| title: 'l1', |
| component: 'name', |
| isInstalled: false, |
| checked: true |
| }) |
| ]) |
| })])); |
| }); |
| }); |
| |
| describe('#deselectAllNodes', function () { |
| |
| var hostsObj = Em.A([Em.Object.create({ |
| hasMaster: false, |
| isInstalled: false, |
| checkboxes: Em.A([ |
| Em.Object.create({ |
| title: 'l1', |
| component: 'name', |
| isInstalled: false, |
| checked: true |
| }) |
| ]) |
| })]); |
| var obj = Em.Object.create({ |
| context: { |
| name: "name" |
| } |
| }); |
| var clientComponents = Em.A([{component_name: "name1"}]); |
| |
| it('should uncheck checkbox', function () { |
| controller.set('hosts', hostsObj); |
| controller.set('content.clients', clientComponents); |
| controller.deselectAllNodes(obj); |
| expect(controller.get('hosts')).to.eql(Em.A([Em.Object.create({ |
| hasMaster: false, |
| isInstalled: false, |
| checkboxes: Em.A([ |
| Em.Object.create({ |
| title: 'l1', |
| component: 'name', |
| isInstalled: false, |
| checked: false |
| }) |
| ]) |
| })])); |
| }); |
| }); |
| |
| describe('#renderSlaves()', function () { |
| var hostsObj = [{}]; |
| |
| beforeEach(function() { |
| sinon.stub(controller, 'selectRecommendedComponents'); |
| sinon.stub(controller, 'setInstalledComponents'); |
| sinon.stub(controller, 'restoreComponentsSelection'); |
| sinon.stub(controller, 'selectClientHost'); |
| sinon.stub(controller, 'enableCheckboxesForDependentComponents'); |
| }); |
| |
| afterEach(function() { |
| controller.selectRecommendedComponents.restore(); |
| controller.setInstalledComponents.restore(); |
| controller.restoreComponentsSelection.restore(); |
| controller.selectClientHost.restore(); |
| controller.enableCheckboxesForDependentComponents.restore(); |
| }); |
| |
| describe("slaveComponents is null", function() { |
| |
| beforeEach(function() { |
| controller.set('content.slaveComponentHosts', null); |
| controller.set('content.controllerName', null); |
| }); |
| |
| it("selectRecommendedComponents should be called", function() { |
| expect(controller.renderSlaves(hostsObj)).to.eql(hostsObj); |
| expect(controller.selectRecommendedComponents.calledWith(hostsObj)).to.be.true; |
| }); |
| it("setInstalledComponents should be called", function() { |
| expect(controller.renderSlaves(hostsObj)).to.eql(hostsObj); |
| expect(controller.setInstalledComponents.calledWith(hostsObj)).to.be.true; |
| }); |
| it("restoreComponentsSelection should not be called", function() { |
| expect(controller.renderSlaves(hostsObj)).to.eql(hostsObj); |
| expect(controller.restoreComponentsSelection.called).to.be.false; |
| }); |
| it("selectClientHost should be called", function() { |
| expect(controller.renderSlaves(hostsObj)).to.eql(hostsObj); |
| expect(controller.selectClientHost.calledWith(hostsObj)).to.be.true; |
| }); |
| it("enableCheckboxesForDependentComponents should not be called", function() { |
| expect(controller.renderSlaves(hostsObj)).to.eql(hostsObj); |
| expect(controller.enableCheckboxesForDependentComponents.calledOnce).to.be.false; |
| }); |
| it("enableCheckboxesForDependentComponents should be called", function() { |
| controller.set('content.controllerName', 'addServiceController'); |
| expect(controller.renderSlaves(hostsObj)).to.eql(hostsObj); |
| expect(controller.enableCheckboxesForDependentComponents.calledOnce).to.be.true; |
| }); |
| }); |
| |
| describe("slaveComponents is defined", function() { |
| |
| var slaveComponentHosts = [{}]; |
| |
| beforeEach(function() { |
| controller.set('content.slaveComponentHosts', slaveComponentHosts); |
| }); |
| |
| it("selectRecommendedComponents should not be called", function() { |
| expect(controller.renderSlaves(hostsObj)).to.eql(hostsObj); |
| expect(controller.selectRecommendedComponents.called).to.be.false; |
| }); |
| it("setInstalledComponents should not be called", function() { |
| expect(controller.renderSlaves(hostsObj)).to.eql(hostsObj); |
| expect(controller.setInstalledComponents.called).to.be.false; |
| }); |
| it("restoreComponentsSelection should be called", function() { |
| expect(controller.renderSlaves(hostsObj)).to.eql(hostsObj); |
| expect(controller.restoreComponentsSelection.calledWith(hostsObj, slaveComponentHosts)).to.be.true; |
| }); |
| it("selectClientHost should be called", function() { |
| expect(controller.renderSlaves(hostsObj)).to.eql(hostsObj); |
| expect(controller.selectClientHost.calledWith(hostsObj)).to.be.true; |
| }); |
| }); |
| }); |
| |
| describe("#setInstalledComponents()", function() { |
| var hostsObj = [{ |
| hostName: 'host1', |
| checkboxes: [ |
| { |
| component: 'C1', |
| isInstalled: false, |
| checked: false |
| }, |
| { |
| component: 'C2', |
| isInstalled: false, |
| checked: false |
| } |
| ] |
| }]; |
| |
| it("installedHosts is null", function() { |
| controller.set('content.installedHosts', null); |
| expect(controller.setInstalledComponents(hostsObj)).to.be.false; |
| }); |
| |
| it("installedHosts is defined", function() { |
| controller.set('content.installedHosts', { |
| 'host1': { |
| hostComponents: [ |
| { |
| HostRoles: { |
| component_name: 'C1' |
| } |
| } |
| ] |
| } |
| }); |
| controller.setInstalledComponents(hostsObj); |
| expect(hostsObj[0].checkboxes[0].isInstalled).to.be.true; |
| expect(hostsObj[0].checkboxes[1].isInstalled).to.be.false; |
| expect(hostsObj[0].checkboxes[0].checked).to.be.true; |
| expect(hostsObj[0].checkboxes[1].checked).to.be.false; |
| }); |
| }); |
| |
| describe("#restoreComponentsSelection()", function() { |
| var getHostsObj = function() { |
| return [{ |
| hostName: 'host1', |
| checkboxes: [ |
| { |
| component: 'C1', |
| title: 'c1', |
| isInstalled: false, |
| checked: false |
| }, |
| { |
| component: 'C2', |
| title: 'c1', |
| isInstalled: true, |
| checked: false |
| }, |
| { |
| component: 'C3', |
| title: 'c3', |
| isInstalled: false, |
| checked: false |
| } |
| ] |
| }]; |
| }; |
| |
| var slaveComponents = [ |
| { |
| componentName: 'C1', |
| hosts: [{hostName: 'host1', isInstalled: true}] |
| } |
| ]; |
| |
| beforeEach(function() { |
| controller.set('headers', [ |
| Em.Object.create({ |
| name: 'C1', |
| label: 'c1' |
| }), |
| Em.Object.create({ |
| name: 'C2', |
| label: 'c2' |
| }), |
| Em.Object.create({ |
| name: 'C3', |
| label: 'c3' |
| }) |
| ]); |
| }); |
| |
| it("C1 components should be checked and installed", function() { |
| var hostsObj = getHostsObj(); |
| controller.restoreComponentsSelection(hostsObj, slaveComponents); |
| expect(hostsObj[0].checkboxes[0].isInstalled).to.be.true; |
| expect(hostsObj[0].checkboxes[0].checked).to.be.true; |
| }); |
| it("C2 components should not be checked and should be installed", function() { |
| var hostsObj = getHostsObj(); |
| controller.restoreComponentsSelection(hostsObj, slaveComponents); |
| expect(hostsObj[0].checkboxes[1].isInstalled).to.be.true; |
| expect(hostsObj[0].checkboxes[1].checked).to.be.false; |
| }); |
| it("C3 components should not be checked and should not be installed", function() { |
| var hostsObj = getHostsObj(); |
| controller.restoreComponentsSelection(hostsObj, slaveComponents); |
| expect(hostsObj[0].checkboxes[2].isInstalled).to.be.false; |
| expect(hostsObj[0].checkboxes[2].checked).to.be.false; |
| }); |
| }); |
| |
| describe("#selectRecommendedComponents()", function() { |
| |
| var hostsObj = [{ |
| hostName: 'host1', |
| checkboxes: [ |
| { |
| component: 'C1', |
| checked: false, |
| isDisabled: false |
| }, |
| { |
| component: 'C2', |
| checked: false, |
| isDisabled: true |
| }, |
| { |
| component: 'C3', |
| checked: false, |
| isDisabled: false |
| }, |
| { |
| component: 'CLIENT', |
| checked: false, |
| isDisabled: false |
| } |
| ] |
| }]; |
| |
| var recommendations = { |
| blueprint: { |
| host_groups: [ |
| { |
| name: 'g1', |
| components: [ |
| {name: 'C1'}, |
| {name: 'C2'}, |
| {name: 'C_CLIENT'} |
| ] |
| } |
| ] |
| }, |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| name: 'g1', |
| hosts: [{fqdn: 'host1'}] |
| } |
| ] |
| } |
| }; |
| |
| beforeEach(function() { |
| sinon.stub(App, 'get').returns(['C_CLIENT']); |
| }); |
| |
| afterEach(function() { |
| App.get.restore(); |
| }); |
| |
| it("C1 should be checked", function() { |
| controller.set('content.recommendations', recommendations); |
| controller.selectRecommendedComponents(hostsObj); |
| expect(hostsObj[0].checkboxes[0].checked).to.be.true; |
| }); |
| |
| it("C2 should not be checked, as it is disabled", function() { |
| controller.set('content.recommendations', recommendations); |
| controller.selectRecommendedComponents(hostsObj); |
| expect(hostsObj[0].checkboxes[1].checked).to.be.false; |
| }); |
| |
| it("C3 should not be checked", function() { |
| controller.set('content.recommendations', recommendations); |
| controller.selectRecommendedComponents(hostsObj); |
| expect(hostsObj[0].checkboxes[2].checked).to.be.false; |
| }); |
| |
| it("CLIENT should be checked", function() { |
| controller.set('content.recommendations', recommendations); |
| controller.selectRecommendedComponents(hostsObj); |
| expect(hostsObj[0].checkboxes[3].checked).to.be.true; |
| }); |
| }); |
| |
| App.TestAliases.testAsComputedOr(getController(), 'anyGeneralErrors', ['errorMessage', 'generalErrorMessages.length']); |
| |
| describe('#render', function () { |
| it('true if loaded', function () { |
| var hosts = { |
| h1: {bootStatus: 'REGISTERED', name: 'h1'}, |
| h2: {bootStatus: 'REGISTERED', name: 'h2'}, |
| h3: {bootStatus: 'REGISTERED', name: 'h3'} |
| }; |
| var headers = Em.A([ |
| Em.Object.create({name: "c1", label: 'l1', isDisabled: true}), |
| Em.Object.create({name: "c2", label: 'l2', isDisabled: false}) |
| ]); |
| var masterComponentHosts = Em.A([ |
| {hostName: 'h1', component: 'c1'} |
| ]); |
| var recommendations = { |
| blueprint: { |
| host_groups: [ |
| { |
| components: [ |
| { |
| name: 'c6' |
| } |
| ], |
| name: 'host-group-1' |
| }, |
| { |
| components: [ |
| { |
| name: 'c8' |
| } |
| ], |
| name: 'host-group-2' |
| } |
| ] |
| }, |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| hosts: [ |
| { |
| fqdn: 'h0' |
| } |
| ], |
| name: 'host-group-1' |
| }, |
| { |
| hosts: [ |
| { |
| fqdn: 'h1' |
| } |
| ], |
| name: 'host-group-2' |
| }] |
| } |
| }; |
| controller.set('content.hosts', hosts); |
| controller.set('content.masterComponentHosts', masterComponentHosts); |
| controller.set('content.recommendations', recommendations); |
| controller.set('headers', headers); |
| controller.render(); |
| expect(controller.get('isLoaded')).to.equal(true); |
| }); |
| }); |
| |
| describe('#anyGeneralWarnings', function () { |
| it('true if generalWarningMessages is non empty array and warningMessage is undefined', function () { |
| controller.set('generalWarningMessages', ["warning1", "warning2"]); |
| expect(controller.get('anyGeneralWarnings')).to.equal(true); |
| }); |
| it('false if generalWarningMessages is empty array', function () { |
| controller.set('generalWarningMessages', []); |
| expect(controller.get('anyGeneralWarnings')).to.equal(false); |
| }); |
| it('undefined if generalWarningMessages is undefined', function () { |
| controller.set('generalWarningMessages', false); |
| expect(controller.get('anyGeneralWarnings')).to.equal(false); |
| }); |
| }); |
| |
| App.TestAliases.testAsComputedOr(getController(), 'anyGeneralIssues', ['anyGeneralErrors', 'anyGeneralWarnings']); |
| |
| App.TestAliases.testAsComputedOr(getController(), 'anyErrors', ['anyGeneralErrors', 'anyHostErrors']); |
| |
| App.TestAliases.testAsComputedOr(getController(), 'anyWarnings', ['anyGeneralWarnings', 'anyHostWarnings']); |
| |
| describe('#anyWarnings', function () { |
| it('true if generalWarningMessages is non empty', function () { |
| controller.set('generalWarningMessages', ["error 404", "error"]); |
| expect(controller.get('anyWarnings')).to.equal(true); |
| }); |
| it('false if generalWarningMessages is empty', function () { |
| controller.set('generalWarningMessages', []); |
| expect(controller.get('anyWarnings')).to.equal(false); |
| }); |
| }); |
| |
| App.TestAliases.testAsComputedEqual(getController(), 'isInstallerWizard', 'content.controllerName', 'installerController'); |
| |
| App.TestAliases.testAsComputedEqual(getController(), 'isAddServiceWizard', 'content.controllerName', 'addServiceController'); |
| |
| describe('#selectClientHost', function () { |
| it('true if isClientsSet false', function () { |
| var hostsObj = Em.A([Em.Object.create({ |
| hasMaster: false, |
| checkboxes: Em.A([ |
| Em.Object.create({ |
| component: 'c1', |
| isInstalled: false, |
| checked: true |
| }) |
| ]) |
| })]); |
| controller.set('isClientsSet', false); |
| controller.selectClientHost(hostsObj); |
| expect(controller.get('isClientsSet')).to.equal(true); |
| }); |
| }); |
| |
| describe('#updateValidationsSuccessCallback', function () { |
| |
| var hosts = Em.A([Em.Object.create({ |
| warnMessages: "warn", |
| errorMessages: "error", |
| anyMessage: true, |
| checkboxes: Em.A([Em.Object.create({ |
| hasWarnMessage: true, |
| hasErrorMessage: true |
| })]) |
| })]); |
| |
| var validationData = Em.Object.create({ |
| resources: Em.A([ |
| Em.Object.create({ |
| items: Em.A([ |
| Em.Object.create({ |
| "component-name": 'HDFS_CLIENT', |
| host: "1", |
| isMaster: true |
| }) |
| ]) |
| }) |
| ]) |
| }); |
| |
| beforeEach(function () { |
| sinon.stub(validationUtils, 'filterNotInstalledComponents', function () { |
| return Em.A([Em.Object.create({ |
| componentName: 'c0', |
| isSlave: true, |
| type: 'host-component', |
| level: 'ERROR' |
| }), |
| Em.Object.create({ |
| componentName: 'c1', |
| isSlave: true, |
| type: 'host-component', |
| level: 'WARN', |
| isShownOnInstallerSlaveClientPage: true |
| })]); |
| }); |
| sinon.stub(App.StackServiceComponent, 'find', function () { |
| return [ |
| Em.Object.create({ |
| componentName: 'c0', |
| isSlave: true |
| }), |
| Em.Object.create({ |
| componentName: 'c1', |
| isSlave: true, |
| isShownOnInstallerSlaveClientPage: true |
| }), |
| Em.Object.create({ |
| componentName: 'c2', |
| isSlave: true, |
| isShownOnInstallerSlaveClientPage: false |
| }), |
| Em.Object.create({ |
| componentName: 'c3', |
| isClient: true |
| }), |
| Em.Object.create({ |
| componentName: 'c4', |
| isClient: true, |
| isRequiredOnAllHosts: false |
| }), |
| Em.Object.create({ |
| componentName: 'c5', |
| isClient: true, |
| isRequiredOnAllHosts: true |
| }), |
| Em.Object.create({ |
| componentName: 'c6', |
| isMaster: true, |
| isShownOnInstallerAssignMasterPage: true |
| }), |
| Em.Object.create({ |
| componentName: 'c7', |
| isMaster: true, |
| isShownOnInstallerAssignMasterPage: false |
| }), |
| Em.Object.create({ |
| componentName: 'HDFS_CLIENT', |
| isMaster: true, |
| isShownOnAddServiceAssignMasterPage: true |
| }), |
| Em.Object.create({ |
| componentName: 'c9', |
| isMaster: true, |
| isShownOnAddServiceAssignMasterPage: false |
| }) |
| ]; |
| }); |
| controller.set('hosts', hosts); |
| controller.updateValidationsSuccessCallback(validationData); |
| }); |
| |
| afterEach(function () { |
| App.StackServiceComponent.find.restore(); |
| validationUtils.filterNotInstalledComponents.restore(); |
| }); |
| |
| it('no generalErrorMessages', function () { |
| expect(controller.get('generalErrorMessages').length).to.equal(0); |
| }); |
| |
| it('no generalWarningMessages', function () { |
| expect(controller.get('generalWarningMessages').length).to.equal(0); |
| }); |
| |
| it('hosts info is valid', function () { |
| var cHosts = JSON.parse(JSON.stringify(controller.get('hosts'))); |
| var expected = [{ |
| warnMessages: [null], |
| errorMessages: [null], |
| anyMessage: true, |
| checkboxes: [{ |
| hasWarnMessage: true, |
| hasErrorMessage: true |
| }] |
| }]; |
| expect(cHosts).to.eql(expected); |
| }); |
| }); |
| |
| describe('#clearError', function () { |
| |
| var headers = Em.A([ |
| Em.Object.create({name: "c1", label: 't1'}), |
| Em.Object.create({name: "c2", label: 't2'})]); |
| |
| beforeEach(function () { |
| controller.set('errorMessage', 'error'); |
| controller.set('headers', headers); |
| }); |
| |
| it('both checkboxes are checked', function () { |
| var hosts = Em.A([ |
| Em.Object.create({ |
| checkboxes: Em.A([ |
| Em.Object.create({ |
| component: 'c1', |
| isInstalled: false, |
| checked: true |
| }), |
| Em.Object.create({ |
| component: 'c2', |
| isInstalled: false, |
| checked: true |
| })]) |
| }) |
| ]); |
| |
| controller.set('hosts', hosts); |
| controller.clearError(); |
| expect(controller.get('errorMessage')).to.equal(''); |
| }); |
| |
| it('true if is one of checkboxes checked false', function () { |
| var hosts = Em.A([ |
| Em.Object.create({ |
| checkboxes: Em.A([ |
| Em.Object.create({ |
| title: "t1", |
| component: 'c1', |
| isInstalled: false, |
| checked: false |
| }), |
| Em.Object.create({ |
| title: "t2", |
| component: 'c2', |
| isInstalled: false, |
| checked: true |
| })]) |
| }) |
| ]); |
| |
| controller.set('hosts', hosts); |
| controller.set('isAddHostWizard', true); |
| controller.clearError(); |
| expect(controller.get('errorMessage')).to.equal('error'); |
| }); |
| }); |
| |
| describe('#clearStep', function () { |
| beforeEach(function () { |
| sinon.stub(controller, 'clearError', Em.K); |
| }); |
| afterEach(function () { |
| controller.clearError.restore(); |
| }); |
| it('should call clearError', function () { |
| controller.clearStep(); |
| expect(controller.clearError.calledOnce).to.equal(true); |
| }); |
| it('should clear hosts', function () { |
| controller.set('hosts', [ |
| {}, |
| {} |
| ]); |
| controller.clearStep(); |
| expect(controller.get('hosts')).to.eql([]); |
| }); |
| it('should clear headers', function () { |
| controller.set('headers', [ |
| {}, |
| {} |
| ]); |
| controller.clearStep(); |
| expect(controller.get('headers')).to.eql([]); |
| }); |
| it('should set isLoaded to false', function () { |
| controller.set('isLoaded', true); |
| controller.clearStep(); |
| expect(controller.get('isLoaded')).to.equal(false); |
| }); |
| }); |
| |
| describe('#checkCallback', function () { |
| beforeEach(function () { |
| sinon.stub(controller, 'clearError', Em.K); |
| }); |
| afterEach(function () { |
| controller.clearError.restore(); |
| }); |
| it('should call clearError', function () { |
| controller.checkCallback(''); |
| expect(controller.clearError.calledOnce).to.equal(true); |
| }); |
| Em.A([ |
| { |
| m: 'all checked, isInstalled false', |
| headers: Em.A([ |
| Em.Object.create({name: 'c1'}) |
| ]), |
| hosts: Em.A([ |
| Em.Object.create({ |
| checkboxes: Em.A([ |
| Em.Object.create({ |
| component: 'c1', |
| isInstalled: false, |
| checked: true |
| }) |
| ]) |
| }) |
| ]), |
| component: 'c1', |
| e: { |
| allChecked: true, |
| noChecked: false |
| } |
| }, |
| { |
| m: 'all checked, isInstalled true', |
| headers: Em.A([ |
| Em.Object.create({name: 'c1'}) |
| ]), |
| hosts: Em.A([ |
| Em.Object.create({ |
| checkboxes: Em.A([ |
| Em.Object.create({ |
| component: 'c1', |
| isInstalled: true, |
| checked: true |
| }) |
| ]) |
| }) |
| ]), |
| component: 'c1', |
| e: { |
| allChecked: true, |
| noChecked: true |
| } |
| }, |
| { |
| m: 'no one checked', |
| headers: Em.A([ |
| Em.Object.create({name: 'c1'}) |
| ]), |
| hosts: Em.A([ |
| Em.Object.create({ |
| checkboxes: Em.A([ |
| Em.Object.create({ |
| component: 'c1', |
| isInstalled: false, |
| checked: false |
| }) |
| ]) |
| }) |
| ]), |
| component: 'c1', |
| e: { |
| allChecked: false, |
| noChecked: true |
| } |
| }, |
| { |
| m: 'some checked', |
| headers: Em.A([ |
| Em.Object.create({name: 'c1'}) |
| ]), |
| hosts: Em.A([ |
| Em.Object.create({ |
| checkboxes: Em.A([ |
| Em.Object.create({ |
| component: 'c1', |
| isInstalled: false, |
| checked: true |
| }), |
| Em.Object.create({ |
| component: 'c1', |
| isInstalled: false, |
| checked: false |
| }) |
| ]) |
| }) |
| ]), |
| component: 'c1', |
| e: { |
| allChecked: false, |
| noChecked: false |
| } |
| }, |
| { |
| m: 'some checked, some isInstalled true', |
| headers: Em.A([ |
| Em.Object.create({name: 'c1'}) |
| ]), |
| hosts: Em.A([ |
| Em.Object.create({ |
| checkboxes: Em.A([ |
| Em.Object.create({ |
| component: 'c1', |
| isInstalled: true, |
| checked: true |
| }), |
| Em.Object.create({ |
| component: 'c1', |
| isInstalled: true, |
| checked: true |
| }) |
| ]) |
| }) |
| ]), |
| component: 'c1', |
| e: { |
| allChecked: true, |
| noChecked: true |
| } |
| }, |
| { |
| m: 'some checked, some isInstalled true (2)', |
| headers: Em.A([ |
| Em.Object.create({name: 'c1'}) |
| ]), |
| hosts: Em.A([ |
| Em.Object.create({ |
| checkboxes: Em.A([ |
| Em.Object.create({ |
| component: 'c1', |
| isInstalled: false, |
| checked: false |
| }), |
| Em.Object.create({ |
| component: 'c1', |
| isInstalled: true, |
| checked: true |
| }) |
| ]) |
| }) |
| ]), |
| component: 'c1', |
| e: { |
| allChecked: false, |
| noChecked: true |
| } |
| } |
| ]).forEach(function (test) { |
| describe(test.m, function () { |
| |
| beforeEach(function () { |
| controller.clearStep(); |
| controller.set('headers', test.headers); |
| controller.set('hosts', test.hosts); |
| controller.checkCallback(test.component); |
| this.header = controller.get('headers').findProperty('name', test.component); |
| }); |
| |
| it('allChecked is ' + test.e.allChecked, function () { |
| expect(this.header.get('allChecked')).to.equal(test.e.allChecked); |
| }); |
| |
| it('noChecked is ' + test.e.noChecked, function () { |
| expect(this.header.get('noChecked')).to.equal(test.e.noChecked); |
| }); |
| }); |
| }); |
| }); |
| |
| describe('#getAllHosts', function () { |
| var tests = Em.A([ |
| { |
| hosts: { |
| h1: {bootStatus: 'REGISTERED', name: 'h1'}, |
| h2: {bootStatus: 'REGISTERED', name: 'h2'}, |
| h3: {bootStatus: 'REGISTERED', name: 'h3'} |
| }, |
| m: 'All REGISTERED', |
| e: ['h1', 'h2', 'h3'] |
| }, |
| { |
| hosts: { |
| h1: {bootStatus: 'REGISTERED', name: 'h1'}, |
| h2: {bootStatus: 'FAILED', name: 'h2'}, |
| h3: {bootStatus: 'REGISTERED', name: 'h3'} |
| }, |
| m: 'Some REGISTERED', |
| e: ['h1', 'h3'] |
| }, |
| { |
| hosts: { |
| h1: {bootStatus: 'FAILED', name: 'h1'}, |
| h2: {bootStatus: 'FAILED', name: 'h2'}, |
| h3: {bootStatus: 'FAILED', name: 'h3'} |
| }, |
| m: 'No one REGISTERED', |
| e: [] |
| }, |
| { |
| hosts: {}, |
| m: 'Empty hosts', |
| e: [] |
| } |
| ]); |
| tests.forEach(function (test) { |
| it(test.m, function () { |
| controller.set('content.hosts', test.hosts); |
| var r = controller.getAllHosts(); |
| expect(r.mapProperty('hostName')).to.eql(test.e); |
| }); |
| }); |
| }); |
| |
| describe('#getMasterComponentsForHost', function () { |
| var tests = Em.A([ |
| { |
| masterComponentHosts: Em.A([ |
| {hostName: 'h1', component: 'c1'} |
| ]), |
| hostName: 'h1', |
| m: 'host exists', |
| e: ['c1'] |
| }, |
| { |
| masterComponentHosts: Em.A([ |
| {hostName: 'h1', component: 'c1'} |
| ]), |
| hostName: 'h2', |
| m: 'host donesn\'t exists', |
| e: [] |
| } |
| ]); |
| tests.forEach(function (test) { |
| it(test.m, function () { |
| controller.set('content.masterComponentHosts', test.masterComponentHosts); |
| var r = controller.getMasterComponentsForHost(test.hostName); |
| expect(r).to.eql(test.e); |
| }); |
| }); |
| }); |
| |
| describe('#selectMasterComponents', function () { |
| var tests = Em.A([ |
| { |
| masterComponentHosts: Em.A([ |
| { |
| hostName: 'h1', |
| component: 'c1' |
| } |
| ]), |
| hostsObj: [ |
| Em.Object.create({ |
| hostName: 'h1', |
| checkboxes: [ |
| Em.Object.create({ |
| component: 'c1', |
| checked: false |
| }) |
| ] |
| }) |
| ], |
| e: true, |
| m: 'host and component exist' |
| }, |
| { |
| masterComponentHosts: Em.A([ |
| { |
| hostName: 'h1', |
| component: 'c2' |
| } |
| ]), |
| hostsObj: [ |
| Em.Object.create({ |
| hostName: 'h1', |
| checkboxes: [ |
| Em.Object.create({ |
| component: 'c1', |
| checked: false |
| }) |
| ] |
| }) |
| ], |
| e: false, |
| m: 'host exists' |
| }, |
| { |
| masterComponentHosts: Em.A([ |
| { |
| hostName: 'h2', |
| component: 'c2' |
| } |
| ]), |
| hostsObj: [ |
| Em.Object.create({ |
| hostName: 'h1', |
| checkboxes: [ |
| Em.Object.create({ |
| component: 'c1', |
| checked: false |
| }) |
| ] |
| }) |
| ], |
| e: false, |
| m: 'host and component don\'t exist' |
| } |
| ]); |
| tests.forEach(function (test) { |
| it(test.m, function () { |
| controller.set('content.masterComponentHosts', test.masterComponentHosts); |
| var r = controller.selectMasterComponents(test.hostsObj); |
| expect(r.findProperty('hostName', 'h1').get('checkboxes').findProperty('component', 'c1').get('checked')).to.equal(test.e); |
| }); |
| }); |
| }); |
| |
| describe('#getCurrentMastersBlueprint', function () { |
| var tests = Em.A([ |
| { |
| masterComponentHosts: Em.A([ |
| {hostName: 'h1', component: 'c1'} |
| ]), |
| hosts: [{hostName: 'h1'}], |
| m: 'one host and one component', |
| e:{ |
| blueprint: { |
| host_groups: [ |
| { |
| name: 'host-group-1', |
| components: [ |
| { name: 'c1' } |
| ] |
| } |
| ] |
| }, |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| name: 'host-group-1', |
| hosts: [ |
| { fqdn: 'h1' } |
| ] |
| } |
| ] |
| } |
| } |
| }, |
| { |
| masterComponentHosts: Em.A([ |
| {hostName: 'h1', component: 'c1'}, |
| {hostName: 'h2', component: 'c2'}, |
| {hostName: 'h2', component: 'c3'} |
| ]), |
| hosts: [{hostName: 'h1'}, {hostName: 'h2'}, {hostName: 'h3'}], |
| m: 'multiple hosts and multiple components', |
| e: { |
| blueprint: { |
| host_groups: [ |
| { |
| name: 'host-group-1', |
| components: [ |
| { name: 'c1' } |
| ] |
| }, |
| { |
| name: 'host-group-2', |
| components: [ |
| { name: 'c2' }, |
| { name: 'c3' } |
| ] |
| }, |
| { |
| name: 'host-group-3', |
| components: [] |
| } |
| ] |
| }, |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| name: 'host-group-1', |
| hosts: [ |
| { fqdn: 'h1' } |
| ] |
| }, |
| { |
| name: 'host-group-2', |
| hosts: [ |
| { fqdn: 'h2' } |
| ] |
| }, |
| { |
| name: 'host-group-3', |
| hosts: [ |
| { fqdn: 'h3' } |
| ] |
| } |
| ] |
| } |
| } |
| } |
| ]); |
| tests.forEach(function (test) { |
| it(test.m, function () { |
| controller.set('content.masterComponentHosts', test.masterComponentHosts); |
| controller.set('hosts', test.hosts); |
| var r = controller.getCurrentMastersBlueprint(); |
| expect(r).to.eql(test.e); |
| }); |
| }); |
| }); |
| |
| describe('#getCurrentBlueprint', function () { |
| var tests = Em.A([ |
| { |
| clientComponents: Em.A([{component_name: "name1"}]), |
| hosts: Em.A([ |
| Em.Object.create({ |
| checkboxes: Em.A([ |
| Em.Object.create({ |
| component: 'c1', |
| checked: true |
| }), |
| Em.Object.create({ |
| component: 'CLIENT', |
| checked: true |
| }) |
| ]) |
| }) |
| ]), |
| m: 'one host and one component', |
| e:{ |
| blueprint: { |
| host_groups: [ |
| { |
| name: 'host-group-1', |
| components: [ |
| { name: 'c1' }, |
| { name: 'name1' } |
| ] |
| } |
| ] |
| }, |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| name: 'host-group-1', |
| hosts: [ |
| {} |
| ] |
| } |
| ] |
| } |
| } |
| } |
| ]); |
| tests.forEach(function (test) { |
| it(test.m, function () { |
| controller.set('content.clients', test.clientComponents); |
| controller.set('hosts', test.hosts); |
| var r = controller.getCurrentBlueprint(); |
| expect(JSON.parse(JSON.stringify(r))).to.eql(JSON.parse(JSON.stringify(test.e))); |
| }); |
| }); |
| }); |
| |
| describe('#callServerSideValidation', function () { |
| |
| var cases = [ |
| { |
| controllerName: 'installerController', |
| hosts: [ |
| { |
| hostName: 'h0' |
| }, |
| { |
| hostName: 'h1' |
| } |
| ], |
| expected: [ |
| ['c0', 'c6'], |
| ['c1', 'c3', 'c8'] |
| ] |
| }, |
| { |
| controllerName: 'addServiceController', |
| hosts: [ |
| { |
| hostName: 'h0' |
| }, |
| { |
| hostName: 'h1' |
| } |
| ], |
| expected: [ |
| ['c0', 'c6'], |
| ['c1', 'c3', 'c8'] |
| ] |
| }, |
| { |
| controllerName: 'addHostController', |
| hosts: [ |
| { |
| hostName: 'h0' |
| } |
| ], |
| expected: [ |
| ['c0', 'c2', 'c5', 'c6'], |
| ['c1', 'c2', 'c3', 'c5', 'c8'] |
| ] |
| } |
| ], |
| expectedHostGroups = [ |
| { |
| name: 'host-group-1', |
| fqdn: 'h0' |
| }, |
| { |
| name: 'host-group-2', |
| fqdn: 'h1' |
| } |
| ]; |
| |
| beforeEach(function () { |
| controller.get('content').setProperties({ |
| recommendations: { |
| blueprint: { |
| host_groups: [ |
| { |
| components: [ |
| { |
| name: 'c6' |
| } |
| ], |
| name: 'host-group-1' |
| }, |
| { |
| components: [ |
| { |
| name: 'c8' |
| } |
| ], |
| name: 'host-group-2' |
| } |
| ] |
| }, |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| hosts: [ |
| { |
| fqdn: 'h0' |
| } |
| ], |
| name: 'host-group-1' |
| }, |
| { |
| hosts: [ |
| { |
| fqdn: 'h1' |
| } |
| ], |
| name: 'host-group-2' |
| }] |
| } |
| }, |
| clients: [ |
| { |
| component_name: 'c3' |
| } |
| ] |
| }); |
| sinon.stub(App.StackService, 'find', function () { |
| return [ |
| Em.Object.create({ |
| serviceName: 's0', |
| isSelected: true |
| }), |
| Em.Object.create({ |
| serviceName: 's1', |
| isInstalled: true, |
| isSelected: true |
| }) |
| ]; |
| }); |
| sinon.stub(App.StackServiceComponent, 'find', function () { |
| return [ |
| Em.Object.create({ |
| componentName: 'c0', |
| isSlave: true |
| }), |
| Em.Object.create({ |
| componentName: 'c1', |
| isSlave: true, |
| isShownOnInstallerSlaveClientPage: true |
| }), |
| Em.Object.create({ |
| componentName: 'c2', |
| isSlave: true, |
| isShownOnInstallerSlaveClientPage: false |
| }), |
| Em.Object.create({ |
| componentName: 'c3', |
| isClient: true |
| }), |
| Em.Object.create({ |
| componentName: 'c4', |
| isClient: true, |
| isRequiredOnAllHosts: false |
| }), |
| Em.Object.create({ |
| componentName: 'c5', |
| isClient: true, |
| isRequiredOnAllHosts: true |
| }), |
| Em.Object.create({ |
| componentName: 'c6', |
| isMaster: true, |
| isShownOnInstallerAssignMasterPage: true |
| }), |
| Em.Object.create({ |
| componentName: 'c7', |
| isMaster: true, |
| isShownOnInstallerAssignMasterPage: false |
| }), |
| Em.Object.create({ |
| componentName: 'c8', |
| isMaster: true, |
| isShownOnAddServiceAssignMasterPage: true |
| }), |
| Em.Object.create({ |
| componentName: 'c9', |
| isMaster: true, |
| isShownOnAddServiceAssignMasterPage: false |
| }) |
| ]; |
| }); |
| sinon.stub(controller, 'getCurrentBlueprint', function () { |
| return { |
| blueprint: { |
| host_groups: [ |
| { |
| components: [ |
| { |
| name: 'c0' |
| } |
| ], |
| name: 'host-group-1' |
| }, |
| { |
| components: [ |
| { |
| name: 'c1' |
| }, |
| { |
| name: 'c3' |
| } |
| ], |
| name: 'host-group-2' |
| } |
| ] |
| }, |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| hosts: [ |
| { |
| fqdn: 'h0' |
| } |
| ], |
| name: 'host-group-1' |
| }, |
| { |
| hosts: [ |
| { |
| fqdn: 'h1' |
| } |
| ], |
| name: 'host-group-2' |
| }] |
| } |
| }; |
| }); |
| sinon.stub(controller, 'getCurrentMastersBlueprint', function () { |
| return { |
| blueprint: { |
| host_groups: [ |
| { |
| components: [ |
| { |
| name: 'c6' |
| } |
| ], |
| name: 'host-group-1' |
| }, |
| { |
| components: [ |
| { |
| name: 'c8' |
| } |
| ], |
| name: 'host-group-2' |
| } |
| ] |
| }, |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| hosts: [ |
| { |
| fqdn: 'h0' |
| } |
| ], |
| name: 'host-group-1' |
| }, |
| { |
| hosts: [ |
| { |
| fqdn: 'h1' |
| } |
| ], |
| name: 'host-group-2' |
| }] |
| } |
| }; |
| }); |
| sinon.stub(App, 'get').withArgs('components.clients').returns(['c3', 'c4']); |
| sinon.stub(controller, 'getCurrentMasterSlaveBlueprint', function () { |
| return { |
| blueprint: { |
| host_groups: [ |
| { |
| components: [ |
| { |
| name: 'c6' |
| } |
| ], |
| name: 'host-group-1' |
| }, |
| { |
| components: [ |
| { |
| name: 'c8' |
| } |
| ], |
| name: 'host-group-2' |
| } |
| ] |
| }, |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| hosts: [ |
| { |
| fqdn: 'h0' |
| } |
| ], |
| name: 'host-group-1' |
| }, |
| { |
| hosts: [ |
| { |
| fqdn: 'h1' |
| } |
| ], |
| name: 'host-group-2' |
| }] |
| } |
| }; |
| }); |
| sinon.stub(App.Host, 'find', function () { |
| return [ |
| { |
| hostName: 'h1' |
| } |
| ]; |
| }); |
| }); |
| |
| afterEach(function () { |
| App.StackService.find.restore(); |
| App.StackServiceComponent.find.restore(); |
| controller.getCurrentBlueprint.restore(); |
| controller.getCurrentMastersBlueprint.restore(); |
| App.get.restore(); |
| controller.getCurrentMasterSlaveBlueprint.restore(); |
| App.Host.find.restore(); |
| }); |
| |
| cases.forEach(function (item) { |
| describe(item.controllerName, function () { |
| |
| beforeEach(function () { |
| controller.set('hosts', item.hosts); |
| controller.set('content.controllerName', item.controllerName); |
| controller.callServerSideValidation(); |
| }); |
| |
| it('blueprint.host_groups count is correct', function () { |
| expect(controller.get('content.recommendationsHostGroups.blueprint.host_groups.length')).to.equal(expectedHostGroups.length); |
| }); |
| |
| it('blueprint_cluster_binding.host_groups count is correct', function () { |
| expect(controller.get('content.recommendationsHostGroups.blueprint_cluster_binding.host_groups.length')).to.equal(expectedHostGroups.length); |
| }); |
| |
| item.expected.forEach(function (e, index) { |
| it('components are valid for group# ' + (index + 1), function () { |
| expect(controller.get('content.recommendationsHostGroups.blueprint.host_groups')[index].components.mapProperty('name').sort()).to.be.eql(e); |
| }); |
| }); |
| |
| expectedHostGroups.forEach(function (group) { |
| it(group.name, function () { |
| var bpGroup = controller.get('content.recommendationsHostGroups.blueprint_cluster_binding.host_groups').findProperty('name', group.name); |
| expect(bpGroup.hosts).to.have.length(1); |
| expect(bpGroup.hosts[0].fqdn).to.equal(group.fqdn); |
| }); |
| }); |
| |
| }); |
| }); |
| |
| }); |
| |
| describe('#isAllCheckboxesEmpty', function () { |
| |
| Em.A([ |
| { |
| m: 'all checkboxes are not empty', |
| hosts: [ |
| {checkboxes: [{checked: true}, {checked: true}]}, |
| {checkboxes: [{checked: true}, {checked: true}]} |
| ], |
| e: false |
| }, |
| { |
| m: 'some checkboxes are empty', |
| hosts: [ |
| {checkboxes: [{checked: true}, {checked: false}]}, |
| {checkboxes: [{checked: true}, {checked: false}]} |
| ], |
| e: false |
| }, |
| { |
| m: 'all checkboxes are empty', |
| hosts: [ |
| {checkboxes: [{checked: false}, {checked: false}]}, |
| {checkboxes: [{checked: false}, {checked: false}]} |
| ], |
| e: true |
| } |
| ]).forEach(function (test) { |
| |
| it(test.m, function () { |
| controller.set('hosts', test.hosts); |
| expect(controller.isAllCheckboxesEmpty()).to.be.equal(test.e); |
| }); |
| |
| }); |
| |
| }); |
| |
| describe('#loadStep', function () { |
| |
| beforeEach(function () { |
| sinon.stub(controller, 'render', Em.K); |
| sinon.stub(controller, 'callValidation', Em.K); |
| sinon.stub(App.StackService, 'find').returns([ |
| Em.Object.create({ |
| isSelected: true, |
| serviceName: 's1', |
| serviceComponents: [ |
| Em.Object.create({isShownOnInstallerSlaveClientPage: true, componentName: 's1c1', isRequired: true}), |
| Em.Object.create({isShownOnInstallerSlaveClientPage: true, componentName: 's1c2', isRequired: true}) |
| ] |
| }), |
| Em.Object.create({ |
| isSelected: true, |
| serviceName: 's2', |
| serviceComponents: [ |
| Em.Object.create({isShownOnInstallerSlaveClientPage: true, componentName: 's2c3', isRequired: false}), |
| Em.Object.create({isShownOnInstallerSlaveClientPage: true, componentName: 's2c4', isRequired: false}) |
| ] |
| }), |
| Em.Object.create({ |
| isInstalled: true, |
| serviceName: 's3', |
| serviceComponents: [ |
| Em.Object.create({isShownOnInstallerSlaveClientPage: true, componentName: 's3c1', isRequired: true}), |
| Em.Object.create({isShownOnInstallerSlaveClientPage: true, componentName: 's3c2', isRequired: true}) |
| ] |
| }), |
| Em.Object.create({ |
| isInstalled: true, |
| serviceName: 's4', |
| serviceComponents: [ |
| Em.Object.create({isShownOnInstallerSlaveClientPage: true, componentName: 's4c3', isRequired: false}), |
| Em.Object.create({isShownOnInstallerSlaveClientPage: true, componentName: 's4c4', isRequired: false}) |
| ] |
| }) |
| ]); |
| }); |
| |
| afterEach(function () { |
| controller.render.restore(); |
| controller.callValidation.restore(); |
| App.StackService.find.restore(); |
| }); |
| |
| describe('isInstallerWizard', function () { |
| |
| beforeEach(function () { |
| controller.set('content', { |
| clients: [{}], |
| controllerName: 'installerController' |
| }); |
| controller.loadStep(); |
| }); |
| |
| it('component names are valid', function () { |
| expect(controller.get('headers').mapProperty('name')).to.be.eql(['s1c1', 's1c2', 's2c3', 's2c4', 'CLIENT']); |
| }); |
| |
| it('component labels are valid', function () { |
| expect(controller.get('headers').mapProperty('label')).to.be.eql(['S1c1', 'S1c2', 'S2c3', 'S2c4', 'Client']); |
| }); |
| |
| it('everyone allChecked is false', function () { |
| expect(controller.get('headers').everyProperty('allChecked', false)).to.be.true; |
| }); |
| |
| it('component required-flags are valid', function () { |
| expect(controller.get('headers').mapProperty('isRequired')).to.be.eql([true, true, false, false, undefined]); |
| }); |
| |
| it('everyone noChecked is false', function () { |
| expect(controller.get('headers').everyProperty('noChecked', true)).to.be.true; |
| }); |
| |
| it('everyone isDisabled is false', function () { |
| expect(controller.get('headers').everyProperty('isDisabled', false)).to.be.true; |
| }); |
| |
| it('component allId-fields are valid', function () { |
| expect(controller.get('headers').mapProperty('allId')).to.be.eql(['all-s1c1', 'all-s1c2', 'all-s2c3', 'all-s2c4', 'all-CLIENT']); |
| }); |
| |
| it('component noneId-fields are valid', function () { |
| expect(controller.get('headers').mapProperty('noneId')).to.be.eql(['none-s1c1', 'none-s1c2', 'none-s2c3', 'none-s2c4', 'none-CLIENT']); |
| }); |
| |
| }); |
| |
| describe('isAddHostWizard', function () { |
| |
| beforeEach(function () { |
| controller.set('content', { |
| clients: [{}], |
| controllerName: 'addHostController' |
| }); |
| controller.loadStep(); |
| }); |
| |
| it('component names are valid', function () { |
| expect(controller.get('headers').mapProperty('name')).to.be.eql(['s3c1', 's3c2', 's4c3', 's4c4', 'CLIENT']); |
| }); |
| |
| it('component labels are valid', function () { |
| expect(controller.get('headers').mapProperty('label')).to.be.eql(['S3c1', 'S3c2', 'S4c3', 'S4c4', 'Client']); |
| }); |
| |
| it('everyone allChecked is false', function () { |
| expect(controller.get('headers').everyProperty('allChecked', false)).to.be.true; |
| }); |
| |
| it('component required-flags are valid', function () { |
| expect(controller.get('headers').mapProperty('isRequired')).to.be.eql([true, true, false, false, undefined]); |
| }); |
| |
| it('everyone noChecked is false', function () { |
| expect(controller.get('headers').everyProperty('noChecked', true)).to.be.true; |
| }); |
| |
| it('everyone isDisabled is false', function () { |
| expect(controller.get('headers').everyProperty('isDisabled', false)).to.be.true; |
| }); |
| |
| it('component allId-fields are valid', function () { |
| expect(controller.get('headers').mapProperty('allId')).to.be.eql(['all-s3c1', 'all-s3c2', 'all-s4c3', 'all-s4c4', 'all-CLIENT']); |
| }); |
| |
| it('component noneId-fields are valid', function () { |
| expect(controller.get('headers').mapProperty('noneId')).to.be.eql(['none-s3c1', 'none-s3c2', 'none-s4c3', 'none-s4c4', 'none-CLIENT']); |
| }); |
| |
| }); |
| |
| describe('isAddServiceWizard', function () { |
| |
| beforeEach(function () { |
| controller.set('content', { |
| clients: [{}], |
| controllerName: 'addServiceController' |
| }); |
| controller.loadStep(); |
| }); |
| |
| it('component names are valid', function () { |
| expect(controller.get('headers').mapProperty('name')).to.be.eql(['s3c1', 's3c2', 's4c3', 's4c4', 's1c1', 's1c2', 's2c3', 's2c4', 'CLIENT']); |
| }); |
| |
| it('component labels are valid', function () { |
| expect(controller.get('headers').mapProperty('label')).to.be.eql(['S3c1', 'S3c2', 'S4c3', 'S4c4', 'S1c1', 'S1c2', 'S2c3', 'S2c4', 'Client']); |
| }); |
| |
| it('everyone allChecked is false', function () { |
| expect(controller.get('headers').everyProperty('allChecked', false)).to.be.true; |
| }); |
| |
| it('component required-flags are valid', function () { |
| expect(controller.get('headers').mapProperty('isRequired')).to.be.eql([true, true, false, false, true, true, false, false, undefined]); |
| }); |
| |
| it('everyone noChecked is false', function () { |
| expect(controller.get('headers').everyProperty('noChecked', true)).to.be.true; |
| }); |
| |
| it('installed services are disabled', function () { |
| expect(controller.get('headers').mapProperty('isDisabled', false)).to.be.eql([true, true, true, true, false, false, false, false, false]); |
| }); |
| |
| it('component allId-fields are valid', function () { |
| expect(controller.get('headers').mapProperty('allId')).to.be.eql(['all-s3c1', 'all-s3c2', 'all-s4c3', 'all-s4c4', 'all-s1c1', 'all-s1c2', 'all-s2c3', 'all-s2c4', 'all-CLIENT']); |
| }); |
| |
| it('component noneId-fields are valid', function () { |
| expect(controller.get('headers').mapProperty('noneId')).to.be.eql(['none-s3c1', 'none-s3c2', 'none-s4c3', 'none-s4c4', 'none-s1c1', 'none-s1c2', 'none-s2c3', 'none-s2c4', 'none-CLIENT']); |
| }); |
| |
| }); |
| |
| }); |
| |
| describe('#anyHostErrors', function () { |
| |
| var tests = [ |
| { |
| it: "anyHostErrors returns true if errorMessages are defined", |
| host: Em.A([Em.Object.create({ |
| errorMessages: "Error Message" |
| })]), |
| result: true |
| }, |
| { |
| it: "anyHostErrors returns false if errorMessages are not defined", |
| host: Em.A([Em.Object.create({ |
| })]), |
| result: false |
| } |
| ]; |
| |
| tests.forEach(function(test) { |
| it(test.it, function() { |
| controller.set('hosts', test.host); |
| expect(controller.get('anyHostErrors')).to.equal(test.result); |
| }) |
| }); |
| }); |
| |
| |
| |
| describe('#anyHostWarnings', function () { |
| |
| var tests = [ |
| { |
| it: "anyHostWarnings returns true if warnMessages are defined", |
| host: Em.A([Em.Object.create({ |
| warnMessages: "Warning Message" |
| })]), |
| result: true |
| }, |
| { |
| it: "anyHostWarnings returns false if warnMessages are not defined", |
| host: Em.A([Em.Object.create({ |
| })]), |
| result: false |
| } |
| ]; |
| |
| tests.forEach(function(test) { |
| it(test.it, function() { |
| controller.set('hosts', test.host); |
| expect(controller.get('anyHostWarnings')).to.equal(test.result); |
| }) |
| }); |
| }); |
| |
| describe('#enableCheckboxesForDependentComponents', function () { |
| |
| beforeEach(function () { |
| sinon.stub(App.StackService, 'find').returns([ |
| Em.Object.create({ |
| serviceName: 's1', |
| isInstalled: false, |
| isSelected: true, |
| serviceComponents: [ |
| Em.Object.create({ |
| componentName: 'c1', |
| isSlave: true, |
| dependencies: [ |
| { |
| serviceName: 's2', |
| componentName: 'c2' |
| } |
| ] |
| }) |
| ] |
| }), |
| Em.Object.create({ |
| serviceName: 's2', |
| isInstalled: true, |
| isSelected: false, |
| serviceComponents: [ |
| Em.Object.create({ |
| componentName: 'c2', |
| isSlave: true, |
| dependencies: [] |
| }) |
| ] |
| }) |
| ]); |
| sinon.stub(App.StackServiceComponent, 'find').returns([ |
| Em.Object.create({ |
| componentName: 'c2', |
| maxToInstall: 2 |
| }) |
| ]); |
| }); |
| |
| afterEach(function () { |
| App.StackService.find.restore(); |
| App.StackServiceComponent.find.restore(); |
| }); |
| |
| it('it should enable appropriate checkboxes', function() { |
| var hostObj = [ |
| { |
| checkboxes: [ |
| { |
| component: 'c1', |
| isInstalled: false, |
| isDisabled: false |
| }, |
| { |
| component: 'c2', |
| isInstalled: false, |
| isDisabled: true |
| } |
| ] |
| }, |
| { |
| checkboxes: [ |
| { |
| component: 'c1', |
| isInstalled: false, |
| isDisabled: false |
| }, |
| { |
| component: 'c2', |
| isInstalled: false, |
| isDisabled: true |
| } |
| ] |
| } |
| ]; |
| expect(controller.enableCheckboxesForDependentComponents(hostObj)).to.be.true; |
| expect(hostObj[1].checkboxes[1].isDisabled).to.be.false; |
| }) |
| }); |
| |
| }); |
