| /* |
| * 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. |
| */ |
| |
| import {suite, test} from 'mocha'; |
| import {assert} from 'chai'; |
| import {spy} from 'sinon'; |
| |
| import {TestScheduler} from 'rxjs/testing'; |
| import {Subscriber, Subject, BehaviorSubject} from 'rxjs'; |
| import Controller from './controller'; |
| |
| const mocks = () => new Map([ |
| ['$scope', { |
| $applyAsync: spy((fn) => fn()) |
| }], |
| ['pageService', { |
| setCluster: spy() |
| }], |
| ['Clusters', { |
| discoveries: 1, |
| minMemoryPolicySize: 1000 |
| }], |
| ['ConfigureState', { |
| state$: new Subject() |
| }], |
| ['ConfigurationDownload', { |
| downloadClusterConfiguration: spy() |
| }], |
| ['IgniteVersion', { |
| currentSbj: new BehaviorSubject({ignite: '1.9.0'}), |
| since: (a, b) => a === b |
| }], |
| ['state$', { |
| params: { |
| clusterID: null |
| } |
| }] |
| ]); |
| |
| suite.skip('page-configure-basic component controller', () => { |
| test('$onInit method', () => { |
| const c = new Controller(...mocks().values()); |
| c.getObservable = spy(c.getObservable.bind(c)); |
| c.$onInit(); |
| assert.deepEqual( |
| c.getObservable.lastCall.args, |
| [c.ConfigureState.state$, c.Version.currentSbj], |
| 'calls getObservable with correct arguments' |
| ); |
| assert.instanceOf(c.subscription, Subscriber, 'stores subscription for later'); |
| assert.equal(c.discoveries, 1, 'exposes discoveries'); |
| assert.equal(c.minMemorySize, 1000, 'exposes minMemorySize'); |
| assert.deepEqual( |
| c.sizesMenu, |
| [ |
| {label: 'Kb', value: 1024}, |
| {label: 'Mb', value: 1024 * 1024}, |
| {label: 'Gb', value: 1024 * 1024 * 1024} |
| ], |
| 'exposes sizesMenu' |
| ); |
| assert.equal(c.memorySizeScale, c.sizesMenu[2], 'sets default memorySizeScale to Gb'); |
| assert.deepEqual( |
| c.pageService.setCluster.lastCall.args, ['-1'], |
| 'sets cluster to -1 by clusterID state param is missing' |
| ); |
| }); |
| |
| test('$onDestroy method', () => { |
| const c = new Controller(...mocks().values()); |
| c.$onInit(); |
| c.subscription.unsubscribe = spy(c.subscription.unsubscribe); |
| c.$onDestroy(); |
| assert(c.subscription.unsubscribe.calledOnce, 'unsubscribes from Observable'); |
| }); |
| |
| test('getObservable method', () => { |
| const testScheduler = new TestScheduler((...args) => assert.deepEqual(...args)); |
| const c = new Controller(...mocks().values()); |
| |
| c.applyValue = spy(c.applyValue.bind(c)); |
| |
| const version = 'a-b-'; |
| const state = '-a-b'; |
| const expected = '-abc'; |
| |
| const version$ = testScheduler.createHotObservable(version, { |
| a: {ignite: '1.9.0'}, |
| b: {ignite: '2.0.0'} |
| }); |
| |
| const state$ = testScheduler.createHotObservable(state, { |
| a: { |
| list: { |
| clusters: new Map(), |
| caches: new Map() |
| }, |
| configureBasic: { |
| newClusterCaches: [], |
| oldClusterCaches: [], |
| cluster: null |
| } |
| }, |
| b: { |
| list: { |
| clusters: new Map([ |
| [1, {_id: 1, name: '1', caches: [1, 2]}], |
| [2, {_id: 2, name: '2'}] |
| ]), |
| caches: new Map([ |
| [1, {_id: 1, name: '1'}], |
| [2, {_id: 2, name: '2'}] |
| ]) |
| }, |
| configureBasic: { |
| newClusterCaches: [], |
| oldClusterCaches: [ |
| {_id: 1, name: '1'}, |
| {_id: 2, name: '2'} |
| ], |
| cluster: {_id: 1, name: '1', caches: [1, 2]} |
| } |
| } |
| }); |
| |
| |
| const expectedValues = { |
| a: { |
| clusters: new Map(), |
| caches: new Map(), |
| state: { |
| newClusterCaches: [], |
| oldClusterCaches: [], |
| cluster: null |
| }, |
| allClusterCaches: [], |
| cachesMenu: [], |
| defaultMemoryPolicy: void 0, |
| memorySizeInputVisible: false |
| }, |
| b: { |
| clusters: new Map(), |
| caches: new Map(), |
| state: { |
| newClusterCaches: [], |
| oldClusterCaches: [], |
| cluster: null |
| }, |
| allClusterCaches: [], |
| cachesMenu: [], |
| defaultMemoryPolicy: void 0, |
| memorySizeInputVisible: true |
| }, |
| c: { |
| clusters: new Map([ |
| [1, {_id: 1, name: '1', caches: [1, 2]}], |
| [2, {_id: 2, name: '2'}] |
| ]), |
| caches: new Map([ |
| [1, {_id: 1, name: '1'}], |
| [2, {_id: 2, name: '2'}] |
| ]), |
| state: { |
| newClusterCaches: [], |
| oldClusterCaches: [ |
| {_id: 1, name: '1'}, |
| {_id: 2, name: '2'} |
| ], |
| cluster: {_id: 1, name: '1', caches: [1, 2]} |
| }, |
| allClusterCaches: [ |
| {_id: 1, name: '1'}, |
| {_id: 2, name: '2'} |
| ], |
| cachesMenu: [ |
| {_id: 1, name: '1'}, |
| {_id: 2, name: '2'} |
| ], |
| defaultMemoryPolicy: void 0, |
| memorySizeInputVisible: true |
| } |
| }; |
| |
| testScheduler.expectObservable(c.getObservable(state$, version$)).toBe(expected, expectedValues); |
| testScheduler.flush(); |
| |
| assert.deepEqual(c.applyValue.getCall(0).args[0], expectedValues.a, 'applies value a'); |
| assert.deepEqual(c.applyValue.getCall(1).args[0], expectedValues.b, 'applies value b'); |
| assert.deepEqual(c.applyValue.getCall(2).args[0], expectedValues.c, 'applies value c'); |
| assert.equal(c.applyValue.callCount, 3, 'applyValue was called correct amount of times'); |
| }); |
| }); |