Fix the tests for flows actions.

1 files changed, 29 insertions, 167 deletions

diff --git a/web/src/js/__tests__/ducks/flowsSpec.js b/web/src/js/__tests__/ducks/flowsSpec.js
index 868e0621..2dfe046f 100644
--- a/web/src/js/__tests__/ducks/flowsSpec.js
+++ b/web/src/js/__tests__/ducks/flowsSpec.js
@@ -113,43 +113,57 @@ describe('flows actions', () => {
     })
 
     it('should handle resumeAll action', () => {
-        flowActions.resumeAll()()
+        store.dispatch(flowActions.resumeAll())
+        expect(fetchApi).toBeCalledWith('/flows/resume', { method: 'POST' })
     })
 
     it('should handle kill action', () => {
-        flowActions.kill(tflow)()
+        store.dispatch(flowActions.kill(tflow))
+        expect(fetchApi).toBeCalledWith('/flows/1/kill', { method: 'POST' })
+
     })
 
     it('should handle killAll action', () => {
-        flowActions.killAll()()
+        store.dispatch(flowActions.killAll())
+        expect(fetchApi).toBeCalledWith('/flows/kill', { method: 'POST' })
     })
 
     it('should handle remove action', () => {
-        flowActions.remove(tflow)()
+        store.dispatch(flowActions.remove(tflow))
+        expect(fetchApi).toBeCalledWith('/flows/1', { method: 'DELETE' })
     })
 
     it('should handle duplicate action', () => {
-        flowActions.duplicate(tflow)()
+        store.dispatch(flowActions.duplicate(tflow))
+        expect(fetchApi).toBeCalledWith('/flows/1/duplicate', { method: 'POST' })
     })
 
     it('should handle replay action', () => {
-        flowActions.replay(tflow)()
+        store.dispatch(flowActions.replay(tflow))
+        expect(fetchApi).toBeCalledWith('/flows/1/replay', { method: 'POST' })
     })
 
     it('should handle revert action', () => {
-        flowActions.revert(tflow)()
+        store.dispatch(flowActions.revert(tflow))
+        expect(fetchApi).toBeCalledWith('/flows/1/revert', { method: 'POST' })
     })
 
     it('should handle update action', () => {
-        flowActions.update(tflow, "foo")()
+        store.dispatch(flowActions.update(tflow, 'foo'))
+        expect(fetchApi.put).toBeCalledWith('/flows/1', 'foo')
     })
 
