| /** |
| * 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 blueprintUtils = require('utils/blueprint'); |
| |
| describe('utils/blueprint', function() { |
| var masterBlueprint = { |
| blueprint: { |
| host_groups: [ |
| { |
| name: "host-group-1", |
| components: [ |
| { name: "ZOOKEEPER_SERVER" }, |
| { name: "NAMENODE" }, |
| { name: "HBASE_MASTER" } |
| ] |
| }, |
| { |
| name: "host-group-2", |
| components: [ |
| { name: "SECONDARY_NAMENODE" } |
| ] |
| } |
| ] |
| }, |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| name: "host-group-1", |
| hosts: [ |
| { fqdn: "host1" }, |
| { fqdn: "host2" } |
| ] |
| }, |
| { |
| name: "host-group-2", |
| hosts: [ |
| { fqdn: "host3" } |
| ] |
| } |
| ] |
| } |
| }; |
| |
| var slaveBlueprint = { |
| blueprint: { |
| host_groups: [ |
| { |
| name: "host-group-1", |
| components: [ |
| { name: "DATANODE" } |
| ] |
| }, |
| { |
| name: "host-group-2", |
| components: [ |
| { name: "DATANODE" }, |
| { name: "HDFS_CLIENT" }, |
| { name: "ZOOKEEPER_CLIENT" } |
| ] |
| } |
| ] |
| }, |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| name: "host-group-1", |
| hosts: [ |
| { fqdn: "host3" } |
| ] |
| }, |
| { |
| name: "host-group-2", |
| hosts: [ |
| { fqdn: "host4" }, |
| { fqdn: "host5" } |
| ] |
| } |
| ] |
| } |
| }; |
| |
| describe('#matchGroups', function() { |
| it('should compose same host group into pairs', function() { |
| expect(blueprintUtils.matchGroups(masterBlueprint, slaveBlueprint)).to.deep.equal([ |
| { g1: "host-group-1" }, |
| { g1: "host-group-2", g2: "host-group-1" }, |
| { g2: "host-group-2" } |
| ]); |
| }); |
| }); |
| |
| describe('#filterByComponents', function() { |
| it('should remove all components except', function() { |
| expect(blueprintUtils.filterByComponents(masterBlueprint, ["NAMENODE"])).to.deep.equal({ |
| blueprint: { |
| host_groups: [ |
| { |
| name: "host-group-1", |
| components: [ |
| { name: "NAMENODE" } |
| ] |
| } |
| ] |
| }, |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| name: "host-group-1", |
| hosts: [ |
| { fqdn: "host1" }, |
| { fqdn: "host2" } |
| ] |
| } |
| ] |
| } |
| }); |
| }); |
| }); |
| |
| describe('#addComponentsToBlueprint', function() { |
| it('should add components to blueprint', function() { |
| var components = ["FLUME_HANDLER", "HCAT"]; |
| expect(blueprintUtils.addComponentsToBlueprint(masterBlueprint, components)).to.deep.equal({ |
| blueprint: { |
| host_groups: [ |
| { |
| name: "host-group-1", |
| components: [ |
| { name: "ZOOKEEPER_SERVER" }, |
| { name: "NAMENODE" }, |
| { name: "HBASE_MASTER" }, |
| { name: "FLUME_HANDLER" }, |
| { name: "HCAT" } |
| ] |
| }, |
| { |
| name: "host-group-2", |
| components: [ |
| { name: "SECONDARY_NAMENODE" }, |
| { name: "FLUME_HANDLER" }, |
| { name: "HCAT" } |
| ] |
| } |
| ] |
| }, |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| name: "host-group-1", |
| hosts: [ |
| { fqdn: "host1" }, |
| { fqdn: "host2" } |
| ] |
| }, |
| { |
| name: "host-group-2", |
| hosts: [ |
| { fqdn: "host3" } |
| ] |
| } |
| ] |
| } |
| }); |
| }); |
| }); |
| |
| describe('#mergeBlueprints', function() { |
| it('should merge components', function() { |
| expect(blueprintUtils.mergeBlueprints(masterBlueprint, slaveBlueprint)).to.deep.equal( |
| { |
| blueprint: { |
| host_groups: [ |
| { |
| name: "host-group-1", |
| components: [ |
| { name: "ZOOKEEPER_SERVER" }, |
| { name: "NAMENODE" }, |
| { name: "HBASE_MASTER" } |
| ] |
| }, |
| { |
| name: "host-group-2", |
| components: [ |
| { name: "SECONDARY_NAMENODE" }, |
| { name: "DATANODE" } |
| ] |
| }, |
| { |
| name: "host-group-3", |
| components: [ |
| { name: "DATANODE" }, |
| { name: "HDFS_CLIENT" }, |
| { name: "ZOOKEEPER_CLIENT" } |
| ] |
| } |
| ] |
| }, |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| name: "host-group-1", |
| hosts: [ |
| { fqdn: "host1" }, |
| { fqdn: "host2" } |
| ] |
| }, |
| { |
| name: "host-group-2", |
| hosts: [ |
| { fqdn: "host3" } |
| ] |
| }, |
| { |
| name: "host-group-3", |
| hosts: [ |
| { fqdn: "host4" }, |
| { fqdn: "host5" } |
| ] |
| } |
| ] |
| } |
| } |
| ); |
| }); |
| }); |
| |
| describe('#buildConfigsJSON', function () { |
| var tests = [ |
| { |
| "stepConfigs": [ |
| Em.Object.create({ |
| serviceName: "YARN", |
| configs: [ |
| Em.Object.create({ |
| name: "p1", |
| value: "v1", |
| filename: "yarn-site.xml", |
| isRequiredByAgent: true |
| }), |
| Em.Object.create({ |
| name: "p2", |
| value: "v2", |
| filename: "yarn-site.xml", |
| isRequiredByAgent: true |
| }), |
| Em.Object.create({ |
| name: "p3", |
| value: "v3", |
| filename: "yarn-env.xml", |
| isRequiredByAgent: true |
| }) |
| ] |
| }), |
| Em.Object.create({ |
| serviceName: "MISC", |
| configs: [ |
| Em.Object.create({ |
| name: "user", |
| value: "yarn", |
| filename: "yarn-env.xml", |
| isRequiredByAgent: true |
| }) |
| ] |
| }) |
| ], |
| "configurations": { |
| "yarn-site": { |
| "properties": { |
| "p1": "v1", |
| "p2": "v2" |
| } |
| }, |
| "yarn-env": { |
| "properties": { |
| "p3": "v3", |
| "user": "yarn" |
| } |
| } |
| } |
| } |
| ]; |
| tests.forEach(function (test) { |
| it("generate configs for request (use in validation)", function () { |
| expect(blueprintUtils.buildConfigsJSON(test.stepConfigs)).to.eql(test.configurations); |
| }); |
| }); |
| }); |
| |
| describe('#generateHostGroups()', function () { |
| beforeEach(function() { |
| sinon.stub(blueprintUtils, 'getComponentForHosts').returns({ |
| "host1": ["C1", "C2"], |
| "host2": ["C1", "C3"] |
| }); |
| }); |
| afterEach(function() { |
| blueprintUtils.getComponentForHosts.restore(); |
| }); |
| |
| var tests = [ |
| { |
| "hostNames": ["host1", "host2"], |
| "hostComponents": [ |
| Em.Object.create({ |
| componentName: "C1", |
| hostName: "host1" |
| }), |
| Em.Object.create({ |
| componentName: "C2", |
| hostName: "host1" |
| }), |
| Em.Object.create({ |
| componentName: "C1", |
| hostName: "host2" |
| }), |
| Em.Object.create({ |
| componentName: "C3", |
| hostName: "host2" |
| }) |
| ], |
| result: { |
| blueprint: { |
| host_groups: [ |
| { |
| name: "host-group-1", |
| "components": [ |
| { |
| "name": "C1" |
| }, |
| { |
| "name": "C2" |
| } |
| ] |
| }, |
| { |
| name: "host-group-2", |
| "components": [ |
| { |
| "name": "C1" |
| }, |
| { |
| "name": "C3" |
| } |
| ] |
| } |
| ] |
| }, |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| "name": "host-group-1", |
| "hosts": [ |
| { |
| "fqdn": "host1" |
| } |
| ] |
| }, |
| { |
| "name": "host-group-2", |
| "hosts": [ |
| { |
| "fqdn": "host2" |
| } |
| ] |
| } |
| ] |
| } |
| } |
| } |
| ]; |
| tests.forEach(function (test) { |
| it("generate host groups", function () { |
| expect(blueprintUtils.generateHostGroups(test.hostNames)).to.eql(test.result); |
| }); |
| }); |
| }); |
| |
| describe("#getComponentForHosts()", function() { |
| var res; |
| beforeEach(function() { |
| sinon.stub(App.ClientComponent, 'find').returns([ |
| Em.Object.create({ |
| componentName: "C1", |
| hostNames: ["host1", "host2"] |
| }) |
| ]); |
| sinon.stub(App.SlaveComponent, 'find').returns([ |
| Em.Object.create({ |
| componentName: "C2", |
| hostNames: ["host2", "host3"] |
| }) |
| ]); |
| sinon.stub(App.MasterComponent, 'find').returns([ |
| Em.Object.create({ |
| componentName: "C3", |
| hostNames: ["host3"] |
| }) |
| ]); |
| res = blueprintUtils.getComponentForHosts(); |
| }); |
| afterEach(function() { |
| App.ClientComponent.find.restore(); |
| App.SlaveComponent.find.restore(); |
| App.MasterComponent.find.restore(); |
| }); |
| |
| it('map for 3 items is created', function () { |
| expect(Object.keys(res)).to.have.property('length').equal(3); |
| }); |
| |
| it("host1 map is valid", function() { |
| expect(res.host1.toArray()).to.eql(['C1']); |
| }); |
| it("host2 map is valid", function() { |
| expect(res.host2.toArray()).to.eql(['C1', 'C2']); |
| }); |
| it("host3 map is valid", function() { |
| expect(res.host3.toArray()).to.eql(['C2', 'C3']); |
| }); |
| }); |
| |
| describe('#_generateHostMap', function() { |
| it('generate map', function() { |
| var map = blueprintUtils._generateHostMap({}, ['h1','h2', 'h1'],'c1'); |
| expect(map.h1[0]).to.be.equal('c1'); |
| expect(map.h2[0]).to.be.equal('c1'); |
| }); |
| |
| it('skip generations as hosts is empty', function() { |
| expect(blueprintUtils._generateHostMap({}, [],'c1')).to.eql({}); |
| }); |
| |
| it('skip throws error when data is wrong (should assert error if no data returned from server)', function() { |
| expect(function () { |
| blueprintUtils._generateHostMap(); |
| }).to.throw(Error); |
| }); |
| }); |
| |
| describe('#getHostGroupByFqdn', function() { |
| it('should return `null` if blueprint undefined', function() { |
| expect(blueprintUtils.getHostGroupByFqdn(undefined, 'host1')).to.be.null; |
| }); |
| |
| it('should return `null` if blueprint not valid', function() { |
| expect(blueprintUtils.getHostGroupByFqdn({not_valid_object: {}}, 'host1')).to.be.null; |
| }); |
| |
| it('should find host1-group by host1.name', function() { |
| var bp = { |
| blueprint_cluster_binding: { |
| host_groups: [ |
| { |
| hosts: [ |
| {fqdn: 'host2.name'} |
| ], |
| name: 'host2-group' |
| }, |
| { |
| hosts: [ |
| {fqdn: 'host1.name'} |
| ], |
| name: 'host1-group' |
| } |
| ] |
| } |
| }; |
| expect(blueprintUtils.getHostGroupByFqdn(bp, 'host1.name')).to.be.equal('host1-group'); |
| }); |
| }); |
| |
| describe('#addComponentToHostGroup', function() { |
| it('should add new component to host1-group', function() { |
| var bp = { |
| blueprint: { |
| host_groups: [ |
| { |
| components: [ |
| { name: 'COMPONENT1'} |
| ], |
| name: 'host1-group' |
| } |
| ] |
| } |
| }; |
| var expected = { |
| blueprint: { |
| host_groups: [ |
| { |
| components: [ |
| { name: 'COMPONENT1'}, |
| { name: 'COMPONENT2'} |
| ], |
| name: 'host1-group' |
| } |
| ] |
| } |
| }; |
| expect(blueprintUtils.addComponentToHostGroup(bp, 'COMPONENT2', 'host1-group').toString()).to.eql(expected.toString()); |
| }); |
| |
| it('should skip adding component since it already in host1-group', function() { |
| var bp = { |
| blueprint: { |
| host_groups: [ |
| { |
| components: [ |
| { name: 'COMPONENT1'} |
| ], |
| name: 'host1-group' |
| } |
| ] |
| } |
| }; |
| var expected = { |
| blueprint: { |
| host_groups: [ |
| { |
| components: [ |
| { name: 'COMPONENT1'} |
| ], |
| name: 'host1-group' |
| } |
| ] |
| } |
| }; |
| expect(blueprintUtils.addComponentToHostGroup(bp, 'COMPONENT1', 'host1-group').toString()).to.eql(expected.toString()); |
| }); |
| |
| it('should create components attribute and add component to host1-group', function() { |
| var bp = { |
| blueprint: { |
| host_groups: [ |
| { |
| name: 'host1-group' |
| } |
| ] |
| } |
| }; |
| var expected = { |
| blueprint: { |
| host_groups: [ |
| { |
| components: [ |
| { name: 'COMPONENT1'} |
| ], |
| name: 'host1-group' |
| } |
| ] |
| } |
| }; |
| expect(blueprintUtils.addComponentToHostGroup(bp, 'COMPONENT1', 'host1-group').toString()).to.eql(expected.toString()); |
| }); |
| }); |
| }); |
