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 <adam.wudzinski@nokia.com>

22 files changed, 3423 insertions, 0 deletions

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(<Provider store={store}><GlobalAutoCompleteSearchBar /></Provider>);
+  })
+
+  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(<Provider store={store}><GlobalInlineMessageBar /></Provider>);
+  })
+
+  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(
+      <SelectedNodeDetails
+        nodeType={nodeTypeProp}
+        nodeData={nodeDataProp}
+        uid={uidProp}
+      />);
+  })
+
+  it('Render basic component', () => {
+    expect(wrapper.length).toEqual(1);
+  });
+
+  it('Verify node type is displayed as a header', () => {
+    expect(wrapper.contains(<h2>{nodeTypeProp}</h2>)).toBe(true);
+    expect(wrapper.find('h2')).toHaveLength(1);
+  });
+
+  it('Verify uid is displayed', () => {
+    expect(wrapper.contains(<span>{uidProp} <LaunchInContext/></span>)).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(
+        <th className={cellClassName}  key={index}>{SELECTED_NODE_TABLE_COLUMN_NAMES[index-1]}</th>
+      )).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(
+        <td className='left-column-cell'>{prop}</td>
+      )).toBe(true);
+      expect(wrapper.contains(
+        <td className='right-column-cell'>{nodeDataProp[prop]}</td>
+      )).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(
+      <SelectedNodeDetails
+        nodeType={nodeTypeProp}
+        nodeData={nodeDataProp}
+        uid={uidProp}
+      />);
+  })
+
+  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 <Provider>)', () => {
+  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(<Provider store={store}><ConnectedSelectedNodeDetails /></Provider>);
+  })
+
+  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(
+      <vnfSearch
+        vnfFilters={vnfFilters}
+        unifiedFilterValues={unifiedFilterValues}
+        vnfVisualizationPanelClass={vnfVisualizationPanelClass}
+      />
+    );
+  })
+
+  it('Render basic component', () => {
+    expect(wrapper.length).toEqual(1);
+  });
+})
+//
+// describe('VnfSearch - Render React Component (wrapped in <Provider>)', () => {
+//   const initialState = {
+//     vnfSearch: {}
+//   };
+//   const mockStore = configureStore();
+//   let store, wrapper;
+//
+//   beforeEach( () => {
+//     store = mockStore(initialState);
+//     wrapper = mount(<Provider store={store}><ConnectedVnfSearch /></Provider>);
+//   })
+//
+//   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(
+      <VnfSearchNfRoleVisualization
+        enableBusyFeedback={false}
+        processedNfRoleCountChartData={processedNfRoleCountChartDataProp}
+      />
+    );
+  })
+
+  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(
+      <VnfSearchNfRoleVisualization
+        enableBusyFeedback={false}
+        processedNfRoleCountChartData={processedNfRoleCountChartDataProp}
+      />
+    );
+  })
+
+  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(
+      <VnfSearchNfRoleVisualization
+        enableBusyFeedback={true}
+        processedNfRoleCountChartData={processedNfRoleCountChartDataProp}
+      />
+    );
+  })
+
+  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 <Provider>)', () => {
+  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(<Provider store={store}><ConnectedVnfSearchNfRoleVisualization /></Provider>);
+  })
+
+  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 <Provider>) with default props', () => {
+  const initialState = {
+    vnfSearch: {}
+  };
+  const mockStore = configureStore();
+  let store, wrapper;
+
+  beforeEach( () => {
+    store = mockStore(initialState);
+    wrapper = mount(<Provider store={store}><ConnectedVnfSearchNfRoleVisualization /></Provider>);
+  })
+
+  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(
+      <VnfSearchNfTypeVisualization
+        enableBusyFeedback={false}
+        processedNfTypeCountChartData={processedNfTypeCountChartDataProp}
+      />
+    );
+  })
+
+  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(
+      <VnfSearchNfTypeVisualization
+        enableBusyFeedback={false}
+        processedNfTypeCountChartData={processedNfTypeCountChartDataProp}
+      />
+    );
+  })
+
+  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(
+      <VnfSearchNfTypeVisualization
+        enableBusyFeedback={true}
+        processedNfTypeCountChartData={processedNfTypeCountChartDataProp}
+      />
+    );
+  })
+
+  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 <Provider>)', () => {
+  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(<Provider store={store}><ConnectedVnfSearchNfTypeVisualization /></Provider>);
+  })
+
+  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 <Provider>) with default props', () => {
+  const initialState = {
+    vnfSearch: {}
+  };
+  const mockStore = configureStore();
+  let store, wrapper;
+
+  beforeEach( () => {
+    store = mockStore(initialState);
+    wrapper = mount(<Provider store={store}><ConnectedVnfSearchNfTypeVisualization /></Provider>);
+  })
+
+  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(
+      <VnfSearchOrchStatusVisualizations
+        enableBusyFeedback={false}
+        processedOrchStatusCountChartData={processedOrchStatusCountChartDataProp}
+      />
+    );
+  })
+
+  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(
+      <VnfSearchOrchStatusVisualizations
+        enableBusyFeedback={false}
+        processedOrchStatusCountChartData={processedOrchStatusCountChartDataProp}
+      />
+    );
+  })
+
+  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(
+      <VnfSearchOrchStatusVisualizations
+        enableBusyFeedback={true}
+        processedOrchStatusCountChartData={processedOrchStatusCountChartDataProp}
+      />
+    );
+  })
+
+  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 <Provider>)', () => {
+  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(<Provider store={store}><ConnectedVnfSearchOrchStatusVisualizations /></Provider>);
+  })
+
+  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 <Provider>) with default props', () => {
+  const initialState = {
+    vnfSearch: {}
+  };
+  const mockStore = configureStore();
+  let store, wrapper;
+
+  beforeEach( () => {
+    store = mockStore(initialState);
+    wrapper = mount(<Provider store={store}><ConnectedVnfSearchOrchStatusVisualizations /></Provider>);
+  })
+
+  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(
+      <VnfSearchProvStatusVisualization
+        enableBusyFeedback={false}
+        processedProvStatusCountChartData={processedProvStatusCountChartDataProp}
+      />
+    );
+  })
+
+  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(
+      <VnfSearchProvStatusVisualization
+        enableBusyFeedback={false}
+        processedProvStatusCountChartData={processedProvStatusCountChartDataProp}
+      />
+    );
+  })
+
+  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(
+      <VnfSearchProvStatusVisualization
+        enableBusyFeedback={true}
+        processedProvStatusCountChartData={processedProvStatusCountChartDataProp}
+      />
+    );
+  })
+
+  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 <Provider>)', () => {
+  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(<Provider store={store}><ConnectedVnfSearchProvStatusVisualization /></Provider>);
+  })
+
+  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 <Provider>) with default props', () => {
+  const initialState = {
+    vnfSearch: {}
+  };
+  const mockStore = configureStore();
+  let store, wrapper;
+
+  beforeEach( () => {
+    store = mockStore(initialState);
+    wrapper = mount(<Provider store={store}><ConnectedVnfSearchProvStatusVisualization /></Provider>);
+  })
+
+  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(
+      <VnfSearchTotalCountVisualization
+        enableBusyFeedback={false}
+        count={countProp}
+      />
+    );
+  })
+
+  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(<span>{countProp}</span>)).toBe(true);
+  });
+})
+
+describe('VnfSearchTotalCountVisualization - Shallow render of component with no chart data', () => {
+  let wrapper;
+  const countProp = null;
+
+  beforeEach( () => {
+    wrapper = shallow(
+      <VnfSearchTotalCountVisualization
+        enableBusyFeedback={false}
+        count={countProp}
+      />
+    );
+  })
+
+  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(
+      <VnfSearchTotalCountVisualization
+        enableBusyFeedback={true}
+        count={countProp}
+      />
+    );
+  })
+
+  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(<span>{countProp}</span>)).toBe(true);
+  });
+})
+
+describe('VnfSearchTotalCountVisualization - Render React Component (wrapped in <Provider>)', () => {
+  const initialState = {
+    vnfSearch: {
+      count: 25,
+      enableBusyFeedback: false
+    }
+  };
+  const mockStore = configureStore();
+  let store, wrapper;
+
+  beforeEach( () => {
+    store = mockStore(initialState);
+    wrapper = mount(<Provider store={store}><ConnectedVnfSearchTotalCountVisualization /></Provider>);
+  })
+
+  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 <Provider>) with default props', () => {
+  const initialState = {
+    vnfSearch: {}
+  };
+  const mockStore = configureStore();
+  let store, wrapper;
+
+  beforeEach( () => {
+    store = mockStore(initialState);
+    wrapper = mount(<Provider store={store}><ConnectedVnfSearchTotalCountVisualization /></Provider>);
+  })
+
+  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);
+  });
+})