-    it('should handle updateContent action', () => {
-        flowActions.uploadContent(tflow, "foo", "foo")()
+    it('should handle uploadContent action', () => {
+        let body = new FormData(),
+        file     = new window.Blob(['foo'], { type: 'plain/text' })
+        body.append('file', file)
+        store.dispatch(flowActions.uploadContent(tflow, 'foo', 'foo'))
+        expect(fetchApi).toBeCalledWith('/flows/1/foo/content', { method: 'POST', body})
     })
 
     it('should handle clear action', () => {
-        flowActions.clear()()
+        store.dispatch(flowActions.clear())
+        expect(fetchApi).toBeCalledWith('/clear', { method: 'POST'} )
     })
 
     it('should handle download action', () => {
@@ -158,7 +172,10 @@ describe('flows actions', () => {
     })
 
     it('should handle upload action', () => {
-        flowActions.upload("foo")()
+        let body = new FormData()
+        body.append('file', 'foo')
+        store.dispatch(flowActions.upload('foo'))
+        expect(fetchApi).toBeCalledWith('/flows/dump', { method: 'POST', body })
     })
 })
 
@@ -205,159 +222,4 @@ describe('makeSort', () => {
             b    = { request: { contentLength: 1 } }
         expect(sort(a, b)).toEqual(-1)
     })
-
-    it('should be possible to select relative',() => {
-        // already selected some flows
-        let newState = {},
-            getState = () => { return { flows: {...state, selected: [2]}}},
-            dispatch = (action) => { newState = reduceFlows(getState().flows, action) }
-        flowActions.selectRelative(1)(dispatch, getState)
-        expect(newState).toEqual({...state, selected: [3]})
-
-        // haven't selected any flow
-        getState = () => { return { flows: { ...state, selected: []}}}
-        flowActions.selectRelative(-1)(dispatch, getState)
-        expect(newState).toEqual({...state, selected: [1]})
-    })
-})
-
-describe('flows reducer', () => {
-    it('should return initial state', () => {
-        expect(reduceFlows(undefined, {})).toEqual({
-            highlight: null,
-            filter: null,
-            sort: { column: null, desc: false },
-            selected: [],
-            ...reduceStore(undefined, {})
-        })
-    })
-
-    it('should be possible to set filter', () => {
-        let filt = "~u 123"
-        expect(reduceFlows(undefined, flowActions.setFilter(filt)).filter).toEqual(filt)
-    })
-
-    it('should be possible to set highlight', () => {
-        let key = "foo"
-        expect(reduceFlows(undefined, flowActions.setHighlight(key)).highlight).toEqual(key)
-    })
-
-    it('should be possilbe to set sort', () => {
-        let sort = { column: "TLSColumn", desc: 1 }
-        expect(reduceFlows(undefined, flowActions.setSort(sort.column, sort.desc)).sort).toEqual(sort)
-    })
-
-    it('should update state.selected on remove', () => {
-        let state = reduceFlows(undefined, {})
-        for (let i of [1, 2, 3, 4]) {
-            state = reduceFlows(state, {type: flowActions.ADD, data: {id: i}, cmd: 'add'})
-        }
-        state = reduceFlows(state, flowActions.select(2))
-        expect(reduceFlows(state, {type: flowActions.REMOVE, data: 2, cmd: 'remove'}).selected).toEqual([3])
-        //last row
-        state = reduceFlows(state, flowActions.select(4))
-        expect(reduceFlows(state, {type: flowActions.REMOVE, data: 4, cmd: 'remove'}).selected).toEqual([3])
-    })
-})
-
-describe('flows actions', () => {
-
-    let tflow = { id: 1 }
-    it('should handle resume action', () => {
-        flowActions.resume(tflow)()
-    })
-
-    it('should handle resumeAll action', () => {
-        flowActions.resumeAll()()
-    })
-
-    it('should handle kill action', () => {
-        flowActions.kill(tflow)()
-    })
-
-    it('should handle killAll action', () => {
-        flowActions.killAll()()
-    })
-
-    it('should handle remove action', () => {
-        flowActions.remove(tflow)()
-    })
-
-    it('should handle duplicate action', () => {
-        flowActions.duplicate(tflow)()
-    })
-
-    it('should handle replay action', () => {
-        flowActions.replay(tflow)()
-    })
-
-    it('should handle revert action', () => {
-        flowActions.revert(tflow)()
-    })
-
-    it('should handle update action', () => {
-        flowActions.update(tflow, "foo")()
-    })
-
-    it('should handle updateContent action', () => {
-        flowActions.uploadContent(tflow, "foo", "foo")()
-    })
-
-    it('should hanlde clear action', () => {
-        flowActions.clear()()
-    })
-
-    it('should handle download action', () => {
-        let state = reduceFlows(undefined, {})
-        expect(reduceFlows(state, flowActions.download())).toEqual(state)
-    })
-
-    it('should handle upload action', () => {
-        flowActions.upload("foo")()
-    })
-})
-
-describe('makeSort', () => {
-    it('should be possible to sort by TLSColumn', () => {
-        let sort = flowActions.makeSort({column: 'TLSColumn', desc:true}),
-            a = {request: {scheme: 'http'}},
-            b = {request: {scheme: 'https'}}
-        expect(sort(a, b)).toEqual(1)
-    })
-
-    it('should be possible to sort by PathColumn', () => {
-        let sort = flowActions.makeSort({column: 'PathColumn', desc:true}),
-            a = {request: {}},
-            b = {request: {}}
-        expect(sort(a, b)).toEqual(0)
-
-    })
-
-    it('should be possible to sort by MethodColumn', () => {
-        let sort = flowActions.makeSort({column: 'MethodColumn', desc:true}),
-            a = {request: {method: 'GET'}},
-            b = {request: {method: 'POST'}}
-        expect(sort(b, a)).toEqual(-1)
-    })
-
-    it('should be possible to sort by StatusColumn', () => {
-        let sort = flowActions.makeSort({column: 'StatusColumn', desc:false}),
-            a = {response: {status_code: 200}},
-            b = {response: {status_code: 404}}
-        expect(sort(a, b)).toEqual(-1)
-    })
-
-    it('should be possible to sort by TimeColumn', () => {
-        let sort = flowActions.makeSort({column: 'TimeColumn', desc: false}),
-            a = {response: {timestamp_end: 9}, request: {timestamp_start: 8}},
-            b = {response: {timestamp_end: 10}, request: {timestamp_start: 8}}
-        expect(sort(b, a)).toEqual(1)
-    })
-
-    it('should be possible to sort by SizeColumn', () => {
-        let sort = flowActions.makeSort({column:'SizeColumn', desc: true}),
-            a = {request: {contentLength: 1}, response: {contentLength: 1}},
-            b = {request: {contentLength: 1}}
-        expect(sort(a, b)).toEqual(-1)
-    })
 })