From b0f2f345cc2d1cc3812ad8a06fc1898daf5842d0 Mon Sep 17 00:00:00 2001 From: Adam Wudzinski Date: Tue, 26 Mar 2019 16:47:06 +0100 Subject: Remove unused code Remove unsed code from generic-components and change tests directory structure to reflect src structure Change-Id: Iada2efb0f7cfb05557eb7cd709b8a0ed75976b03 Issue-ID: AAI-1618 Signed-off-by: awudzins --- test/app/MainScreenWrapperReducer.test.js | 486 +++++++++++++++++++++ .../ConfigurableViewActions.test.js | 208 +++++++++ .../ConfigurableViewReducer.test.js | 54 +++ .../GlobalAutoCompleteSearchBar.test.js | 35 ++ .../GlobalAutoCompleteSearchBarReducer.test.js | 154 +++++++ .../GlobalInlineMessageBar.test.js | 37 ++ .../GlobalInlineMessageBarAction.test.js | 42 ++ .../GlobalInlineMessageBarReducer.test.js | 40 ++ test/app/networking/NetworkCalls.test.js | 124 ++++++ test/app/networking/NetworkUtil.test.js | 22 + test/app/tierSupport/SelectedNodeDetails.test.js | 141 ++++++ .../tierSupport/SelectedNodeDetailsReducer.test.js | 248 +++++++++++ test/app/tierSupport/TierSupportActions.test.js | 177 ++++++++ test/app/tierSupport/TierSupportReducer.test.js | 206 +++++++++ test/app/vnfSearch/VnfSearch.test.js | 49 +++ test/app/vnfSearch/VnfSearchActions.test.js | 215 +++++++++ .../vnfSearch/VnfSearchNfRoleVisualization.test.js | 154 +++++++ .../vnfSearch/VnfSearchNfTypeVisualization.test.js | 154 +++++++ ...nfSearchOrchestratedStatusVisualization.test.js | 154 +++++++ .../VnfSearchProvStatusVisualization.test.js | 154 +++++++ test/app/vnfSearch/VnfSearchReducer.test.js | 438 +++++++++++++++++++ .../VnfSearchTotalCountVisualization.test.js | 131 ++++++ 22 files changed, 3423 insertions(+) create mode 100644 test/app/MainScreenWrapperReducer.test.js create mode 100644 test/app/configurableViews/ConfigurableViewActions.test.js create mode 100644 test/app/configurableViews/ConfigurableViewReducer.test.js create mode 100644 test/app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBar.test.js create mode 100644 test/app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBarReducer.test.js create mode 100644 test/app/globalInlineMessageBar/GlobalInlineMessageBar.test.js create mode 100644 test/app/globalInlineMessageBar/GlobalInlineMessageBarAction.test.js create mode 100644 test/app/globalInlineMessageBar/GlobalInlineMessageBarReducer.test.js create mode 100644 test/app/networking/NetworkCalls.test.js create mode 100644 test/app/networking/NetworkUtil.test.js create mode 100644 test/app/tierSupport/SelectedNodeDetails.test.js create mode 100644 test/app/tierSupport/SelectedNodeDetailsReducer.test.js create mode 100644 test/app/tierSupport/TierSupportActions.test.js create mode 100644 test/app/tierSupport/TierSupportReducer.test.js create mode 100644 test/app/vnfSearch/VnfSearch.test.js create mode 100644 test/app/vnfSearch/VnfSearchActions.test.js create mode 100644 test/app/vnfSearch/VnfSearchNfRoleVisualization.test.js create mode 100644 test/app/vnfSearch/VnfSearchNfTypeVisualization.test.js create mode 100644 test/app/vnfSearch/VnfSearchOrchestratedStatusVisualization.test.js create mode 100644 test/app/vnfSearch/VnfSearchProvStatusVisualization.test.js create mode 100644 test/app/vnfSearch/VnfSearchReducer.test.js create mode 100644 test/app/vnfSearch/VnfSearchTotalCountVisualization.test.js (limited to 'test/app') diff --git a/test/app/MainScreenWrapperReducer.test.js b/test/app/MainScreenWrapperReducer.test.js new file mode 100644 index 0000000..e9324cc --- /dev/null +++ b/test/app/MainScreenWrapperReducer.test.js @@ -0,0 +1,486 @@ +import thunk from 'redux-thunk'; +import randstr from 'randomstring'; +import configureMockStore from 'redux-mock-store'; + +import MainScreenWrapperReducer from 'app/MainScreenWrapperReducer' +import {aaiActionTypes} from 'app/MainScreenWrapperConstants'; +import {getPersonalizationDetails} from 'app/personlaization/PersonalizationActions'; +import {getInvalidSearchInputEvent} from'app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBarActions'; +import {extensibleViewNetworkCallback, showMainMenu, clearExtensibleViewData, setSecondaryTitle} from 'app/MainScreenWrapperActionHelper'; +import {externalUrlRequest, getSubscriptionPayload} from 'app/contextHandler/ContextHandlerActions' + +import {globalInlineMessageBarActionTypes} from "app/globalInlineMessageBar/GlobalInlineMessageBarConstants"; +import {globalAutoCompleteSearchBarActionTypes} from "app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBarConstants"; +import { + contextHandlerActionTypes, + FAILED_REQUEST, + MULTIPLE_RESULT, SUBSCRIPTION_FAILED_MESSAGE, + WRONG_EXTERNAL_REQUEST_MESSAGE, + WRONG_RESULT, + ZERO_RESULT +} from "app/contextHandler/ContextHandlerConstants"; +import {PERSONALIZATION_FAILED_MESSAGE, personalizationActionTypes} from "app/personlaization/PersonalizationConstans"; + +describe('MainScreenWrapperReducerTests', () => { + fetch = require('jest-fetch-mock'); + const mockStore = configureMockStore([thunk])(); + const initialState = {Baz : 'Fooo'}; + const error = '401'; + + beforeEach(() => { + fetch.resetMocks(); + mockStore.clearActions(); + }); + + describe('extensibleViewNetworkCallbackTests', () => { + const paramName = 'boo'; + const postBody = 'baz'; + const curView = {Boz : 'Fooz'}; + const requestUrl = 'www.foo.com'; + const response = {Foo: 'Bar'}; + + describe('success tests', () => { + beforeEach(async () => { + //given + fetch.once(JSON.stringify(response)); + await mockStore.dispatch(extensibleViewNetworkCallback(requestUrl, postBody, paramName, curView)); + }); + + it('action on success test', () => { + //when + const [action, ...rest] = mockStore.getActions(); + + //then + expect(rest).toEqual([]); + expect(action.type).toBe(aaiActionTypes.EXTENSIBLE_VIEW_NETWORK_CALLBACK_RESPONSE_RECEIVED); + }); + + it('reducer on success test', () => { + //given + const [action, ..._] = mockStore.getActions(); + + //when + const { + extensibleViewNetworkCallbackData, + ...rest + } = MainScreenWrapperReducer(initialState, action); + + //then + expect(rest).toEqual(initialState); + expect(extensibleViewNetworkCallbackData).toEqual({ + boo: response, + ...curView + }); + }); + }); + + describe('failure tests', () => { + beforeEach(async () => { + //given + fetch.mockRejectOnce(error); + await mockStore.dispatch(extensibleViewNetworkCallback(requestUrl, postBody, paramName, curView)); + }); + + it('action on failure test', () => { + //given + const [firstAction, secondAction, ...tail] = mockStore.getActions(); + + //then + expect(tail).toEqual([]); + expect(firstAction.type).toEqual(globalInlineMessageBarActionTypes.SET_GLOBAL_MESSAGE); + expect(secondAction.type).toEqual(aaiActionTypes.EXTENSIBLE_VIEW_NETWORK_CALLBACK_RESPONSE_RECEIVED); + }); + + it('reducer on failure test', () => { + //given + const [firstAction, secondAction, ..._] = mockStore.getActions(); + + //when + const afterFirstState = MainScreenWrapperReducer(initialState, firstAction); + const { + extensibleViewNetworkCallbackData, + ...rest + } = MainScreenWrapperReducer(initialState, secondAction); + + //then + expect(afterFirstState).toEqual(initialState); + expect(rest).toEqual(initialState); + expect(extensibleViewNetworkCallbackData).toEqual({ + boo: {}, + ...curView + }); + }); + }); + }); + + describe.each([true, false])('showMainMenuTests', value => { + beforeEach(async () => { + //given + await mockStore.dispatch(showMainMenu(value)); + }); + + it('action on show: ' + value + ' test', () => { + //when + const [action, ...rest] = mockStore.getActions(); + + //then + expect(rest).toEqual([]); + expect(action.type).toBe(aaiActionTypes.AAI_SHOW_MENU); + }); + + it('reducer on show: ' + value + ' test', () => { + //given + const [action, ..._] = mockStore.getActions(); + + //when + const { + showMenu, + toggleButtonActive, + ...rest + } = MainScreenWrapperReducer(initialState, action); + + //then + expect(rest).toEqual(initialState); + expect(showMenu).toBe(value); + expect(toggleButtonActive).toBe(value); + }); + }); + + describe('clearExtensibleViewDataTests', () => { + beforeEach(async () => { + //given + await mockStore.dispatch(clearExtensibleViewData()); + }); + + it('action test', () => { + //when + const [action, ...rest] = mockStore.getActions(); + + //then + expect(rest).toEqual([]); + expect(action.type).toBe(aaiActionTypes.EXTENSIBLE_VIEW_NETWORK_CALLBACK_CLEAR_DATA); + }); + + it('reducer test', () => { + //given + const [action, ..._] = mockStore.getActions(); + + //when + const { + extensibleViewNetworkCallbackData, + ...rest + } = MainScreenWrapperReducer(initialState, action); + + expect(rest).toEqual(initialState); + expect(extensibleViewNetworkCallbackData).toEqual({}); + }); + }); + + describe('getInvalidSearchInputEventTests', () => { + const msg = randstr.generate(); + + beforeEach(async () => { + await mockStore.dispatch(getInvalidSearchInputEvent(msg)); + }); + + it('action msg: ' + msg + ' test', () => { + //when + const [action, ...rest] = mockStore.getActions(); + + //then + expect(rest).toEqual([]); + expect(action.type).toBe(globalAutoCompleteSearchBarActionTypes.SEARCH_WARNING_EVENT); + }); + + it('reducer msg: ' + msg + ' test', () => { + //given + const [action, ..._] = mockStore.getActions(); + + //when + const { + extensibleViewNetworkCallbackData, + ...rest + } = MainScreenWrapperReducer(initialState, action); + + //then + expect(rest).toEqual(initialState); + expect(extensibleViewNetworkCallbackData).toEqual({clearView : true}); + }); + }); + + describe('externalUrlRequestTests', () => { + const someUrlParams = 'view=A&entityId=B&entityType=C'; + + describe.each([{ + title: 'on empty url params', + prepareMock: () => {}, + urlParams: '', + expectedResponse: WRONG_EXTERNAL_REQUEST_MESSAGE + }, { + title: 'on request rejected by the server', + prepareMock: () => fetch.mockRejectOnce('401'), + urlParams: someUrlParams, + expectedResponse: FAILED_REQUEST + }, { + title: 'on empty suggestions', + prepareMock: () => fetch.once(JSON.stringify({})), + urlParams: someUrlParams, + expectedResponse: WRONG_RESULT + }, { + title: 'on no results', + prepareMock: () => fetch.once(JSON.stringify({totalFound: 0, suggestions: []})), + urlParams: someUrlParams, + expectedResponse: ZERO_RESULT + }, { + title: 'on multiple results', + prepareMock: () => fetch.once(JSON.stringify({totalFound: 2, suggestions: ['Foo', 'Bar']})), + urlParams: someUrlParams, + expectedResponse: MULTIPLE_RESULT + }])('failure tests', ({title, prepareMock, urlParams, expectedResponse}) => { + beforeEach(async () => { + //given + prepareMock(); + await mockStore.dispatch(externalUrlRequest(urlParams)); + }); + + it('action ' + title + ' test', () => { + //when + const [action, ...rest] = mockStore.getActions(); + + //then + expect(rest).toEqual([]); + expect(action.type).toBe(globalInlineMessageBarActionTypes.SET_GLOBAL_MESSAGE); + expect(action.data.msgText).toEqual(expectedResponse); + }); + + it('reducer ' + title + ' test', () => { + //given + const [action, ..._] = mockStore.getActions(); + + //when + const state = MainScreenWrapperReducer(initialState, action); + + //then + expect(state).toEqual(initialState); + }); + }); + + describe("success tests", () => { + //given + const response = {totalFound: 1, suggestions: ['Foo']}; + + beforeEach(async () => { + //given + fetch.resetMocks(); + fetch.once(JSON.stringify(response)); + + await mockStore.dispatch(externalUrlRequest(someUrlParams)); + }); + + it('action on exactly one suggestion test', () => { + //when + const [firstAction, secondAction, ...rest] = mockStore.getActions(); + + //then + expect(rest).toEqual([]); + expect(firstAction.type).toBe( globalInlineMessageBarActionTypes.CLEAR_GLOBAL_MESSAGE); + expect(secondAction.type).toBe(contextHandlerActionTypes.SINGLE_SUGGESTION_FOUND); + }); + + it('reducer on exactly one suggestion test', () => { + //given + const [firstAction, secondAction, ..._] = mockStore.getActions(); + + //when + const state = MainScreenWrapperReducer(initialState, firstAction); + const { + externalRequestFound, + ...rest + } = MainScreenWrapperReducer(state, secondAction); + + //then + expect(state).toEqual(initialState); + expect(rest).toEqual(initialState); + expect(externalRequestFound).toEqual({suggestion: response.suggestions[0]}); + }); + }); + }); + + describe('setSecondaryTitleTests', () => { + //given + const title = randstr.generate(); + + beforeEach(async () => { + //given + await mockStore.dispatch(setSecondaryTitle(title)); + }); + + it('action test', () => { + //when + const [action, ...rest] = mockStore.getActions(); + + //then + expect(rest).toEqual([]); + expect(action.type).toBe(aaiActionTypes.SET_SECONDARY_TITLE); + }); + + it('reducer test', () => { + //given + const [action, ..._] = mockStore.getActions(); + + //when + const { + secondaryTitle, + ...rest + } = MainScreenWrapperReducer(initialState, action); + + //then + expect(rest).toEqual(initialState); + expect(secondaryTitle).toEqual(title); + }); + }); + + describe('getSubscriptionPayloadTests', () => { + describe('failure tests', () => { + beforeEach(async () => { + //given + fetch.mockRejectOnce(error); + await mockStore.dispatch(getSubscriptionPayload()); + }); + + it('action on request rejected by server test', async () => { + //when + const [action, ...rest] = mockStore.getActions(); + + //then + expect(rest).toEqual([]); + expect(action.type).toBe(globalInlineMessageBarActionTypes.SET_GLOBAL_MESSAGE); + expect(action.data.msgText).toEqual(SUBSCRIPTION_FAILED_MESSAGE); + }); + + it('reducer on request rejected by server test', async () => { + //given + const [action, ..._] = mockStore.getActions(); + + //when + const state = MainScreenWrapperReducer(initialState, action); + + //then + expect(state).toEqual(initialState); + }); + }); + + const subscriptionData = 'Foo'; + + describe.each([{ + title: 'on disabled subscription', + payload: {subscriptionEnabled: false}, + type: contextHandlerActionTypes.SUBSCRIPTION_PAYLOAD_EMPTY, + detail : undefined + }, { + title: 'on enabled subscription', + payload: {subscriptionEnabled: true, subscriptionDetails: subscriptionData}, + type: contextHandlerActionTypes.SUBSCRIPTION_PAYLOAD_FOUND, + detail : subscriptionData + }])('success tests', ({title, payload, type, detail}) => { + beforeEach(async () => { + //given + fetch.once(JSON.stringify(payload)); + await mockStore.dispatch(getSubscriptionPayload()); + }); + + it('action ' + title + ' test', () => { + //when + const [action, ...rest] = mockStore.getActions(); + + //then + expect(rest).toEqual([]); + expect(action.type).toBe(type); + }); + + it('reducer ' + title + ' test', () => { + //given + const [action, ..._] = mockStore.getActions(); + + //when + const { + subscriptionEnabled, + subscriptionPayload, + ...rest + } = MainScreenWrapperReducer(initialState, action); + + //then + expect(rest).toEqual(initialState); + expect(subscriptionEnabled).toBe(payload.subscriptionEnabled); + expect(subscriptionPayload).toEqual(detail); + }); + }); + }); + + describe("getPersonalizationDetailsTests", () => { + describe('failure tests', () => { + beforeEach(async () => { + //given + fetch.mockRejectOnce(error); + await mockStore.dispatch(getPersonalizationDetails()); + }); + + it('action on request rejected by server test', () => { + //when + const [action, ...rest] = mockStore.getActions(); + + //then + expect(rest).toEqual([]); + expect(action.type).toBe(globalInlineMessageBarActionTypes.SET_GLOBAL_MESSAGE); + expect(action.data.msgText).toEqual(PERSONALIZATION_FAILED_MESSAGE); + }); + + it('reducer on request rejected by server test', () => { + //given + const [action, ..._] = mockStore.getActions(); + + //when + const state = MainScreenWrapperReducer(initialState, action); + + //then + expect(state).toEqual(initialState); + }); + }); + + describe('success tests', () => { + const personalizationPayload = {topLeftHeader: 'Foo', htmlDocumentTitle: 'Bar'}; + + beforeEach(async () => { + //given + fetch.once(JSON.stringify(personalizationPayload)); + await mockStore.dispatch(getPersonalizationDetails()); + }); + + it('action on personalization payload found test', () => { + //when + const [action, ...rest] = mockStore.getActions(); + + //then + expect(rest).toEqual([]); + expect(action.type).toBe(personalizationActionTypes.PERSONALIZATION_PAYLOAD_FOUND); + }); + + it("Reducer on personalization payload found test", async () => { + //given + const [action, ..._] = mockStore.getActions(); + + //when + const { + aaiTopLeftPersonalizedHeader, + aaiPersonalizedHtmlDocumentTitle, + ...rest + } = MainScreenWrapperReducer(initialState, action); + + //then + expect(rest).toEqual(initialState); + expect(aaiTopLeftPersonalizedHeader).toEqual(personalizationPayload.topLeftHeader); + expect(aaiPersonalizedHtmlDocumentTitle).toEqual(personalizationPayload.htmlDocumentTitle); + }); + }); + }); +}); diff --git a/test/app/configurableViews/ConfigurableViewActions.test.js b/test/app/configurableViews/ConfigurableViewActions.test.js new file mode 100644 index 0000000..9d7bc9e --- /dev/null +++ b/test/app/configurableViews/ConfigurableViewActions.test.js @@ -0,0 +1,208 @@ +import configureStore from 'redux-mock-store'; +import thunk from 'redux-thunk' +import fetchMock from 'fetch-mock'; +import { + configurableViewsActionTypes +} from 'app/configurableViews/ConfigurableViewConstants.js'; +import { + newCustomComponentsEvent, + setCustomRoutes, + getConfigurableViewConfigs +} from 'app/configurableViews/ConfigurableViewActions.js' + + +describe('ConfigurableViewActionTests', () => { + const sampleConfig = { + "id": "aggregateReport", + "title": "Aggregate Report", + "iconURL": "resources/images/sampleAggReportIcon.svg", + "iconHoverURL": "resources/images/sampleAggReportIconHover.svg", + "viewType": "ConfigurableCardView", + "layout": { + "draggable": true, + "resizable": true, + "rowHeight": 100, + "cardMargin": [ + 20, + 20 + ], + "cardPadding": [ + 20, + 20 + ], + "breakpoints": [ + { + "id": "lg", + "col": 12, + "width": 1400 + }, + { + "id": "md", + "col": 8, + "width": 1200 + }, + { + "id": "sm", + "col": 6, + "width": 1024 + } + ] + }, + "components": [ + { + "id": "visualization1", + "title": "Total VNFs", + "queryData": { + "eventId": "visualization1", + "api": "/get-component-data", + "method": "POST", + "headers": { + "accept": "application/json" + }, + "componentDataDescriptor": { + "index": "aggregate_generic-vnf_index", + "queryType": "aggregation", + "query": { + "filter": {}, + "queries": [], + "aggregations": [ + { + "name": "prov-status", + "aggregation": { + "group-by": { + "field": "prov-status", + "size": 0 + } + } + }, + { + "name": "orchestration-status", + "aggregation": { + "group-by": { + "field": "orchestration-status", + "size": 0 + } + } + }, + { + "name": "nf-type", + "aggregation": { + "group-by": { + "field": "nf-type", + "size": 0 + } + } + }, + { + "name": "nf-role", + "aggregation": { + "group-by": { + "field": "nf-role", + "size": 0 + } + } + } + ] + }, + "responseTransformation": { + "type": "count", + "spec": { + "countType": "total", + "countResponseLabel": "display" + } + } + } + }, + "containerData": { + "containerType": "NetworkQueryCard", + "visualizationType": "text", + "visualizationProp": { + "display": "", + "style": { + "textAlign": "center", + "fontSize": "50px", + "fontWeight": "bold", + "paddingTop": "50px" + } + }, + "breakpoints": { + "lg": { + "w": 2, + "h": 2, + "x": 0, + "y": 0 + }, + "md": { + "w": 2, + "h": 2, + "x": 0, + "y": 0 + }, + "sm": { + "w": 6, + "h": 2, + "x": 0, + "y": 0 + } + } + } + } + ] + }; + + it('newCustomComponentsEvent', () => { + const components = [ + { + compId: 'someId', + compName: 'Some Name' + } + ]; + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({}); + store.dispatch(newCustomComponentsEvent(components)); + const actions = store.getActions(); + expect(actions).toEqual([{ + type: configurableViewsActionTypes.CUSTOM_COMPONENTS_RECEIVED, + data: components + }]); + }); + + it('setCustomRoutes', () => { + const routes = [ + { + routeName: 'Some Custom Route', + path: 'some/route/path' + } + ]; + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({}); + store.dispatch(setCustomRoutes(routes)); + const actions = store.getActions(); + expect(actions).toEqual([{ + type: configurableViewsActionTypes.CUSTOM_ROUTES, + data: routes + }]); + }); + + it('getConfigurableViewConfigs', () => { + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({}); + const expectedActions = [ + { + type: configurableViewsActionTypes.CONFIGURABLE_VIEWS_CONFIG_RECEIVED, + data: sampleConfig + } + ]; + fetchMock.mock('*', sampleConfig); + + return store.dispatch(getConfigurableViewConfigs()) + .then( () => { + const actions = store.getActions(); + expect(actions).toEqual(expectedActions); + fetchMock.restore(); + }); + }); +}) diff --git a/test/app/configurableViews/ConfigurableViewReducer.test.js b/test/app/configurableViews/ConfigurableViewReducer.test.js new file mode 100644 index 0000000..0c5c46e --- /dev/null +++ b/test/app/configurableViews/ConfigurableViewReducer.test.js @@ -0,0 +1,54 @@ +import { + configurableViewsActionTypes +} from 'app/configurableViews/ConfigurableViewConstants.js'; +import ConfigurableViewReducer from 'app/configurableViews/ConfigurableViewReducer.js' +describe('ConfigurableViewsReducerTests', () => { + it('Action Type: CONFIGURABLE_VIEWS_CONFIG_RECEIVED', () => { + const data = { + viewId: 'someViewId', + viewName: 'Some View Name', + viewRoute: 'some/view/route' + }; + const action = { + type: configurableViewsActionTypes.CONFIGURABLE_VIEWS_CONFIG_RECEIVED, + data: data + }; + let state = {}; + state = ConfigurableViewReducer(state, action); + expect(state).toEqual({ + configurableViewsConfig: data + }); + }); + + it('Action Type: CUSTOM_COMPONENTS_RECEIVED', () => { + const data = { + componentName: 'someComponentName', + componentData: { + blah: 'blah', + filler: 'filler' + } + }; + const action = { + type: configurableViewsActionTypes.CUSTOM_COMPONENTS_RECEIVED, + data: data + }; + let state = {}; + state = ConfigurableViewReducer(state, action); + expect(state).toEqual({ + customComponents: data + }); + }); + + it('Action Type: CUSTOM_ROUTES', () => { + const data = 'some/custom/route'; + const action = { + type: configurableViewsActionTypes.CUSTOM_ROUTES, + data: data + }; + let state = {}; + state = ConfigurableViewReducer(state, action); + expect(state).toEqual({ + customRoutes: data + }); + }); +}) diff --git a/test/app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBar.test.js b/test/app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBar.test.js new file mode 100644 index 0000000..25676b7 --- /dev/null +++ b/test/app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBar.test.js @@ -0,0 +1,35 @@ +import React from 'react'; +import { mount } from 'enzyme'; +import {Provider} from 'react-redux' +import configureStore from 'redux-mock-store'; + +import GlobalAutoCompleteSearchBar from 'app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBar.jsx' +import AutoCompleteSearchBar from 'generic-components/autoCompleteSearchBar/AutoCompleteSearchBar.jsx'; +import { + globalAutoCompleteSearchBarActionTypes +} from 'app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBarConstants.js'; + +describe('GlobalAutoCompleteSearchBarTests', () => { + const initValue = 'some random search text'; + const initialState = { + globalAutoCompleteSearchBarReducer: { + value: initValue + } + }; + const mockStore = configureStore(); + let store, wrapper; + + beforeEach( () => { + store = mockStore(initialState); + wrapper = mount(); + }) + + it('render search bar - visible', () => { + expect(wrapper).toHaveLength(1); // ensure the message bar is mounted + expect(wrapper.find(AutoCompleteSearchBar)).toHaveLength(1); // ensure the InlineMessage is mounted + }); + + it('props assigned properly', () => { + expect(wrapper.find(AutoCompleteSearchBar).props().value).toEqual(initValue); // check that the props match + }) +}) diff --git a/test/app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBarReducer.test.js b/test/app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBarReducer.test.js new file mode 100644 index 0000000..1078df6 --- /dev/null +++ b/test/app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBarReducer.test.js @@ -0,0 +1,154 @@ +import i18n from 'utils/i18n/i18n'; +import GlobalAutoCompleteSearchBarReducer from 'app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBarReducer.js'; +import { + globalAutoCompleteSearchBarActionTypes, + NO_MATCHES_FOUND +} from 'app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBarConstants.js'; +import { + MESSAGE_LEVEL_WARNING, + MESSAGE_LEVEL_DANGER +} from 'utils/GlobalConstants.js'; + +describe('GlobalAutoCompleteSearchBarReducerTests', () => { + it('Action Type: SUGGESTION_FOUND', () => { + const suggestions = [ + { + entityType: 'some entity type', + value: 'selected value' + }, + { + entityType: 'some entity type', + value: 'other selected value' + } + ]; + const errMsg = 'some error message'; + const action = { + type: globalAutoCompleteSearchBarActionTypes.SUGGESTION_FOUND, + data: { + suggestions: suggestions, + errorMsg: errMsg + } + }; + let state = {}; + state = GlobalAutoCompleteSearchBarReducer(state, action); + expect(state).toEqual({ + suggestions: suggestions, + cachedSuggestions: suggestions, + feedbackMsgText: errMsg, + feedbackMsgSeverity: MESSAGE_LEVEL_DANGER + }); + }); + + it('Action Type: SUGGESTION_NOT_FOUND', () => { + const action = { + type: globalAutoCompleteSearchBarActionTypes.SUGGESTION_NOT_FOUND, + }; + let state = {}; + state = GlobalAutoCompleteSearchBarReducer(state, action); + expect(state).toEqual({ + suggestions: [{ text: i18n(NO_MATCHES_FOUND)}], + cachedSuggestions: [{ entityType: i18n(NO_MATCHES_FOUND)}], + feedbackMsgText: '', + feedbackMsgSeverity: '' + }); + }); + + it('Action Type: CLEAR_SUGGESTIONS_TEXT_FIELD', () => { + const action = { + type: globalAutoCompleteSearchBarActionTypes.CLEAR_SUGGESTIONS_TEXT_FIELD, + }; + let state = {}; + state = GlobalAutoCompleteSearchBarReducer(state, action); + expect(state).toEqual({ + suggestions: [], + cachedSuggestions: [], + value: '', + feedbackMsgText: '', + feedbackMsgSeverity: '', + clearSearchText: false + }); + }); + + it('Action Type: CLEAR_SUGGESTIONS', () => { + const action = { + type: globalAutoCompleteSearchBarActionTypes.CLEAR_SUGGESTIONS, + }; + let state = {}; + state = GlobalAutoCompleteSearchBarReducer(state, action); + expect(state).toEqual({ + suggestions: [] + }); + }); + + it('Action Type: SUGGESTION_CHANGED', () => { + const suggestionText = 'some suggestion text'; + const action = { + type: globalAutoCompleteSearchBarActionTypes.SUGGESTION_CHANGED, + data: suggestionText + }; + let state = {}; + state = GlobalAutoCompleteSearchBarReducer(state, action); + expect(state).toEqual({ + value: suggestionText, + feedbackMsgText: '', + feedbackMsgSeverity: '' + }); + }); + + it('Action Type: SUGGESTION_CLICKED', () => { + const suggestion = { + entityType: 'some entity type', + value: 'selected value' + }; + const action = { + type: globalAutoCompleteSearchBarActionTypes.SUGGESTION_CLICKED, + data: { + selectedSuggestion: suggestion + } + }; + let state = {}; + state = GlobalAutoCompleteSearchBarReducer(state, action); + expect(state).toEqual({ + selectedSuggestion: suggestion, + performPrepareVisualization: true, + feedbackMsgText: '', + feedbackMsgSeverity: '' + }); + }); + + it('Action Type: NETWORK_ERROR', () => { + const errMsg = 'some error message'; + const action = { + type: globalAutoCompleteSearchBarActionTypes.NETWORK_ERROR, + data: { + errorMsg: errMsg + } + }; + let state = {}; + state = GlobalAutoCompleteSearchBarReducer(state, action); + expect(state).toEqual({ + suggestions: [], + cachedSuggestions: [], + feedbackMsgText: errMsg, + feedbackMsgSeverity: MESSAGE_LEVEL_DANGER + }); + }); + + it('Action Type: SEARCH_WARNING_EVENT', () => { + const errMsg = 'some error message'; + const action = { + type: globalAutoCompleteSearchBarActionTypes.SEARCH_WARNING_EVENT, + data: { + errorMsg: errMsg + } + }; + let state = {}; + state = GlobalAutoCompleteSearchBarReducer(state, action); + expect(state).toEqual({ + suggestions: [], + cachedSuggestions: [], + feedbackMsgText: errMsg, + feedbackMsgSeverity: MESSAGE_LEVEL_WARNING + }); + }); +}) diff --git a/test/app/globalInlineMessageBar/GlobalInlineMessageBar.test.js b/test/app/globalInlineMessageBar/GlobalInlineMessageBar.test.js new file mode 100644 index 0000000..9dc2a28 --- /dev/null +++ b/test/app/globalInlineMessageBar/GlobalInlineMessageBar.test.js @@ -0,0 +1,37 @@ +import React from 'react'; +import { mount } from 'enzyme'; +import {Provider} from 'react-redux' +import configureStore from 'redux-mock-store'; + +import GlobalInlineMessageBar from 'app/globalInlineMessageBar/GlobalInlineMessageBar.jsx' +import { + MESSAGE_LEVEL_WARNING +} from 'utils/GlobalConstants.js' +import InlineMessage from 'generic-components/InlineMessage/InlineMessage.jsx'; + +describe('GlobalInlineMessageBarTests', () => { + const errMsg = 'some random message'; + const initialState = { + globalInlineMessageBar: { + feedbackMsgText: errMsg, + feedbackMsgSeverity: MESSAGE_LEVEL_WARNING + } + }; + const mockStore = configureStore(); + let store, wrapper; + + beforeEach( () => { + store = mockStore(initialState); + wrapper = mount(); + }) + + it('render message bar - visible', () => { + expect(wrapper).toHaveLength(1); // ensure the message bar is mounted + expect(wrapper.find(InlineMessage)).toHaveLength(1); // ensure the InlineMessage is mounted + }); + + it('props assigned properly', () => { + expect(wrapper.find(InlineMessage).props().level).toEqual(MESSAGE_LEVEL_WARNING); // check that the props match + expect(wrapper.find(InlineMessage).props().messageTxt).toEqual(errMsg); // check that the props match + }) +}) diff --git a/test/app/globalInlineMessageBar/GlobalInlineMessageBarAction.test.js b/test/app/globalInlineMessageBar/GlobalInlineMessageBarAction.test.js new file mode 100644 index 0000000..4def5ac --- /dev/null +++ b/test/app/globalInlineMessageBar/GlobalInlineMessageBarAction.test.js @@ -0,0 +1,42 @@ +import configureStore from 'redux-mock-store'; +import thunk from 'redux-thunk'; + +import { + getSetGlobalMessageEvent, + getClearGlobalMessageEvent +} from 'app/globalInlineMessageBar/GlobalInlineMessageBarActions.js'; +import { + globalInlineMessageBarActionTypes +} from 'app/globalInlineMessageBar/GlobalInlineMessageBarConstants.js'; +import { + MESSAGE_LEVEL_WARNING +} from 'utils/GlobalConstants.js' + +describe('GlobalInlineMessageBarActionTests', () => { + it('getSetGlobalMessageEvent', () => { + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({}); + const msgText = 'some test msg'; + store.dispatch(getSetGlobalMessageEvent(msgText, MESSAGE_LEVEL_WARNING)); + const actions = store.getActions(); + expect(actions).toEqual([{ + type: globalInlineMessageBarActionTypes.SET_GLOBAL_MESSAGE, + data: { + msgText: msgText, + msgSeverity: MESSAGE_LEVEL_WARNING + } + }]); + }); + + it('getClearGlobalMessageEvent', () => { + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({}); + store.dispatch(getClearGlobalMessageEvent()); + const actions = store.getActions(); + expect(actions).toEqual([{ + type: globalInlineMessageBarActionTypes.CLEAR_GLOBAL_MESSAGE + }]); + }); +}) diff --git a/test/app/globalInlineMessageBar/GlobalInlineMessageBarReducer.test.js b/test/app/globalInlineMessageBar/GlobalInlineMessageBarReducer.test.js new file mode 100644 index 0000000..62389b4 --- /dev/null +++ b/test/app/globalInlineMessageBar/GlobalInlineMessageBarReducer.test.js @@ -0,0 +1,40 @@ +import GlobalInlineMessageBarReducer from 'app/globalInlineMessageBar/GlobalInlineMessageBarReducer.js'; +import { + globalInlineMessageBarActionTypes +} from 'app/globalInlineMessageBar/GlobalInlineMessageBarConstants.js'; +import { + MESSAGE_LEVEL_WARNING +} from 'utils/GlobalConstants.js' + +describe('GlobalInlineMessageBarReducerTests', () => { + it('Action Type: SET_GLOBAL_MESSAGE', () => { + const action = { + type: globalInlineMessageBarActionTypes.SET_GLOBAL_MESSAGE, + data: { + msgText: 'some error message here', + msgSeverity: MESSAGE_LEVEL_WARNING + } + }; + let state = {}; + state = GlobalInlineMessageBarReducer(state, action); + expect(state).toEqual({ + feedbackMsgText: action.data.msgText, + feedbackMsgSeverity: action.data.msgSeverity + }); + }); + + it('Action Type: CLEAR_GLOBAL_MESSAGE', () => { + const action = { + type: globalInlineMessageBarActionTypes.CLEAR_GLOBAL_MESSAGE + }; + let state = { + feedbackMsgText: 'some error message here', + feedbackMsgSeverity: MESSAGE_LEVEL_WARNING + }; + state = GlobalInlineMessageBarReducer(state, action); + expect(state).toEqual({ + feedbackMsgText: '', + feedbackMsgSeverity: '' + }); + }); +}) diff --git a/test/app/networking/NetworkCalls.test.js b/test/app/networking/NetworkCalls.test.js new file mode 100644 index 0000000..373fbac --- /dev/null +++ b/test/app/networking/NetworkCalls.test.js @@ -0,0 +1,124 @@ +import NetworkCalls from 'app/networking/NetworkCalls'; +import * as sinon from "sinon"; + +describe("Network Utils", () => { + + let suite; + + beforeEach(() => { + suite = {}; + suite.sandbox = sinon.createSandbox(); + }); + + afterEach(() => { + suite.sandbox.reset(); + }); + + describe('#fetchRequest', () => { + it('should fetch request', () => { + global.fetch = suite.sandbox.stub(); + + const then = suite.sandbox.stub(); + + fetch.returns({then}); + + NetworkCalls.fetchRequest("URL", "POST", "POST", "HEADER", "BODY"); + sinon.assert.calledOnce(then); + + expect(then.firstCall.args[0]({json: () => "json"})).toEqual("json"); + sinon.assert.calledOnce(fetch); + }); + }); + + describe('#fetchConfigurableViewRequest', () => { + it('fetch configurable request', () => { + const queryData = { + api: "api", + method: "method", + headers: "headers", + componentDataDescriptor: {object: "object"} + }; + + const fetchPromise = Promise.resolve(); + global.fetch = suite.sandbox.stub(); + + global.fetch + .withArgs(queryData.api, { + method: queryData.method, + headers: queryData.headers, + body: queryData.body + }) + .returns(fetchPromise); + + NetworkCalls.fetchConfigurableViewRequest(queryData); + + sinon.assert.calledWith(fetch, "http://localhost:api", { + method: queryData.method, + headers: queryData.headers, + credentials: "same-origin", + body: '{"object":"object"}' + }); + }); + }); + + describe('#fetchRequestObj', () => { + it('fetch request object', () => { + + const fetchPromise = Promise.resolve(); + global.fetch = suite.sandbox.stub(); + const url = 'url'; + + global.fetch + .withArgs(url, { + method: 'GET', + headers: 'POST_HEADER', + body: 'BODY' + + }) + .returns(fetchPromise); + + NetworkCalls.fetchRequestObj(url, "GET", "POST_HEADER", "BODY"); + + sinon.assert.calledWith(fetch, url, { + credentials: 'same-origin', + method: "GET", + headers: "POST_HEADER", + body: "BODY" + }); + }); + }); + + describe('#getRequest', () => { + it("should fetch any request", () => { + const json = suite.sandbox.stub(); + const fetchPromise = Promise.resolve({json}); + global.fetch = suite.sandbox.stub(); + + global.fetch + .withArgs('URL', { + credentials: 'same-origin', + method: 'GET' + }) + .returns(fetchPromise); + + NetworkCalls.getRequest("URL", "GET"); + + return fetchPromise.then(() => { + sinon.assert.calledOnce(json); + }); + }); + }); + + describe('#genericRequest', () => { + it('should fetch any generic request', () => { + global.fetch = suite.sandbox.stub(); + const then = suite.sandbox.stub(); + fetch.returns({then}); + NetworkCalls.genericRequest("localhost", "/relativeUrl", "GET"); + + expect(then.firstCall.args[0]({json: () => "d"})).toEqual("d"); + + sinon.assert.calledOnce(fetch); + }); + }); +}); diff --git a/test/app/networking/NetworkUtil.test.js b/test/app/networking/NetworkUtil.test.js new file mode 100644 index 0000000..1743813 --- /dev/null +++ b/test/app/networking/NetworkUtil.test.js @@ -0,0 +1,22 @@ +import {getTSUIElasticSearchQueryString} from 'app/networking/NetworkUtil'; + +describe("Network Utils", () => { + describe('#getTSUIElasticSearchQueryString', () => { + it('should return query body', () => { + const query = "query"; + const response = getTSUIElasticSearchQueryString(query); + expect(response).toEqual({"maxResults": "10", "queryStr": "query"}); + }); + + it('should return partial request query', () => { + const query = ""; + const response = getTSUIElasticSearchQueryString(query); + expect(response).toEqual({"maxResults": "10", "queryStr": ""}); + }); + + it('should be truthy', () => { + const query = ""; + expect(getTSUIElasticSearchQueryString(query)).toBeTruthy(); + }) + }); +}); diff --git a/test/app/tierSupport/SelectedNodeDetails.test.js b/test/app/tierSupport/SelectedNodeDetails.test.js new file mode 100644 index 0000000..5f97626 --- /dev/null +++ b/test/app/tierSupport/SelectedNodeDetails.test.js @@ -0,0 +1,141 @@ +import React from 'react'; +import { shallow, mount } from 'enzyme'; +import {Provider} from 'react-redux' +import configureStore from 'redux-mock-store'; +import Table from 'react-bootstrap/lib/Table'; + +import ConnectedSelectedNodeDetails, { SelectedNodeDetails } from 'app/tierSupport/selectedNodeDetails/SelectedNodeDetails.jsx'; +import { SELECTED_NODE_TABLE_COLUMN_NAMES } from 'app/tierSupport/selectedNodeDetails/SelectedNodeDetailsConstants.js'; +import LaunchInContext from 'app/tierSupport/launchExternalResource/LaunchExternalResource.jsx'; + +describe('SelectedNodeDetails - Shallow render of component', () => { + let wrapper; + const nodeTypeProp = 'VNF'; + const uidProp = 'SomeValidUIDName'; + const nodeDataProp = { + 'interface-role': 'MPLS', + 'in-maint': 'false', + 'interface-type': 'WAN', + 'port-description': 'MPLS port on 10_NSG16_location4', + 'resource-version': '123456789', + 'interface-name': '10_port1_location4', + 'uri': 'network/pnfs/pnf/10_NSG14_location4/p-interfaces/p-interface/10_port1_location4' + }; + + beforeEach( () => { + wrapper = shallow( + ); + }) + + it('Render basic component', () => { + expect(wrapper.length).toEqual(1); + }); + + it('Verify node type is displayed as a header', () => { + expect(wrapper.contains(

{nodeTypeProp}

)).toBe(true); + expect(wrapper.find('h2')).toHaveLength(1); + }); + + it('Verify uid is displayed', () => { + expect(wrapper.contains({uidProp} )).toBe(true); + }); + + it('Verify node data table is displayed', () => { + // verify table has a row for each node data prop plus one row for the column headers + expect(wrapper.find(Table)).toHaveLength(1); + expect(wrapper.find(Table).props().bsClass).toEqual('ts-selected-node-table'); + expect(wrapper.find(Table).children()).toHaveLength(2); // thead and tbody + + // validate the table header content + expect(wrapper.find('thead')).toHaveLength(1); + let cellClassName; + for (let index = 1; index <= SELECTED_NODE_TABLE_COLUMN_NAMES.length; index++) { + cellClassName = (index % 2 ? 'left-column-cell' : 'right-column-cell'); + expect(wrapper.contains( + {SELECTED_NODE_TABLE_COLUMN_NAMES[index-1]} + )).toBe(true); + } + + // validate the table body content + expect(wrapper.find('tbody')).toHaveLength(1); + expect(wrapper.find('tbody').children()).toHaveLength(7); // 1 row for each of the 7 properties + for (let prop in nodeDataProp) { + expect(wrapper.contains( + {prop} + )).toBe(true); + expect(wrapper.contains( + {nodeDataProp[prop]} + )).toBe(true); + } + }); +}) + +describe('SelectedNodeDetails - Shallow render of component with no node data', () => { + let wrapper; + const nodeTypeProp = 'VNF'; + const uidProp = 'SomeValidUIDName'; + const nodeDataProp = {}; + + beforeEach( () => { + wrapper = shallow( + ); + }) + + it('Render basic component', () => { + expect(wrapper.length).toEqual(1); + }); + + it('Verify node data table is hidden', () => { + // verify table is hidden + expect(wrapper.find(Table)).toHaveLength(1); + expect(wrapper.find(Table).props().bsClass).toEqual('hidden'); + }); +}) + +describe('SelectedNodeDetails - Render React Component (wrapped in )', () => { + const initialState = { + tierSupport: { + launchExternalResourceReducer: { + externalResourcePayload: {} + }, + selectedNodeDetails: { + nodeType: 'VNF', + uid: 'AAI/CLYMR/000509/SD_WAN', + nodeData: { + 'interface-role': 'MPLS', + 'in-maint': 'false', + 'interface-type': 'WAN', + 'port-description': 'MPLS port on 10_NSG16_location4', + 'resource-version': '123456789', + 'interface-name': '10_port1_location4', + 'uri': 'network/pnfs/pnf/10_NSG14_location4/p-interfaces/p-interface/10_port1_location4' + } + } + } + }; + const mockStore = configureStore(); + let store, wrapper; + + beforeEach( () => { + store = mockStore(initialState); + wrapper = mount(); + }) + + it('Render the connected component', () => { + expect(wrapper.find(ConnectedSelectedNodeDetails).length).toEqual(1); + }); + + it('Validate props from store', () => { + expect(wrapper.find(SelectedNodeDetails).props().uid).toEqual(initialState.tierSupport.selectedNodeDetails.uid); + expect(wrapper.find(SelectedNodeDetails).props().nodeType).toEqual(initialState.tierSupport.selectedNodeDetails.nodeType); + expect(wrapper.find(SelectedNodeDetails).props().nodeData).toEqual(initialState.tierSupport.selectedNodeDetails.nodeData); + }); +}) diff --git a/test/app/tierSupport/SelectedNodeDetailsReducer.test.js b/test/app/tierSupport/SelectedNodeDetailsReducer.test.js new file mode 100644 index 0000000..238d21c --- /dev/null +++ b/test/app/tierSupport/SelectedNodeDetailsReducer.test.js @@ -0,0 +1,248 @@ +import SelectedNodeDetailsReducer from 'app/tierSupport/selectedNodeDetails/SelectedNodeDetailsReducer.js'; +import {tierSupportActionTypes} from 'app/tierSupport/TierSupportConstants.js'; +import { + globalAutoCompleteSearchBarActionTypes +} from 'app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBarConstants.js'; + +describe('SelectedNodeDetails - Reducer Tests', () => { + it('Action Type: TS_NODE_SEARCH_RESULTS', () => { + const action = { + type: tierSupportActionTypes.TS_NODE_SEARCH_RESULTS, + data: { + nodes: [ + { + 'id': 'AAI/CLYMR/000509/SD_WAN', + 'itemType': 'service-instance', + 'itemNameKey': 'service-instance.AAI/SPRKY/000509/SD_WAN', + 'itemNameValue': 'AAI/SPRKY/000509/SD_WAN', + 'itemProperties': { + 'service-instance-id': 'AAI/SPRKY/000509/SD_WAN', + 'resource-version':'1508078039815' + }, + 'itemIntegrity' : { + 'entityId' : 'AEEhny_vnf1_under_fw-si1', + 'entityType' : 'vnf', + 'entityLink' : 'cloud-infrastr084-1377-4f49-9c72-f0_location2', + 'initialTimestamp' :'2017-11-13T16:58:01Z', + 'latestValidationTimestamp':'2017-11-13T16:58:01Z', + 'resourceVersion':'1510592264096', + 'violations': [] + }, + 'nodeMeta': { + 'className': 'selectedSearchedNodeClass', + 'nodeDebug': null, + 'selfLinkResponseTimeInMs': 628, + 'relationshipNode': false, + 'searchTarget': true, + 'enrichableNode': false, + 'nodeValidated': true, + 'nodeIssue': false, + 'maxAltitude': 4, + 'nodeType': 'serviceInstance', + 'nodeLabel1':'service-instance', + 'nodeLabel2':'AAI/SPRKY/000509/SD_WAN' + }, + 'rootNode' : false + } + ] + } + }; + let state = { + nodeType: '', + uid: '', + nodeData: {} + }; + state = SelectedNodeDetailsReducer(state, action); + expect(state).toEqual({ + nodeType: action['data']['nodes'][0]['itemType'], + uid: action['data']['nodes'][0]['itemNameValue'], + nodeData: action['data']['nodes'][0]['itemProperties'] + }); + }); + + it('Action Type: TS_NODE_SEARCH_RESULTS - searchTarget === false', () => { + const action = { + type: tierSupportActionTypes.TS_NODE_SEARCH_RESULTS, + data: { + nodes: [ + { + 'id': 'AAI/CLYMR/000509/SD_WAN', + 'itemType': 'service-instance', + 'itemNameKey': 'service-instance.AAI/SPRKY/000509/SD_WAN', + 'itemNameValue': 'AAI/SPRKY/000509/SD_WAN', + 'itemProperties': { + 'service-instance-id': 'AAI/SPRKY/000509/SD_WAN', + 'resource-version':'1508078039815' + }, + 'itemIntegrity' : { + 'entityId' : 'AEEhny_vnf1_under_fw-si1', + 'entityType' : 'vnf', + 'entityLink' : 'cloud-infrastr084-1377-4f49-9c72-f0_location2', + 'initialTimestamp' :'2017-11-13T16:58:01Z', + 'latestValidationTimestamp':'2017-11-13T16:58:01Z', + 'resourceVersion':'1510592264096', + 'violations': [] + }, + 'nodeMeta': { + 'className': 'selectedSearchedNodeClass', + 'nodeDebug': null, + 'selfLinkResponseTimeInMs': 628, + 'relationshipNode': false, + 'searchTarget': false, + 'enrichableNode': false, + 'nodeValidated': true, + 'nodeIssue': false, + 'maxAltitude': 4, + 'nodeType': 'serviceInstance', + 'nodeLabel1':'service-instance', + 'nodeLabel2':'AAI/SPRKY/000509/SD_WAN' + }, + 'rootNode' : false + } + ] + } + }; + let state = { + nodeType: 'Complex', + uid: 'ABC', + nodeData: { + 'service-instance-id': 'blah/blah/blah', + 'resource-version':'123456' + } + }; + state = SelectedNodeDetailsReducer(state, action); + expect(state).toEqual({ + nodeType: '', + uid: '', + nodeData: {} + }); + }); + + it('Action Type: TS_GRAPH_NODE_SELECTED', () => { + const action = { + type: tierSupportActionTypes.TS_GRAPH_NODE_SELECTED, + data: { + itemProperties: { + 'service-instance-id': 'AAI/SPRKY/000509/SD_WAN', + 'resource-version':'1508078039815' + }, + itemType: 'Complex', + itemNameValue: '123456' + } + }; + let state = { + nodeType: '', + uid: '', + nodeData: {} + }; + state = SelectedNodeDetailsReducer(state, action); + expect(state).toEqual({ + nodeType: action['data']['itemType'], + uid: action['data']['itemNameValue'], + nodeData: action['data']['itemProperties'] + }); + }); + + it('Action Type: TIER_SUPPORT_NETWORK_ERROR', () => { + const action = { + type: tierSupportActionTypes.TIER_SUPPORT_NETWORK_ERROR, + }; + let state = { + nodeType: 'Complex', + uid: '12345', + nodeData: { + 'service-instance-id': 'AAI/SPRKY/000509/SD_WAN', + 'resource-version':'1508078039815' + } + }; + state = SelectedNodeDetailsReducer(state, action); + expect(state).toEqual({ + nodeType: '', + uid: '', + nodeData: {} + }); + }); + + it('Action Type: TIER_SUPPORT_CLEAR_DATA', () => { + const action = { + type: tierSupportActionTypes.TIER_SUPPORT_CLEAR_DATA, + }; + let state = { + nodeType: 'Complex', + uid: '12345', + nodeData: { + 'service-instance-id': 'AAI/SPRKY/000509/SD_WAN', + 'resource-version':'1508078039815' + } + }; + state = SelectedNodeDetailsReducer(state, action); + expect(state).toEqual({ + nodeType: '', + uid: '', + nodeData: {} + }); + }); + + it('Action Type: TS_NODE_SEARCH_NO_RESULTS', () => { + const action = { + type: tierSupportActionTypes.TS_NODE_SEARCH_NO_RESULTS, + }; + let state = { + nodeType: 'Complex', + uid: '12345', + nodeData: { + 'service-instance-id': 'AAI/SPRKY/000509/SD_WAN', + 'resource-version':'1508078039815' + } + }; + state = SelectedNodeDetailsReducer(state, action); + expect(state).toEqual({ + nodeType: '', + uid: '', + nodeData: {} + }); + }); + + it('Action Type: SEARCH_WARNING_EVENT', () => { + const action = { + type: globalAutoCompleteSearchBarActionTypes.SEARCH_WARNING_EVENT, + }; + let state = { + nodeType: 'Complex', + uid: '12345', + nodeData: { + 'service-instance-id': 'AAI/SPRKY/000509/SD_WAN', + 'resource-version':'1508078039815' + } + }; + state = SelectedNodeDetailsReducer(state, action); + expect(state).toEqual({ + nodeType: '', + uid: '', + nodeData: {} + }); + }); + + it('Invalid Action Type', () => { + const action = { + type: 'Nonexistent Action Type', + }; + let state = { + nodeType: 'Complex', + uid: '12345', + nodeData: { + 'service-instance-id': 'AAI/SPRKY/000509/SD_WAN', + 'resource-version':'1508078039815' + } + }; + state = SelectedNodeDetailsReducer(state, action); + expect(state).toEqual({ + nodeType: 'Complex', + uid: '12345', + nodeData: { + 'service-instance-id': 'AAI/SPRKY/000509/SD_WAN', + 'resource-version':'1508078039815' + } + }); + }); +}) diff --git a/test/app/tierSupport/TierSupportActions.test.js b/test/app/tierSupport/TierSupportActions.test.js new file mode 100644 index 0000000..62485ee --- /dev/null +++ b/test/app/tierSupport/TierSupportActions.test.js @@ -0,0 +1,177 @@ +import configureStore from 'redux-mock-store'; +import thunk from 'redux-thunk' +import { + onNodeDetailsChange, + splitPaneResize, + onNodeMenuChange, + clearVIData, + setNotificationText +} from 'app/tierSupport/TierSupportActions.js'; +import { + tierSupportActionTypes +} from 'app/tierSupport/TierSupportConstants.js'; +import { + MESSAGE_LEVEL_WARNING +} from 'utils/GlobalConstants.js'; +import { + globalInlineMessageBarActionTypes +} from 'app/globalInlineMessageBar/GlobalInlineMessageBarConstants.js'; + +describe('TierSupportActionTests', () => { + it('onNodeDetailsChange', () => { + const newDetails = { + id: '7352312c7bfa814c3071a803d98c5b670952765974876e55ef954e0f8a930b1c', + itemType: 'complex', + nodeMeta: { + nodeLabel1: 'Artic', + nodeValidated: false, + nodeLocation: 'bottom' + }, + rootNode: false, + index: 2, + }; + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({ tierSupportReducer: {} }); + store.dispatch(onNodeDetailsChange(newDetails)); + const actions = store.getActions(); + expect(actions).toEqual([{ + type: tierSupportActionTypes.TS_GRAPH_NODE_SELECTED, + data: newDetails + }]); + }); + + it('splitPaneResize', () => { + const initialLoad = { + test: 'message' + }; + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({ tierSupportReducer: {} }); + store.dispatch(splitPaneResize(initialLoad)); + const actions = store.getActions(); + expect(actions).toEqual([{ + type: tierSupportActionTypes.SPLIT_PANE_RESIZE, + data: initialLoad + }]); + }); + + it('onNodeMenuChange', () => { + const selectedMenu = { + test: 'menuData' + }; + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({ tierSupportReducer: {} }); + store.dispatch(onNodeMenuChange(selectedMenu)); + const actions = store.getActions(); + expect(actions).toEqual([{ + type: tierSupportActionTypes.TS_GRAPH_NODE_MENU_SELECTED, + data: selectedMenu + }]); + }); + + it('clearVIData', () => { + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({ tierSupportReducer: {} }); + store.dispatch(clearVIData()); + const actions = store.getActions(); + expect(actions).toEqual([{ + type: tierSupportActionTypes.TIER_SUPPORT_CLEAR_DATA + }]); + }); + // + // it('fetchSelectedNodeElement - no results', () => { + // const middlewares = [thunk]; + // const mockStore = configureStore(middlewares); + // const store = mockStore({ tierSupportReducer: {} }); + // const nodes = [ + // { + // id: '7352312c7bfa814c3071a803d98c5b670952765974876e55ef954e0f8a930b1c', + // itemType: 'complex', + // nodeMeta: { + // className: 'selectedSearchedNodeClass', + // nodeLabel1: 'Artic', + // nodeValidated: false, + // nodeLocation: 'bottom' + // }, + // rootNode: false, + // index: 2 + // }, + // { + // id: '3899453d98c5b670952765974876e55ef954e0f8a930b1c', + // itemType: 'generic-vnf', + // nodeMeta: { + // className: 'someOtherClassName', + // nodeLabel1: 'Artic', + // nodeValidated: false, + // nodeLocation: 'bottom' + // }, + // rootNode: false, + // index: 1 + // } + // ]; + // const expectedActions = [ + // { + // type: tierSupportActionTypes.TS_NODE_SEARCH_RESULTS, + // data: { + // nodes: nodes + // } + // }, + // { + // type: tierSupportActionTypes.TS_GRAPH_NODE_SELECTED, + // data: nodes[0] + // } + // ]; + // + // console.log(nodes); + // + // let fetchRequestCallback = () => { + // const results = { + // nodes: nodes + // }; + // let init = { status: 200 }; + // let myBlob = new Blob(); + // let response = new Response(); + // return new Promise((resolve, reject) => { + // resolve(response); + // }); + // }; + // return store.dispatch(fetchSelectedNodeElement(fetchRequestCallback)) + // .then( () => { + // const actions = store.getActions(); + // expect(actions).toEqual(expectedActions); + // }); + // }); + + it('setNotificationText', () => { + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({ tierSupportReducer: {} }); + const msgText = 'some test text'; + const msgSeverity = MESSAGE_LEVEL_WARNING; + store.dispatch(setNotificationText(msgText, msgSeverity)); + const actions = store.getActions(); + expect(actions).toEqual([{ + type: globalInlineMessageBarActionTypes.SET_GLOBAL_MESSAGE, + data: { + msgText: msgText, + msgSeverity: msgSeverity + } + }]); + }); + + it('Clear notification text with setNotificationText', () => { + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({ tierSupportReducer: {} }); + const msgText = ''; + const msgSeverity = MESSAGE_LEVEL_WARNING; + store.dispatch(setNotificationText(msgText, msgSeverity)); + const actions = store.getActions(); + expect(actions).toEqual([{ + type: globalInlineMessageBarActionTypes.CLEAR_GLOBAL_MESSAGE + }]); + }); +}) diff --git a/test/app/tierSupport/TierSupportReducer.test.js b/test/app/tierSupport/TierSupportReducer.test.js new file mode 100644 index 0000000..9825a06 --- /dev/null +++ b/test/app/tierSupport/TierSupportReducer.test.js @@ -0,0 +1,206 @@ +import TierSupportReducer from 'app/tierSupport/TierSupportReducer.js'; +import ForceDirectedGraph from 'generic-components/graph/ForceDirectedGraph.jsx'; +import { + tierSupportActionTypes, + TSUI_GRAPH_MENU_NODE_DETAILS +} from 'app/tierSupport/TierSupportConstants.js'; +import { + MESSAGE_LEVEL_WARNING, + MESSAGE_LEVEL_DANGER +} from 'utils/GlobalConstants.js'; +import { + globalAutoCompleteSearchBarActionTypes +} from 'app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBarConstants.js'; + +describe('TierSupportReducerTests', () => { + it('Action Type: TS_NODE_SEARCH_RESULTS', () => { + ForceDirectedGraph.graphCounter = 0; // ensuring counter is at zero after previous tests + const action = { + type: tierSupportActionTypes.TS_NODE_SEARCH_RESULTS, + data: { + nodes: [ + { + nodeMeta: { + searchTarget: true + }, + itemProperties: 'someProperty' + } + ], + links: ['link', 'information'], + graphMeta: { graph: 'meta' } + } + }; + let graphData = ForceDirectedGraph.generateNewProps(action.data.nodes, action.data.links, + action.data.graphMeta); + ForceDirectedGraph.graphCounter = 0; // ensuring counter is at zero after previous statement + let state = {}; + state = TierSupportReducer(state, action); + expect(state.tierSupportReducer).toEqual({ + forceDirectedGraphRawData: graphData, + feedbackMsgText: '', + feedbackMsgSeverity: '' + }); + }); + + it('Action Type: TS_GRAPH_NODE_MENU_SELECTED', () => { + const action = { + type: tierSupportActionTypes.TS_GRAPH_NODE_MENU_SELECTED, + data: { + attr1: 'someValue', + attr2: 'someOterValue' + } + }; + let state = {}; + state = TierSupportReducer(state, action); + expect(state.tierSupportReducer).toEqual({ + graphNodeSelectedMenu: action.data + }); + }); + + it('Action Type: TS_NODE_SEARCH_NO_RESULTS', () => { + ForceDirectedGraph.graphCounter = 0; // ensuring counter is at zero after previous tests + let emptyNodesAndLinksNoResults = { + graphCounter: 1, + graphMeta: {}, + linkDataArray: [], + nodeDataArray: [] + }; + const action = { + type: tierSupportActionTypes.TS_NODE_SEARCH_NO_RESULTS, + data: { + errorMsg: 'some error message' + } + }; + let state = {}; + state = TierSupportReducer(state, action); + expect(state.tierSupportReducer).toEqual({ + forceDirectedGraphRawData: emptyNodesAndLinksNoResults, + graphNodeSelectedMenu: TSUI_GRAPH_MENU_NODE_DETAILS, + feedbackMsgText: action.data.errorMsg, + feedbackMsgSeverity: MESSAGE_LEVEL_WARNING + }); + }); + + it('Action Type: TIER_SUPPORT_NETWORK_ERROR', () => { + ForceDirectedGraph.graphCounter = 0; // ensuring counter is at zero after previous tests + let emptyNodesAndLinksNoResults = { + graphCounter: 1, + graphMeta: {}, + linkDataArray: [], + nodeDataArray: [] + }; + const action = { + type: tierSupportActionTypes.TIER_SUPPORT_NETWORK_ERROR, + data: { + errorMsg: 'some error message' + } + }; + let state = {}; + state = TierSupportReducer(state, action); + expect(state.tierSupportReducer).toEqual({ + forceDirectedGraphRawData: emptyNodesAndLinksNoResults, + graphNodeSelectedMenu: TSUI_GRAPH_MENU_NODE_DETAILS, + feedbackMsgText: action.data.errorMsg, + feedbackMsgSeverity: MESSAGE_LEVEL_DANGER + }); + }); + + it('Action Type: TIER_SUPPORT_CLEAR_DATA', () => { + ForceDirectedGraph.graphCounter = 0; // ensuring counter is at zero after previous tests + let emptyNodesAndLinksNoResults = { + graphCounter: 1, + graphMeta: {}, + linkDataArray: [], + nodeDataArray: [] + }; + const action = { + type: tierSupportActionTypes.TIER_SUPPORT_CLEAR_DATA + }; + let state = {}; + state = TierSupportReducer(state, action); + expect(state.tierSupportReducer).toEqual({ + forceDirectedGraphRawData: emptyNodesAndLinksNoResults, + graphNodeSelectedMenu: TSUI_GRAPH_MENU_NODE_DETAILS, + feedbackMsgText: '', + feedbackMsgSeverity: '' + }); + }); + + it('Action Type: TS_GRAPH_NODE_SELECTED', () => { + const action = { + type: tierSupportActionTypes.TS_GRAPH_NODE_SELECTED, + data: 'some action data' + }; + let state = {}; + state = TierSupportReducer(state, action); + expect(state.tierSupportReducer).toEqual({ + nodeData: action.data + }); + }); + + it('Action Type: TIER_SUPPORT_ACTIVATE_BUSY_FEEDBACK', () => { + const action = { + type: tierSupportActionTypes.TIER_SUPPORT_ACTIVATE_BUSY_FEEDBACK, + }; + let state = {}; + state = TierSupportReducer(state, action); + expect(state.tierSupportReducer).toEqual({ + enableBusyFeedback: true + }); + }); + + it('Action Type: TIER_SUPPORT_DISABLE_BUSY_FEEDBACK', () => { + const action = { + type: tierSupportActionTypes.TIER_SUPPORT_DISABLE_BUSY_FEEDBACK, + }; + let state = {}; + state = TierSupportReducer(state, action); + expect(state.tierSupportReducer).toEqual({ + enableBusyFeedback: false + }); + }); + + it('Action Type: SEARCH_WARNING_EVENT', () => { + ForceDirectedGraph.graphCounter = 0; // ensuring counter is at zero after previous tests + let emptyNodesAndLinksNoResults = { + graphCounter: 1, + graphMeta: {}, + linkDataArray: [], + nodeDataArray: [] + }; + const action = { + type: globalAutoCompleteSearchBarActionTypes.SEARCH_WARNING_EVENT, + data: { + errorMsg: 'some warning msg' + } + }; + let state = {}; + state = TierSupportReducer(state, action); + expect(state.tierSupportReducer).toEqual({ + forceDirectedGraphRawData: emptyNodesAndLinksNoResults, + graphNodeSelectedMenu: TSUI_GRAPH_MENU_NODE_DETAILS + }); + }); + + it('Action Type: TS_OVERLAY_NETWORK_CALLBACK_RESPONSE_RECEIVED', () => { + const action = { + type: tierSupportActionTypes.TS_OVERLAY_NETWORK_CALLBACK_RESPONSE_RECEIVED, + data: { + curData: { + attr1: 'value1', + attr2: 'value2' + }, + paramName: 'attr2', + overlayData: 'someValue2' + } + }; + let state = {}; + state = TierSupportReducer(state, action); + expect(state.tierSupportReducer).toEqual({ + nodeData: { + attr1: 'value1', + attr2: 'someValue2' + } + }); + }); +}) diff --git a/test/app/vnfSearch/VnfSearch.test.js b/test/app/vnfSearch/VnfSearch.test.js new file mode 100644 index 0000000..3875543 --- /dev/null +++ b/test/app/vnfSearch/VnfSearch.test.js @@ -0,0 +1,49 @@ +import React from 'react'; +import { shallow, mount } from 'enzyme'; +import {Provider} from 'react-redux'; +import configureStore from 'redux-mock-store'; + +import ConnectedVnfSearch, { vnfSearch } from 'app/vnfSearch/VnfSearch.jsx'; + +describe('VnfSearch - Shallow render of component', () => { + let wrapper; + const vnfFilters = {}; + const vnfVisualizationPanelClass = 'collapsible-panel-main-panel'; + const unifiedFilterValues = {}; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Render basic component', () => { + expect(wrapper.length).toEqual(1); + }); +}) +// +// describe('VnfSearch - Render React Component (wrapped in )', () => { +// const initialState = { +// vnfSearch: {} +// }; +// const mockStore = configureStore(); +// let store, wrapper; +// +// beforeEach( () => { +// store = mockStore(initialState); +// wrapper = mount(); +// }) +// +// it('Render the connected component', () => { +// expect(wrapper.find(ConnectedVnfSearch).length).toEqual(1); +// }); +// +// it('Validate props from store', () => { +// expect(wrapper.find(VnfSearchNfRoleVisualization).props().enableBusyFeedback).toEqual(initialState.vnfSearch.enableBusyFeedback); +// expect(wrapper.find(VnfSearchNfRoleVisualization).props().processedNfRoleCountChartData).toEqual(initialState.vnfSearch.processedNfRoleCountChartData); +// }); +// }) diff --git a/test/app/vnfSearch/VnfSearchActions.test.js b/test/app/vnfSearch/VnfSearchActions.test.js new file mode 100644 index 0000000..e1c3733 --- /dev/null +++ b/test/app/vnfSearch/VnfSearchActions.test.js @@ -0,0 +1,215 @@ +import configureStore from 'redux-mock-store'; +import thunk from 'redux-thunk' +import fetchMock from 'fetch-mock'; + +import { + processVnfFilterPanelCollapse, + clearVnfSearchData, + setNotificationText, + processVnfVisualizationsOnFilterChange +} from 'app/vnfSearch/VnfSearchActions.js'; +import { + vnfActionTypes, + CHART_PROV_STATUS, + CHART_ORCH_STATUS, + CHART_NF_TYPE, + CHART_NF_ROLE, + TOTAL_VNF_COUNT, + VNF_FILTER_EMPTY_RESULT +} from 'app/vnfSearch/VnfSearchConstants.js'; +import { globalInlineMessageBarActionTypes } from 'app/globalInlineMessageBar/GlobalInlineMessageBarConstants.js'; +import { ERROR_RETRIEVING_DATA } from 'app/networking/NetworkConstants.js'; + +describe('VnfSearchAction - Action Tests', () => { + it('Action: processVnfFilterPanelCollapse - open', () => { + const result = processVnfFilterPanelCollapse(true); + expect(result).toEqual({ + type: vnfActionTypes.VNF_FILTER_PANEL_TOGGLED, + data: { + vnfVisualizationPanelClass: 'collapsible-panel-main-panel vertical-filter-panel-is-open' + } + }); + }); + + it('Action: processVnfFilterPanelCollapse - close', () => { + const result = processVnfFilterPanelCollapse(false); + expect(result).toEqual({ + type: vnfActionTypes.VNF_FILTER_PANEL_TOGGLED, + data: { + vnfVisualizationPanelClass: 'collapsible-panel-main-panel' + } + }); + }); + + it('Action: clearVnfSearchData', () => { + const result = clearVnfSearchData(); + expect(result).toEqual({ + type: vnfActionTypes.VNF_SEARCH_RESULTS_RECEIVED, + data: { + count: '', + provStatusData: CHART_PROV_STATUS.emptyData, + orchStatusData: CHART_ORCH_STATUS.emptyData, + nfTypeData: CHART_NF_TYPE.emptyData, + nfRoleData: CHART_NF_ROLE.emptyData + } + }); + }); + + it('Action: setNotificationText - with message', () => { + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({ vnfSearch: {} }); + store.dispatch(setNotificationText('test error message', 'WARNING')); + const actions = store.getActions(); + expect(actions).toEqual([{ + type: globalInlineMessageBarActionTypes.SET_GLOBAL_MESSAGE, + data: { + msgText: 'test error message', + msgSeverity: 'WARNING' + } + }]); + }); + + it('Action: processVnfVisualizationsOnFilterChange - data for filter values', () => { + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({ vnfSearch: {} }); + const filterValueMap = { + 1: 'Running', + 2: 'Junk', + 7: 'Blah', + 8: 'Doh' + }; + const expectedActions = [ + { type: vnfActionTypes.VNF_ACTIVATE_BUSY_FEEDBACK }, + { type: globalInlineMessageBarActionTypes.CLEAR_GLOBAL_MESSAGE }, + { + type: vnfActionTypes.VNF_SEARCH_RESULTS_RECEIVED, + data: { + count: 10, + provStatusData: { + values: [ + { x: 'junk', y: 10 } + ] + }, + orchStatusData: { + values: [ + { x: 'running', y: 10 } + ] + }, + nfTypeData: { + values: [ + { x: 'doh', y: 10 } + ] + }, + nfRoleData: { + values: [ + { x: 'blah', y: 10 } + ] + } + } + }, + { type: vnfActionTypes.VNF_DISABLE_BUSY_FEEDBACK } + ]; + fetchMock.mock('*', { + "total": 10, + "aggregations":{ + "nf-role":[{"doc_count":10,"key":"blah"}], + "nf-type":[{"doc_count":10,"key":"doh"}], + "prov-status":[{"doc_count":10,"key":"junk"}], + "orchestration-status":[{"doc_count":10,"key":"running"}] + } + }); + + return store.dispatch(processVnfVisualizationsOnFilterChange(filterValueMap)) + .then( () => { + const actions = store.getActions(); + expect(actions).toEqual(expectedActions); + fetchMock.restore(); + }); + }); + + it('Action: processVnfVisualizationsOnFilterChange - no data for filter values', () => { + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({ vnfSearch: {} }); + const filterValueMap = { + 1: 'Running', + 2: 'Junk', + 7: '', + 8: 'Doh' + }; + const expectedActions = [ + { type: vnfActionTypes.VNF_ACTIVATE_BUSY_FEEDBACK }, + { type: globalInlineMessageBarActionTypes.SET_GLOBAL_MESSAGE, + data: { msgSeverity: "warning", msgText: VNF_FILTER_EMPTY_RESULT } + }, + { + type: vnfActionTypes.VNF_SEARCH_RESULTS_RECEIVED, + data: { + count: TOTAL_VNF_COUNT.emptyData, + provStatusData: CHART_PROV_STATUS.emptyData, + orchStatusData: CHART_ORCH_STATUS.emptyData, + nfTypeData: CHART_NF_TYPE.emptyData, + nfRoleData: CHART_NF_ROLE.emptyData + } + }, + { type: vnfActionTypes.VNF_DISABLE_BUSY_FEEDBACK } + ]; + fetchMock.mock('*', { + "total": 0, + "aggregations":{ + "nf-role":[], + "nf-type":[], + "prov-status":[], + "orchestration-status":[] + } + }); + + return store.dispatch(processVnfVisualizationsOnFilterChange(filterValueMap)) + .then( () => { + const actions = store.getActions(); + expect(actions).toEqual(expectedActions); + fetchMock.restore(); + }); + }); + + it('Action: processVnfVisualizationsOnFilterChange - network error', () => { + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({ vnfSearch: {} }); + const filterValueMap = { + 1: 'Running', + 2: 'Junk', + 7: 'Blah', + 8: 'Doh' + }; + const expectedActions = [ + { type: vnfActionTypes.VNF_ACTIVATE_BUSY_FEEDBACK }, + { type: vnfActionTypes.VNF_DISABLE_BUSY_FEEDBACK }, + { + type: vnfActionTypes.VNF_NETWORK_ERROR, + data: { errorMsg: ERROR_RETRIEVING_DATA } + } + ]; + fetchMock.mock('*', 503); + + return store.dispatch(processVnfVisualizationsOnFilterChange(filterValueMap)) + .then( () => { + const actions = store.getActions(); + expect(actions).toEqual(expectedActions); + fetchMock.restore(); + }); + }); + + it('Action: setNotificationText - no message', () => { + const middlewares = [thunk]; + const mockStore = configureStore(middlewares); + const store = mockStore({ vnfSearch: {} }); + store.dispatch(setNotificationText('', '')); + const actions = store.getActions(); + expect(actions).toEqual([{ + type: globalInlineMessageBarActionTypes.CLEAR_GLOBAL_MESSAGE + }]); + }); +}) diff --git a/test/app/vnfSearch/VnfSearchNfRoleVisualization.test.js b/test/app/vnfSearch/VnfSearchNfRoleVisualization.test.js new file mode 100644 index 0000000..2265e6e --- /dev/null +++ b/test/app/vnfSearch/VnfSearchNfRoleVisualization.test.js @@ -0,0 +1,154 @@ +import React from 'react'; +import { shallow, mount } from 'enzyme'; +import {Provider} from 'react-redux' +import configureStore from 'redux-mock-store'; +import { BarChart } from 'recharts'; + +import ConnectedVnfSearchNfRoleVisualization, + { VnfSearchNfRoleVisualization } from 'app/vnfSearch/VnfSearchNfRoleVisualization.jsx'; +import { CHART_NF_ROLE } from 'app/vnfSearch/VnfSearchConstants.js'; +import Spinner from 'utils/SpinnerContainer.jsx'; + +describe('VnfSearchNfRoleVisualization - Shallow render of component', () => { + let wrapper; + const processedNfRoleCountChartDataProp = { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Render basic component', () => { + expect(wrapper.length).toEqual(1); + expect(wrapper.hasClass('visualizations')).toEqual(true); + }); + + it('Verify Spinner is present but not visible', () => { + expect(wrapper.find(Spinner)).toHaveLength(1); + expect(wrapper.find(Spinner).props().loading).toEqual(false); + }); + + it('Verify BarChart is displayed', () => { + expect(wrapper.find(BarChart)).toHaveLength(1); + expect(wrapper.find(BarChart).props().data).toEqual(processedNfRoleCountChartDataProp.values); + }); +}) + +describe('VnfSearchNfRoleVisualization - Shallow render of component with no chart data', () => { + let wrapper; + const processedNfRoleCountChartDataProp = { + values: null + }; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Visualization graph hidden', () => { + expect(wrapper.length).toEqual(1); + expect(['visualizations', 'hidden'].every(className => wrapper.hasClass(className))).toEqual(true); + }); +}) + +describe('VnfSearchNfRoleVisualization - Shallow render of component with busy feedback', () => { + let wrapper; + const processedNfRoleCountChartDataProp = { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Render basic component', () => { + expect(wrapper.length).toEqual(1); + expect(wrapper.hasClass('visualizations')).toEqual(true); + }); + + it('Verify Spinner is present and visible', () => { + expect(wrapper.find(Spinner)).toHaveLength(1); + expect(wrapper.find(Spinner).props().loading).toEqual(true); + }); + + it('Verify BarChart is displayed', () => { + expect(wrapper.find(BarChart)).toHaveLength(1); + expect(wrapper.find(BarChart).props().data).toEqual(processedNfRoleCountChartDataProp.values); + }); +}) + +describe('VnfSearchNfRoleVisualization - Render React Component (wrapped in )', () => { + const initialState = { + vnfSearch: { + processedNfRoleCountChartData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + enableBusyFeedback: false + } + }; + const mockStore = configureStore(); + let store, wrapper; + + beforeEach( () => { + store = mockStore(initialState); + wrapper = mount(); + }) + + it('Render the connected component', () => { + expect(wrapper.find(ConnectedVnfSearchNfRoleVisualization).length).toEqual(1); + }); + + it('Validate props from store', () => { + expect(wrapper.find(VnfSearchNfRoleVisualization).props().enableBusyFeedback).toEqual(initialState.vnfSearch.enableBusyFeedback); + expect(wrapper.find(VnfSearchNfRoleVisualization).props().processedNfRoleCountChartData).toEqual(initialState.vnfSearch.processedNfRoleCountChartData); + }); +}) + +describe('VnfSearchNfRoleVisualization - Render React Component (wrapped in ) with default props', () => { + const initialState = { + vnfSearch: {} + }; + const mockStore = configureStore(); + let store, wrapper; + + beforeEach( () => { + store = mockStore(initialState); + wrapper = mount(); + }) + + it('Render the connected component', () => { + expect(wrapper.find(ConnectedVnfSearchNfRoleVisualization).length).toEqual(1); + }); + + it('Validate default props loaded', () => { + expect(wrapper.find(VnfSearchNfRoleVisualization).props().enableBusyFeedback).toEqual(false); + expect(wrapper.find(VnfSearchNfRoleVisualization).props().processedNfRoleCountChartData).toEqual(CHART_NF_ROLE.emptyData); + }); +}) diff --git a/test/app/vnfSearch/VnfSearchNfTypeVisualization.test.js b/test/app/vnfSearch/VnfSearchNfTypeVisualization.test.js new file mode 100644 index 0000000..485a822 --- /dev/null +++ b/test/app/vnfSearch/VnfSearchNfTypeVisualization.test.js @@ -0,0 +1,154 @@ +import React from 'react'; +import { shallow, mount } from 'enzyme'; +import {Provider} from 'react-redux' +import configureStore from 'redux-mock-store'; +import { BarChart } from 'recharts'; + +import ConnectedVnfSearchNfTypeVisualization, + { VnfSearchNfTypeVisualization } from 'app/vnfSearch/VnfSearchNfTypeVisualization.jsx'; +import { CHART_NF_TYPE } from 'app/vnfSearch/VnfSearchConstants.js'; +import Spinner from 'utils/SpinnerContainer'; + +describe('VnfSearchNfTypeVisualization - Shallow render of component', () => { + let wrapper; + const processedNfTypeCountChartDataProp = { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Render basic component', () => { + expect(wrapper.length).toEqual(1); + expect(wrapper.hasClass('visualizations')).toEqual(true); + }); + + it('Verify Spinner is present but not visible', () => { + expect(wrapper.find(Spinner)).toHaveLength(1); + expect(wrapper.find(Spinner).props().loading).toEqual(false); + }); + + it('Verify BarChart is displayed', () => { + expect(wrapper.find(BarChart)).toHaveLength(1); + expect(wrapper.find(BarChart).props().data).toEqual(processedNfTypeCountChartDataProp.values); + }); +}) + +describe('VnfSearchNfTypeVisualization - Shallow render of component with no chart data', () => { + let wrapper; + const processedNfTypeCountChartDataProp = { + values: null + }; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Visualization graph hidden', () => { + expect(wrapper.length).toEqual(1); + expect(['visualizations', 'hidden'].every(className => wrapper.hasClass(className))).toEqual(true); + }); +}) + +describe('VnfSearchNfTypeVisualization - Shallow render of component with busy feedback', () => { + let wrapper; + const processedNfTypeCountChartDataProp = { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Render basic component', () => { + expect(wrapper.length).toEqual(1); + expect(wrapper.hasClass('visualizations')).toEqual(true); + }); + + it('Verify Spinner is present and visible', () => { + expect(wrapper.find(Spinner)).toHaveLength(1); + expect(wrapper.find(Spinner).props().loading).toEqual(true); + }); + + it('Verify BarChart is displayed', () => { + expect(wrapper.find(BarChart)).toHaveLength(1); + expect(wrapper.find(BarChart).props().data).toEqual(processedNfTypeCountChartDataProp.values); + }); +}) + +describe('VnfSearchNfTypeVisualization - Render React Component (wrapped in )', () => { + const initialState = { + vnfSearch: { + processedNfTypeCountChartData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + enableBusyFeedback: false + } + }; + const mockStore = configureStore(); + let store, wrapper; + + beforeEach( () => { + store = mockStore(initialState); + wrapper = mount(); + }) + + it('Render the connected component', () => { + expect(wrapper.find(ConnectedVnfSearchNfTypeVisualization).length).toEqual(1); + }); + + it('Validate props from store', () => { + expect(wrapper.find(VnfSearchNfTypeVisualization).props().enableBusyFeedback).toEqual(initialState.vnfSearch.enableBusyFeedback); + expect(wrapper.find(VnfSearchNfTypeVisualization).props().processedNfTypeCountChartData).toEqual(initialState.vnfSearch.processedNfTypeCountChartData); + }); +}) + +describe('VnfSearchNfTypeVisualization - Render React Component (wrapped in ) with default props', () => { + const initialState = { + vnfSearch: {} + }; + const mockStore = configureStore(); + let store, wrapper; + + beforeEach( () => { + store = mockStore(initialState); + wrapper = mount(); + }) + + it('Render the connected component', () => { + expect(wrapper.find(ConnectedVnfSearchNfTypeVisualization).length).toEqual(1); + }); + + it('Validate default props loaded', () => { + expect(wrapper.find(VnfSearchNfTypeVisualization).props().enableBusyFeedback).toEqual(false); + expect(wrapper.find(VnfSearchNfTypeVisualization).props().processedNfTypeCountChartData).toEqual(CHART_NF_TYPE.emptyData); + }); +}) diff --git a/test/app/vnfSearch/VnfSearchOrchestratedStatusVisualization.test.js b/test/app/vnfSearch/VnfSearchOrchestratedStatusVisualization.test.js new file mode 100644 index 0000000..2586079 --- /dev/null +++ b/test/app/vnfSearch/VnfSearchOrchestratedStatusVisualization.test.js @@ -0,0 +1,154 @@ +import React from 'react'; +import { shallow, mount } from 'enzyme'; +import {Provider} from 'react-redux' +import configureStore from 'redux-mock-store'; +import { BarChart } from 'recharts'; + +import ConnectedVnfSearchOrchStatusVisualizations, + { VnfSearchOrchStatusVisualizations } from 'app/vnfSearch/VnfSearchOrchestratedStatusVisualization.jsx'; +import { CHART_ORCH_STATUS } from 'app/vnfSearch/VnfSearchConstants.js'; +import Spinner from 'utils/SpinnerContainer'; + +describe('VnfSearchOrchStatusVisualizations - Shallow render of component', () => { + let wrapper; + const processedOrchStatusCountChartDataProp = { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Render basic component', () => { + expect(wrapper.length).toEqual(1); + expect(wrapper.hasClass('visualizations')).toEqual(true); + }); + + it('Verify Spinner is present but not visible', () => { + expect(wrapper.find(Spinner)).toHaveLength(1); + expect(wrapper.find(Spinner).props().loading).toEqual(false); + }); + + it('Verify BarChart is displayed', () => { + expect(wrapper.find(BarChart)).toHaveLength(1); + expect(wrapper.find(BarChart).props().data).toEqual(processedOrchStatusCountChartDataProp.values); + }); +}) + +describe('VnfSearchOrchStatusVisualizations - Shallow render of component with no chart data', () => { + let wrapper; + const processedOrchStatusCountChartDataProp = { + values: null + }; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Visualization graph hidden', () => { + expect(wrapper.length).toEqual(1); + expect(['visualizations', 'hidden'].every(className => wrapper.hasClass(className))).toEqual(true); + }); +}) + +describe('VnfSearchOrchStatusVisualizations - Shallow render of component with busy feedback', () => { + let wrapper; + const processedOrchStatusCountChartDataProp = { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Render basic component', () => { + expect(wrapper.length).toEqual(1); + expect(wrapper.hasClass('visualizations')).toEqual(true); + }); + + it('Verify Spinner is present and visible', () => { + expect(wrapper.find(Spinner)).toHaveLength(1); + expect(wrapper.find(Spinner).props().loading).toEqual(true); + }); + + it('Verify BarChart is displayed', () => { + expect(wrapper.find(BarChart)).toHaveLength(1); + expect(wrapper.find(BarChart).props().data).toEqual(processedOrchStatusCountChartDataProp.values); + }); +}) + +describe('VnfSearchOrchStatusVisualizations - Render React Component (wrapped in )', () => { + const initialState = { + vnfSearch: { + processedOrchStatusCountChartData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + enableBusyFeedback: false + } + }; + const mockStore = configureStore(); + let store, wrapper; + + beforeEach( () => { + store = mockStore(initialState); + wrapper = mount(); + }) + + it('Render the connected component', () => { + expect(wrapper.find(ConnectedVnfSearchOrchStatusVisualizations).length).toEqual(1); + }); + + it('Validate props from store', () => { + expect(wrapper.find(VnfSearchOrchStatusVisualizations).props().enableBusyFeedback).toEqual(initialState.vnfSearch.enableBusyFeedback); + expect(wrapper.find(VnfSearchOrchStatusVisualizations).props().processedOrchStatusCountChartData).toEqual(initialState.vnfSearch.processedOrchStatusCountChartData); + }); +}) + +describe('VnfSearchOrchStatusVisualizations - Render React Component (wrapped in ) with default props', () => { + const initialState = { + vnfSearch: {} + }; + const mockStore = configureStore(); + let store, wrapper; + + beforeEach( () => { + store = mockStore(initialState); + wrapper = mount(); + }) + + it('Render the connected component', () => { + expect(wrapper.find(ConnectedVnfSearchOrchStatusVisualizations).length).toEqual(1); + }); + + it('Validate default props loaded', () => { + expect(wrapper.find(VnfSearchOrchStatusVisualizations).props().enableBusyFeedback).toEqual(false); + expect(wrapper.find(VnfSearchOrchStatusVisualizations).props().processedOrchStatusCountChartData).toEqual(CHART_ORCH_STATUS.emptyData); + }); +}) diff --git a/test/app/vnfSearch/VnfSearchProvStatusVisualization.test.js b/test/app/vnfSearch/VnfSearchProvStatusVisualization.test.js new file mode 100644 index 0000000..f3e7279 --- /dev/null +++ b/test/app/vnfSearch/VnfSearchProvStatusVisualization.test.js @@ -0,0 +1,154 @@ +import React from 'react'; +import { shallow, mount } from 'enzyme'; +import {Provider} from 'react-redux' +import configureStore from 'redux-mock-store'; +import { BarChart } from 'recharts'; + +import ConnectedVnfSearchProvStatusVisualization, + { VnfSearchProvStatusVisualization } from 'app/vnfSearch/VnfSearchProvStatusVisualization.jsx'; +import { CHART_PROV_STATUS } from 'app/vnfSearch/VnfSearchConstants.js'; +import Spinner from 'utils/SpinnerContainer'; + +describe('VnfSearchProvStatusVisualization - Shallow render of component', () => { + let wrapper; + const processedProvStatusCountChartDataProp = { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Render basic component', () => { + expect(wrapper.length).toEqual(1); + expect(wrapper.hasClass('visualizations')).toEqual(true); + }); + + it('Verify Spinner is present but not visible', () => { + expect(wrapper.find(Spinner)).toHaveLength(1); + expect(wrapper.find(Spinner).props().loading).toEqual(false); + }); + + it('Verify BarChart is displayed', () => { + expect(wrapper.find(BarChart)).toHaveLength(1); + expect(wrapper.find(BarChart).props().data).toEqual(processedProvStatusCountChartDataProp.values); + }); +}) + +describe('VnfSearchProvStatusVisualization - Shallow render of component with no chart data', () => { + let wrapper; + const processedProvStatusCountChartDataProp = { + values: null + }; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Visualization graph hidden', () => { + expect(wrapper.length).toEqual(1); + expect(['visualizations', 'hidden'].every(className => wrapper.hasClass(className))).toEqual(true); + }); +}) + +describe('VnfSearchProvStatusVisualization - Shallow render of component with busy feedback', () => { + let wrapper; + const processedProvStatusCountChartDataProp = { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Render basic component', () => { + expect(wrapper.length).toEqual(1); + expect(wrapper.hasClass('visualizations')).toEqual(true); + }); + + it('Verify Spinner is present and visible', () => { + expect(wrapper.find(Spinner)).toHaveLength(1); + expect(wrapper.find(Spinner).props().loading).toEqual(true); + }); + + it('Verify BarChart is displayed', () => { + expect(wrapper.find(BarChart)).toHaveLength(1); + expect(wrapper.find(BarChart).props().data).toEqual(processedProvStatusCountChartDataProp.values); + }); +}) + +describe('VnfSearchProvStatusVisualization - Render React Component (wrapped in )', () => { + const initialState = { + vnfSearch: { + processedProvStatusCountChartData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + enableBusyFeedback: false + } + }; + const mockStore = configureStore(); + let store, wrapper; + + beforeEach( () => { + store = mockStore(initialState); + wrapper = mount(); + }) + + it('Render the connected component', () => { + expect(wrapper.find(ConnectedVnfSearchProvStatusVisualization).length).toEqual(1); + }); + + it('Validate props from store', () => { + expect(wrapper.find(VnfSearchProvStatusVisualization).props().enableBusyFeedback).toEqual(initialState.vnfSearch.enableBusyFeedback); + expect(wrapper.find(VnfSearchProvStatusVisualization).props().processedProvStatusCountChartData).toEqual(initialState.vnfSearch.processedProvStatusCountChartData); + }); +}) + +describe('VnfSearchProvStatusVisualization - Render React Component (wrapped in ) with default props', () => { + const initialState = { + vnfSearch: {} + }; + const mockStore = configureStore(); + let store, wrapper; + + beforeEach( () => { + store = mockStore(initialState); + wrapper = mount(); + }) + + it('Render the connected component', () => { + expect(wrapper.find(ConnectedVnfSearchProvStatusVisualization).length).toEqual(1); + }); + + it('Validate default props loaded', () => { + expect(wrapper.find(VnfSearchProvStatusVisualization).props().enableBusyFeedback).toEqual(false); + expect(wrapper.find(VnfSearchProvStatusVisualization).props().processedProvStatusCountChartData).toEqual(CHART_PROV_STATUS.emptyData); + }); +}) diff --git a/test/app/vnfSearch/VnfSearchReducer.test.js b/test/app/vnfSearch/VnfSearchReducer.test.js new file mode 100644 index 0000000..381a696 --- /dev/null +++ b/test/app/vnfSearch/VnfSearchReducer.test.js @@ -0,0 +1,438 @@ +import VnfSearchReducer from 'app/vnfSearch/VnfSearchReducer.js'; +import { + vnfActionTypes, + CHART_ORCH_STATUS, + CHART_PROV_STATUS, + CHART_NF_ROLE, + CHART_NF_TYPE, + TOTAL_VNF_COUNT +} from 'app/vnfSearch/VnfSearchConstants.js'; +import {ERROR_RETRIEVING_DATA} from 'app/networking/NetworkConstants.js'; +import { + filterBarActionTypes, + MESSAGE_LEVEL_DANGER +} from 'utils/GlobalConstants'; +import { + globalAutoCompleteSearchBarActionTypes +} from 'app/globalAutoCompleteSearchBar/GlobalAutoCompleteSearchBarConstants.js'; + +describe('VnfSearchReducer - Reducer Action Type Tests', () => { + it('Action Type: VNF_NETWORK_ERROR', () => { + const action = { + type: vnfActionTypes.VNF_NETWORK_ERROR + }; + let state = { + processedProvStatusCountChartData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + processedOrchStatusCountChartData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + processedNfTypeCountChartData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + processedNfRoleCountChartData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + count: 20, + feedbackMsgText: '', + feedbackMsgSeverity: '' + }; + state = VnfSearchReducer(state, action); + expect(state).toEqual({ + processedProvStatusCountChartData: CHART_PROV_STATUS.emptyData, + processedOrchStatusCountChartData: CHART_ORCH_STATUS.emptyData, + processedNfTypeCountChartData: CHART_NF_TYPE.emptyData, + processedNfRoleCountChartData: CHART_NF_ROLE.emptyData, + count: TOTAL_VNF_COUNT.emptyValue, + feedbackMsgText: ERROR_RETRIEVING_DATA, + feedbackMsgSeverity: MESSAGE_LEVEL_DANGER + }); + }); + + it('Action Type: SEARCH_WARNING_EVENT', () => { + const action = { + type: globalAutoCompleteSearchBarActionTypes.SEARCH_WARNING_EVENT + }; + let state = { + processedProvStatusCountChartData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + processedOrchStatusCountChartData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + processedNfTypeCountChartData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + processedNfRoleCountChartData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + count: 20, + }; + state = VnfSearchReducer(state, action); + expect(state).toEqual({ + processedProvStatusCountChartData: CHART_PROV_STATUS.emptyData, + processedOrchStatusCountChartData: CHART_ORCH_STATUS.emptyData, + processedNfTypeCountChartData: CHART_NF_TYPE.emptyData, + processedNfRoleCountChartData: CHART_NF_ROLE.emptyData, + count: TOTAL_VNF_COUNT.emptyValue, + }); + }); + + it('Action Type: NEW_SELECTIONS', () => { + const action = { + type: filterBarActionTypes.NEW_SELECTIONS, + data: { + selectedValuesMap: [ + { filter1: ['someValue'] } + ], + unifiedValues: [ + { filter1: ['someValue', 'someOtherValue']} + ] + } + }; + let state = { + vnfFilterValues: {}, + unifiedFilterValues: {} + }; + state = VnfSearchReducer(state, action); + expect(state).toEqual({ + vnfFilterValues: action.data.selectedValuesMap, + unifiedFilterValues: action.data.unifiedValues + }); + }); + + it('Action Type: SET_UNIFIED_VALUES', () => { + const action = { + type: filterBarActionTypes.SET_UNIFIED_VALUES, + data: { + unifiedValues: [ + { filter1: ['someValue', 'someOtherValue']} + ] + } + }; + let state = { + unifiedFilterValues: {} + }; + state = VnfSearchReducer(state, action); + expect(state).toEqual({ + unifiedFilterValues: action.data + }); + }); + + it('Action Type: VNF_SEARCH_RESULTS_RECEIVED', () => { + const action = { + type: vnfActionTypes.VNF_SEARCH_RESULTS_RECEIVED, + data: { + provStatusData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + orchStatusData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + nfTypeData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + nfRoleData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + count: 25, + } + }; + let state = { + processedProvStatusCountChartData: {}, + processedOrchStatusCountChartData: {}, + processedNfTypeCountChartData: {}, + processedNfRoleCountChartData: {}, + count: 0, + feedbackMsgText: 'some error msg', + feedbackMsgSeverity: 'someSeverityLevel' + }; + state = VnfSearchReducer(state, action); + expect(state).toEqual({ + processedProvStatusCountChartData: action.data.provStatusData, + processedOrchStatusCountChartData: action.data.orchStatusData, + processedNfTypeCountChartData: action.data.nfTypeData, + processedNfRoleCountChartData: action.data.nfRoleData, + count: action.data.count, + feedbackMsgText: '', + feedbackMsgSeverity: '' + }); + }); + + it('Action Type: VNF_FILTER_PANEL_TOGGLED', () => { + const action = { + type: vnfActionTypes.VNF_FILTER_PANEL_TOGGLED, + data: { + vnfVisualizationPanelClass: 'hide', + } + }; + let state = { + vnfVisualizationPanelClass: 'show' + }; + state = VnfSearchReducer(state, action); + expect(state).toEqual({ + vnfVisualizationPanelClass: 'hide' + }); + }); + + it('Action Type: VNF_SEARCH_FILTERS_RECEIVED', () => { + const action = { + type: vnfActionTypes.VNF_SEARCH_FILTERS_RECEIVED, + data: [ + { filter1: 'value 1' }, + { filter2: 'value 2' } + ] + }; + let state = { + vnfFilters: [] + }; + state = VnfSearchReducer(state, action); + expect(state).toEqual({ + vnfFilters: action.data + }); + }); + + it('Action Type: SET_NON_CONVERTED_VALUES', () => { + const action = { + type: filterBarActionTypes.SET_NON_CONVERTED_VALUES, + data: [ + { value1: 'abc' }, + { value2: 'xyz' } + ] + }; + let state = { + nonConvertedFilters: [] + }; + state = VnfSearchReducer(state, action); + expect(state).toEqual({ + nonConvertedFilters: action.data + }); + }); + + it('Action Type: SET_CONVERTED_VALUES', () => { + const action = { + type: filterBarActionTypes.SET_CONVERTED_VALUES, + data: { + convertedValues: { + value1: 'abc', + value2: 'xyz' + }, + nonConvertedValues: { + value1: 123, + value2: 456 + } + } + }; + let state = { + nonConvertedFilters: { + filter1: 'one', + filter2: 'two' + }, + unifiedFilterValues: {}, + vnfFilterValues: {} + }; + state = VnfSearchReducer(state, action); + expect(state).toEqual({ + nonConvertedFilters: {}, + unifiedFilterValues: action.data.convertedValues, + vnfFilterValues: action.data.nonConvertedValues + }); + }); + + it('Action Type: VNF_ACTIVATE_BUSY_FEEDBACK', () => { + const action = { + type: vnfActionTypes.VNF_ACTIVATE_BUSY_FEEDBACK + }; + let state = { + enableBusyFeedback: false + }; + state = VnfSearchReducer(state, action); + expect(state).toEqual({ + enableBusyFeedback: true + }); + }); + + it('Action Type: VNF_DISABLE_BUSY_FEEDBACK', () => { + const action = { + type: vnfActionTypes.VNF_DISABLE_BUSY_FEEDBACK + }; + let state = { + enableBusyFeedback: true + }; + state = VnfSearchReducer(state, action); + expect(state).toEqual({ + enableBusyFeedback: false + }); + }); + + it('Action Type: CLEAR_FILTERS', () => { + const action = { + type: filterBarActionTypes.CLEAR_FILTERS + }; + let state = { + vnfFilters: { + filter1: 'filterName1' + }, + vnfFilterValues: { + filter1: 'value 1' + }, + nonConvertedFilters: { + nonConvertedFilter1: 'some fitler props' + }, + unifiedFilterValues: { + unifiedFilter1: 'some unified props' + } + }; + state = VnfSearchReducer(state, action); + expect(state).toEqual({ + vnfFilters: {}, + vnfFilterValues: {}, + nonConvertedFilters: {}, + unifiedFilterValues: {} + }); + }); + + it('Invalid Action Type', () => { + const action = { + type: 'Nonexistent Action Type', + }; + let state = { + vnfFilters: { + filter1: 'filterName1' + }, + vnfFilterValues: { + filter1: 'value 1' + }, + nonConvertedFilters: { + nonConvertedFilter1: 'some fitler props' + }, + unifiedFilterValues: { + unifiedFilter1: 'some unified props' + }, + enableBusyFeedback: true, + provStatusData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + orchStatusData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + nfTypeData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + nfRoleData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + count: 25 + }; + state = VnfSearchReducer(state, action); + expect(state).toEqual({ + vnfFilters: { + filter1: 'filterName1' + }, + vnfFilterValues: { + filter1: 'value 1' + }, + nonConvertedFilters: { + nonConvertedFilter1: 'some fitler props' + }, + unifiedFilterValues: { + unifiedFilter1: 'some unified props' + }, + enableBusyFeedback: true, + provStatusData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + orchStatusData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + nfTypeData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + nfRoleData: { + values: [ + {x: 'col 1', y: 3}, + {x: 'col 2', y: 7}, + {x: 'col 3', y: 2} + ] + }, + count: 25 + }); + }); +}) diff --git a/test/app/vnfSearch/VnfSearchTotalCountVisualization.test.js b/test/app/vnfSearch/VnfSearchTotalCountVisualization.test.js new file mode 100644 index 0000000..a397ff2 --- /dev/null +++ b/test/app/vnfSearch/VnfSearchTotalCountVisualization.test.js @@ -0,0 +1,131 @@ +import React from 'react'; +import { shallow, mount } from 'enzyme'; +import {Provider} from 'react-redux' +import configureStore from 'redux-mock-store'; + +import ConnectedVnfSearchTotalCountVisualization, + { VnfSearchTotalCountVisualization } from 'app/vnfSearch/VnfSearchTotalCountVisualization.jsx'; +import { TOTAL_VNF_COUNT } from 'app/vnfSearch/VnfSearchConstants.js'; +import Spinner from 'utils/SpinnerContainer'; + +describe('VnfSearchTotalCountVisualization - Shallow render of component', () => { + let wrapper; + const countProp = 25; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Render basic component', () => { + expect(wrapper.length).toEqual(1); + expect(wrapper.hasClass('visualizations')).toEqual(true); + }); + + it('Verify Spinner is present but not visible', () => { + expect(wrapper.find(Spinner)).toHaveLength(1); + expect(wrapper.find(Spinner).props().loading).toEqual(false); + }); + + it('Verify total count is displayed', () => { + expect(wrapper.contains({countProp})).toBe(true); + }); +}) + +describe('VnfSearchTotalCountVisualization - Shallow render of component with no chart data', () => { + let wrapper; + const countProp = null; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Visualization graph hidden', () => { + expect(wrapper.length).toEqual(1); + expect(['visualizations', 'hidden'].every(className => wrapper.hasClass(className))).toEqual(true); + }); +}) + +describe('VnfSearchTotalCountVisualization - Shallow render of component with busy feedback', () => { + let wrapper; + const countProp = 25; + + beforeEach( () => { + wrapper = shallow( + + ); + }) + + it('Render basic component', () => { + expect(wrapper.length).toEqual(1); + expect(wrapper.hasClass('visualizations')).toEqual(true); + }); + + it('Verify Spinner is present and visible', () => { + expect(wrapper.find(Spinner)).toHaveLength(1); + expect(wrapper.find(Spinner).props().loading).toEqual(true); + }); + + it('Verify total count is displayed', () => { + expect(wrapper.contains({countProp})).toBe(true); + }); +}) + +describe('VnfSearchTotalCountVisualization - Render React Component (wrapped in )', () => { + const initialState = { + vnfSearch: { + count: 25, + enableBusyFeedback: false + } + }; + const mockStore = configureStore(); + let store, wrapper; + + beforeEach( () => { + store = mockStore(initialState); + wrapper = mount(); + }) + + it('Render the connected component', () => { + expect(wrapper.find(ConnectedVnfSearchTotalCountVisualization).length).toEqual(1); + }); + + it('Validate props from store', () => { + expect(wrapper.find(VnfSearchTotalCountVisualization).props().enableBusyFeedback).toEqual(initialState.vnfSearch.enableBusyFeedback); + expect(wrapper.find(VnfSearchTotalCountVisualization).props().count).toEqual(initialState.vnfSearch.count); + }); +}) + +describe('VnfSearchTotalCountVisualization - Render React Component (wrapped in ) with default props', () => { + const initialState = { + vnfSearch: {} + }; + const mockStore = configureStore(); + let store, wrapper; + + beforeEach( () => { + store = mockStore(initialState); + wrapper = mount(); + }) + + it('Render the connected component', () => { + expect(wrapper.find(ConnectedVnfSearchTotalCountVisualization).length).toEqual(1); + }); + + it('Validate default props loaded', () => { + expect(wrapper.find(VnfSearchTotalCountVisualization).props().enableBusyFeedback).toEqual(false); + expect(wrapper.find(VnfSearchTotalCountVisualization).props().count).toEqual(TOTAL_VNF_COUNT.emptyValue); + }); +}) -- cgit 1.2.3-korg