TierSupportActions test
[aai/sparky-fe.git] / test / app / tierSupport / TierSupportActions.test.js
1 import configureStore from 'redux-mock-store';
2 import thunk from 'redux-thunk'
3 import {
4   onNodeDetailsChange,
5   splitPaneResize,
6   onNodeMenuChange,
7   clearVIData,
8   setNotificationText,
9   fetchSelectedNodeElement,
10   querySelectedNodeElement
11 }
12 from 'app/tierSupport/TierSupportActions';
13 import {tierSupportActionTypes} from 'app/tierSupport/TierSupportConstants';
14 import {MESSAGE_LEVEL_WARNING} from 'utils/GlobalConstants';
15 import {globalInlineMessageBarActionTypes} from 'app/globalInlineMessageBar/GlobalInlineMessageBarConstants';
16 import {
17   NO_RESULTS_FOUND,
18   ERROR_RETRIEVING_DATA
19 } from 'app/networking/NetworkConstants';
20 import networkCall from 'app/networking/NetworkCalls';
21
22 const mockStore = configureStore([thunk]);
23
24 describe('TierSupportActionTests', () => {
25   let store;
26
27   beforeEach(() => {
28     store = mockStore({ tierSupportReducer: {} });
29   });
30
31   describe('onNodeDetailsChange', () => {
32     it('emits TS_GRAPH_NODE_SELECTED with payload', () => {
33       // Given
34       const newDetails = {
35         testDetails: 'Test Details',
36       };
37       const expectedActions = [{
38         type: tierSupportActionTypes.TS_GRAPH_NODE_SELECTED,
39         data: newDetails
40       }];
41
42       // When
43       store.dispatch(onNodeDetailsChange(newDetails));
44
45       // Then
46       expect(store.getActions()).toEqual(expectedActions);
47     });
48   });
49
50   describe('splitPaneResize', () => {
51     it('emits SPLIT_PANE_RESIZE action with payload', () => {
52       // Given
53       const initialLoad = {
54         test: 'message'
55       };
56       const expectedActions = [{
57         type: tierSupportActionTypes.SPLIT_PANE_RESIZE,
58         data: initialLoad
59       }];
60
61       // When
62       store.dispatch(splitPaneResize(initialLoad));
63
64       // Then
65       expect(store.getActions()).toEqual(expectedActions);
66     });
67   });
68
69   describe('onNodeMenuChange', () => {
70     it('emits TS_GRAPH_NODE_MENU_SELECTED action with payload', () => {
71       // Given
72       const selectedMenu = {
73         test: 'menuData'
74       };
75       const expectedActions = [{
76         type: tierSupportActionTypes.TS_GRAPH_NODE_MENU_SELECTED,
77         data: selectedMenu
78       }];
79
80       // When
81       store.dispatch(onNodeMenuChange(selectedMenu));
82
83       // Then
84       expect(store.getActions()).toEqual(expectedActions);
85     });
86   });
87
88   describe('clearVIData', () => {
89     it('emits TIER_SUPPORT_CLEAR_DATA action', () => {
90       // Given
91       const expectedActions = [{
92         type: tierSupportActionTypes.TIER_SUPPORT_CLEAR_DATA
93       }];
94
95       // When
96       store.dispatch(clearVIData());
97
98       // Then
99       expect(store.getActions()).toEqual(expectedActions);
100     });
101   });
102
103   describe('fetchSelectedNodeElement', () => {
104     it('emits actions with proper error message when 204 code returned', async () => {
105       // Given
106       const promise = () => getPromiseWithStatusCode(204);
107       const expectedActions = [
108         {
109           type: tierSupportActionTypes.TIER_SUPPORT_DISABLE_BUSY_FEEDBACK,
110         },
111         {
112           type: tierSupportActionTypes.TS_NODE_SEARCH_NO_RESULTS,
113           data: {errorMsg: NO_RESULTS_FOUND}
114         }
115       ];
116
117       // When
118       await store.dispatch(fetchSelectedNodeElement(promise));
119
120       // Then
121       expect(store.getActions()).toEqual(expectedActions);
122     });
123
124     it('emits actions with proper error message when 3XX code returned', async () => {
125       // Given
126       const promise = () => getPromiseWithStatusCode(301);
127       const expectedActions = [
128         {
129           type: tierSupportActionTypes.TIER_SUPPORT_DISABLE_BUSY_FEEDBACK,
130         },
131         {
132           type: tierSupportActionTypes.TS_NODE_SEARCH_NO_RESULTS,
133           data: {errorMsg: NO_RESULTS_FOUND}
134         }
135       ];
136
137       // When
138       await store.dispatch(fetchSelectedNodeElement(promise));
139
140       // Then
141       expect(store.getActions()).toEqual(expectedActions);
142     });
143
144     it('emits actions with proper error message when 5XX code returned', async () => {
145       // Given
146       const promise = () => getPromiseWithStatusCode(501);
147       const expectedActions = [
148         {
149           type: tierSupportActionTypes.TIER_SUPPORT_DISABLE_BUSY_FEEDBACK,
150         },
151         {
152           type: tierSupportActionTypes.TIER_SUPPORT_NETWORK_ERROR,
153           data: {value: ERROR_RETRIEVING_DATA, errorMsg: ERROR_RETRIEVING_DATA}
154         }
155       ];
156
157       // When
158       await store.dispatch(fetchSelectedNodeElement(promise));
159
160       // Then
161       expect(store.getActions()).toEqual(expectedActions);
162     });
163
164     it('emits actions with payload when 200 code returned and nodes not empty', async () => {
165       // Given
166       const {nodes, node1} = prepareTestNodes();
167       const promise = () => getNodesPromise(nodes);
168       const expectedActions = [
169         {
170           type: tierSupportActionTypes.TS_NODE_SEARCH_RESULTS,
171           data: {"nodes": nodes}
172         },
173         {
174           type: tierSupportActionTypes.TS_GRAPH_NODE_SELECTED,
175           data: node1
176         },
177         {
178           type: tierSupportActionTypes.TIER_SUPPORT_DISABLE_BUSY_FEEDBACK
179         }
180       ];
181
182       // When
183       await store.dispatch(fetchSelectedNodeElement(promise));
184
185       // Then
186       expect(store.getActions()).toEqual(expectedActions);
187     });
188
189     it('emits actions with payload when 200 code returned and nodes empty', async () => {
190       // Given
191       const promise = () => getNodesPromise([]);
192       const expectedActions = [
193         {
194           type: tierSupportActionTypes.TS_NODE_SEARCH_NO_RESULTS,
195           data: {errorMsg: NO_RESULTS_FOUND}
196         },
197         {
198           type: tierSupportActionTypes.TIER_SUPPORT_DISABLE_BUSY_FEEDBACK
199         }
200       ];
201
202       // When
203       await store.dispatch(fetchSelectedNodeElement(promise));
204
205       // Then
206       expect(store.getActions()).toEqual(expectedActions);
207     });
208   });
209
210   describe('querySelectedNodeElement', () => {
211     const searchHash = "testHash";
212
213     it('emits actions when fetchRequest defined ', async () => {
214       // Given
215       const promise = () => getNodesPromise([]);
216       const expectedAction = [
217         {
218           type: tierSupportActionTypes.TIER_SUPPORT_ACTIVATE_BUSY_FEEDBACK,
219         },
220         {
221           type: tierSupportActionTypes.TS_NODE_SEARCH_NO_RESULTS,
222           data: {errorMsg: NO_RESULTS_FOUND}
223         },
224         {
225           type: tierSupportActionTypes.TIER_SUPPORT_DISABLE_BUSY_FEEDBACK
226         }
227       ];
228
229       // When
230       await store.dispatch(querySelectedNodeElement(searchHash, promise));
231
232       // Then
233       expect(store.getActions()).toEqual(expectedAction);
234     });
235
236     it('builds request and emits actions when fetchRequest undefined ', async () => {
237       // Given
238       const stringifySpy = jest.spyOn(JSON, 'stringify');
239       const promise = getNodesPromise([]);
240       networkCall.fetchRequestObj = jest.fn(() => promise);
241       const expectedStringifyInput = {
242         hashId: searchHash
243       };
244       const expectedFetchRequestBody = "{\"hashId\":\"testHash\"}";
245       const expectedAction = [
246         {
247           type: tierSupportActionTypes.TIER_SUPPORT_ACTIVATE_BUSY_FEEDBACK,
248         },
249         {
250           type: tierSupportActionTypes.TS_NODE_SEARCH_NO_RESULTS,
251           data: {errorMsg: NO_RESULTS_FOUND}
252         },
253         {
254           type: tierSupportActionTypes.TIER_SUPPORT_DISABLE_BUSY_FEEDBACK
255         }
256       ];
257
258       // When
259       await store.dispatch(querySelectedNodeElement(searchHash, undefined));
260
261       // Then
262       expect(stringifySpy).toHaveBeenCalledWith(expectedStringifyInput);
263       expect(networkCall.fetchRequestObj).toHaveBeenCalledWith(
264           expect.anything(),
265           expect.anything(),
266           expect.anything(),
267           expectedFetchRequestBody
268       );
269       expect(store.getActions()).toEqual(expectedAction);
270     });
271   });
272
273   describe('setNotificationText', () => {
274   const msgSeverity = MESSAGE_LEVEL_WARNING;
275
276     it('emits SET_GLOBAL_MESSAGE action with payload when msgText is not blank ', () => {
277       // Given
278       const msgText = 'some test text';
279       const expectedActions = [{
280         type: globalInlineMessageBarActionTypes.SET_GLOBAL_MESSAGE,
281         data: {
282           msgText: msgText,
283           msgSeverity: msgSeverity
284         }
285       }];
286
287       // When
288       store.dispatch(setNotificationText(msgText, msgSeverity));
289
290       // Then
291       expect(store.getActions()).toEqual(expectedActions);
292     });
293
294     it('emits CLEAR_GLOBAL_MESSAGE when msgText is blank ', () => {
295       // Given
296       const msgText = '';
297       const expectedActions = [{
298         type: globalInlineMessageBarActionTypes.CLEAR_GLOBAL_MESSAGE
299       }];
300
301       // When
302       store.dispatch(setNotificationText(msgText, msgSeverity));
303
304       // Then
305       expect(store.getActions()).toEqual(expectedActions);
306     });
307   });
308
309   function getPromiseWithStatusCode(statusCode) {
310     return new Promise(function(resolve) {
311       resolve({status: statusCode});
312     });
313   }
314
315   function getNodesPromise(nodes) {
316     return new Promise(function (resolve) {
317       resolve({
318         status: 200,
319         json: () => {
320           return {
321             nodes: nodes
322           };
323         }
324       });
325     });
326   }
327
328   function prepareTestNodes() {
329     const node1 = prepareSelectedClassTestNode();
330     const node2 = prepareOtherClassTestNode();
331     return {
332       nodes: [node1, node2],
333       node1,
334       node2
335     }
336   }
337
338   function prepareOtherClassTestNode() {
339     return  {
340       id: '3899453d98c5b670952765974876e55ef954e0f8a930b1c',
341       itemType: 'generic-vnf',
342       nodeMeta: {
343         className: 'someOtherClassName',
344         nodeLabel1: 'Artic',
345         nodeValidated: false,
346         nodeLocation: 'bottom'
347       },
348       rootNode: false,
349       index: 1
350     };
351   }
352
353   function prepareSelectedClassTestNode() {
354     return {
355       id: '7352312c7bfa814c3071a803d98c5b670952765974876e55ef954e0f8a930b1c',
356       itemType: 'complex',
357       nodeMeta: {
358         className: 'selectedSearchedNodeClass',
359         nodeLabel1: 'Artic',
360         nodeValidated: false,
361         nodeLocation: 'bottom'
362       },
363       rootNode: false,
364       index: 2
365     };
366   }
367 });

© 2017 ONAP. Copyright © The Linux Foundation ®. All Rights Reserved.
The Linux Foundation has registered trademarks and uses trademarks.
For a list of trademarks of The Linux Foundation, please see our Trademark Usage page.
Linux is a registered trademark of Linus Torvalds.
Privacy Policy and Terms of Use