| /** |
| * 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('mappers/socket/topology_mapper'); |
| |
| describe('App.topologyMapper', function () { |
| const mapper = App.topologyMapper; |
| |
| |
| describe('#map', function () { |
| const mockCtrl = { |
| updateHost: sinon.spy() |
| }; |
| beforeEach(function () { |
| sinon.stub(mapper, 'applyComponentTopologyChanges'); |
| sinon.stub(App.router, 'get').returns(mockCtrl); |
| App.set('clusterId', 1); |
| }); |
| afterEach(function() { |
| mapper.applyComponentTopologyChanges.restore(); |
| App.router.get.restore(); |
| }); |
| it('applyComponentTopologyChanges should be called', function () { |
| mapper.map({clusters: {1: {components: []}}, eventType: 'UPDATE'}); |
| expect(mapper.applyComponentTopologyChanges.calledWith([], 'UPDATE')).to.be.true; |
| }); |
| it('updateHost should be called on UPDATE event', function () { |
| App.set('allHostNames', []); |
| mapper.map({clusters: {1: {hosts: [{hostName: 'host1'}]}}, eventType: 'UPDATE'}); |
| expect(mockCtrl.updateHost.calledWith(Em.K, null, true)).to.be.true; |
| expect(JSON.stringify(App.get('allHostNames'))).to.be.equal(JSON.stringify(['host1'])); |
| }); |
| it('updateHost should be called on DELETE event', function () { |
| App.set('allHostNames', ['host2']); |
| mapper.map({clusters: {1: {hosts: [{hostName: 'host2'}]}}, eventType: 'DELETE'}); |
| expect(mockCtrl.updateHost.calledWith(Em.K, null, true)).to.be.true; |
| expect(App.get('allHostNames')).to.be.empty; |
| }); |
| }); |
| |
| describe('#applyComponentTopologyChanges', function () { |
| beforeEach(function () { |
| sinon.stub(mapper, 'addServiceIfNew'); |
| sinon.stub(mapper, 'createHostComponent'); |
| sinon.stub(mapper, 'deleteHostComponent'); |
| sinon.stub(mapper, 'deleteServiceIfHasNoComponents'); |
| sinon.stub(App.componentsStateMapper, 'updateComponentCountOnCreate'); |
| sinon.stub(App.componentsStateMapper, 'updateComponentCountOnDelete'); |
| }); |
| afterEach(function() { |
| mapper.addServiceIfNew.restore(); |
| mapper.createHostComponent.restore(); |
| mapper.deleteHostComponent.restore(); |
| mapper.deleteServiceIfHasNoComponents.restore(); |
| App.componentsStateMapper.updateComponentCountOnCreate.restore(); |
| App.componentsStateMapper.updateComponentCountOnDelete.restore(); |
| }); |
| it('CREATE component event', function () { |
| const components = [ |
| { |
| hostNames: ['host1'], |
| serviceName: 'S1', |
| commandParams: {}, |
| publicHostNames: ['public1'] |
| } |
| ]; |
| mapper.applyComponentTopologyChanges(components, 'UPDATE'); |
| expect(mapper.addServiceIfNew.calledWith('S1')).to.be.true; |
| expect(mapper.createHostComponent.calledWith(components[0], 'host1', 'public1')).to.be.true; |
| expect(App.componentsStateMapper.updateComponentCountOnCreate.calledWith(components[0])).to.be.true; |
| }); |
| |
| it('DELETE component event', function () { |
| const components = [ |
| { |
| hostNames: ['host1'], |
| serviceName: 'S1' |
| } |
| ]; |
| mapper.applyComponentTopologyChanges(components, 'DELETE'); |
| expect(mapper.deleteHostComponent.calledWith(components[0], 'host1')).to.be.true; |
| expect(mapper.deleteServiceIfHasNoComponents.calledWith('S1')).to.be.true; |
| expect(App.componentsStateMapper.updateComponentCountOnDelete.calledWith(components[0])).to.be.true; |
| }); |
| }); |
| |
| describe('#addServiceIfNew', function () { |
| beforeEach(function () { |
| sinon.stub(App.Service, 'find').returns(Em.Object.create({isLoaded: false})); |
| sinon.stub(App.store, 'safeLoad'); |
| }); |
| afterEach(function() { |
| App.Service.find.restore(); |
| App.store.safeLoad.restore(); |
| }); |
| it('should load service if it does not exist yet', function () { |
| mapper.addServiceIfNew('S1'); |
| expect(App.store.safeLoad.calledOnce).to.be.true; |
| }); |
| }); |
| |
| describe('#deleteServiceIfHasNoComponents', function () { |
| beforeEach(function () { |
| sinon.stub(App.Service, 'find').returns(Em.Object.create({isLoaded: true, hostComponents: []})); |
| sinon.stub(mapper, 'deleteRecord'); |
| }); |
| afterEach(function() { |
| App.Service.find.restore(); |
| mapper.deleteRecord.restore(); |
| }); |
| it('should delete service record', function () { |
| mapper.deleteServiceIfHasNoComponents('S1'); |
| expect(mapper.deleteRecord.calledOnce).to.be.true; |
| }); |
| }); |
| |
| describe('#deleteHostComponent', function () { |
| beforeEach(function () { |
| sinon.stub(App.HostComponent, 'find').returns(Em.Object.create({isLoaded: true})); |
| sinon.stub(mapper, 'deleteRecord'); |
| sinon.stub(mapper, 'updateHostComponentsOfHost'); |
| sinon.stub(mapper, 'updateHostComponentsOfService'); |
| sinon.stub(App.Host, 'find').returns(Em.Object.create({hostComponents: [{id: 'C1_host1'}]})); |
| sinon.stub(App.Service, 'find').returns(Em.Object.create({hostComponents: [{id: 'C1_host1'}]})); |
| mapper.deleteHostComponent({componentName: 'C1'}, 'host1'); |
| }); |
| afterEach(function() { |
| App.HostComponent.find.restore(); |
| mapper.deleteRecord.restore(); |
| mapper.updateHostComponentsOfHost.restore(); |
| mapper.updateHostComponentsOfService.restore(); |
| App.Host.find.restore(); |
| App.Service.find.restore(); |
| }); |
| it('deleteRecord should be called', function () { |
| expect(mapper.deleteRecord.calledOnce).to.be.true; |
| }); |
| it('updateHostComponentsOfHost should be called', function () { |
| expect(mapper.updateHostComponentsOfHost.calledWith(Em.Object.create({hostComponents: [{id: 'C1_host1'}]}), [])).to.be.true; |
| }); |
| it('updateHostComponentsOfService should be called', function () { |
| expect(mapper.updateHostComponentsOfService.calledWith(Em.Object.create({hostComponents: [{id: 'C1_host1'}]}), [])).to.be.true; |
| }); |
| }); |
| |
| describe('#createHostComponent', function () { |
| beforeEach(function () { |
| sinon.stub(App.store, 'safeLoad'); |
| sinon.stub(mapper, 'updateHostComponentsOfHost'); |
| sinon.stub(mapper, 'updateHostComponentsOfService'); |
| sinon.stub(App.Host, 'find').returns(Em.Object.create({hostComponents: [], isLoaded: true})); |
| sinon.stub(App.Service, 'find').returns(Em.Object.create({hostComponents: []})); |
| mapper.createHostComponent({componentName: 'C1'}, 'host1'); |
| }); |
| afterEach(function() { |
| App.store.safeLoad.restore(); |
| mapper.updateHostComponentsOfHost.restore(); |
| mapper.updateHostComponentsOfService.restore(); |
| App.Host.find.restore(); |
| App.Service.find.restore(); |
| }); |
| it('deleteRecord should be called', function () { |
| expect(App.store.safeLoad.calledOnce).to.be.true; |
| }); |
| it('updateHostComponentsOfHost should be called', function () { |
| expect(mapper.updateHostComponentsOfHost.calledOnce).to.be.true; |
| }); |
| it('updateHostComponentsOfService should be called', function () { |
| expect(mapper.updateHostComponentsOfService.calledOnce).to.be.true; |
| }); |
| }); |
| |
| describe('#updateHostComponentsOfHost', function () { |
| beforeEach(function () { |
| sinon.stub(App.store, 'safeLoad'); |
| }); |
| afterEach(function() { |
| App.store.safeLoad.restore(); |
| }); |
| it('App.store.safeLoad should be called', function () { |
| mapper.updateHostComponentsOfHost(Em.Object.create({id: 1}), [{id: 2}]); |
| expect(App.store.safeLoad.calledWith(App.Host, {id: 1, hostComponents: [{id: 2}]})); |
| }); |
| }); |
| |
| describe('#updateHostComponentsOfService', function () { |
| beforeEach(function () { |
| sinon.stub(App.store, 'safeLoad'); |
| }); |
| afterEach(function() { |
| App.store.safeLoad.restore(); |
| }); |
| it('App.store.safeLoad should be called', function () { |
| mapper.updateHostComponentsOfService(Em.Object.create({id: 1}), [{id: 2}]); |
| expect(App.store.safeLoad.calledWith(App.Service, {id: 1, hostComponents: [{id: 2}]})); |
| }); |
| }); |
| }); |