diff --git a/src/__tests__/composite.spec.js b/src/__tests__/composite.spec.js index 0ecc706..ac873aa 100644 --- a/src/__tests__/composite.spec.js +++ b/src/__tests__/composite.spec.js @@ -12,30 +12,30 @@ describe('composite.spec', () => { parallelAll, } = require('../composite') - const success = jest.fn() + const succeed = jest.fn() const fail = jest.fn() - const message = jest.fn() + const send = jest.fn() - let counterSuccessChild + let counterSucceedChild let counterFailChild - let createSuccessTask + let createSuccessfulTask let createFailTask - const getCreateSuccessTask = (async = false) => { - return (success, _, message) => { + const getCreateSuccessfulTask = (_async = false) => { + return (succeed, _, send) => { let tid return { - name: 'success', + name: 'succeed', run: () => { const sync = () => { - message('will success') - counterSuccessChild++ - success('success') + send('will succeed') + counterSucceedChild++ + succeed('succeed') } - async ? (tid = setTimeout(sync)) : sync() + _async ? (tid = setTimeout(sync)) : sync() }, cancel: () => { clearTimeout(tid) @@ -44,20 +44,20 @@ describe('composite.spec', () => { } } - const getCreateFailTask = (async = false) => { - return (_, fail, message) => { + const getCreateFailTask = (_async = false) => { + return (_, fail, send) => { let tid return { name: 'fail', run: () => { const sync = () => { - message('will fail') + send('will fail') counterFailChild++ fail('fail') } - async ? (tid = setTimeout(sync)) : sync() + _async ? (tid = setTimeout(sync)) : sync() }, cancel: () => { clearTimeout(tid) @@ -67,21 +67,21 @@ describe('composite.spec', () => { } beforeEach(() => { - success.mockClear() + succeed.mockClear() fail.mockClear() - message.mockClear() + send.mockClear() - counterSuccessChild = 0 + counterSucceedChild = 0 counterFailChild = 0 }) cases( - 'should success if no task provided', + 'should succeed if no task provided', ({ composite }) => { - const task = composite()(success) + const task = composite()(succeed) task.run() - expect(success).toBeCalled() + expect(succeed).toBeCalled() }, { 'serie sequence': { composite: serieSequence }, @@ -95,62 +95,71 @@ describe('composite.spec', () => { describe('serie', () => { describe('sequence', () => { - it('should success when all task succeed', () => { - createSuccessTask = getCreateSuccessTask() + it('should succeed when all task succeed', () => { + createSuccessfulTask = getCreateSuccessfulTask() - const task = serieSequence(createSuccessTask, createSuccessTask)(success, fail, message) + const task = serieSequence(createSuccessfulTask, createSuccessfulTask)(succeed, fail, send) expect(task.name).toBe('serie-sequence') task.run() - expect(success).toBeCalledWith('success') - expect(fail).not.toBeCalled() - - expect(message).toBeCalledWith('will success', 'success') + expect(send).toBeCalledWith('will succeed', 'succeed(0)') + expect(send).toBeCalledWith('succeed', 'succeed(0)') + expect(send).toBeCalledWith('will succeed', 'succeed(1)') + expect(send).toBeCalledWith('succeed', 'succeed(1)') + expect(send).toHaveBeenCalledTimes(4) - expect(counterSuccessChild).toBe(2) + expect(succeed).toBeCalled() + expect(fail).not.toBeCalled() + expect(counterSucceedChild).toBe(2) expect(counterFailChild).toBe(0) }) it('should fail as soon as one failed', () => { - createSuccessTask = getCreateSuccessTask() + createSuccessfulTask = getCreateSuccessfulTask() createFailTask = getCreateFailTask() - const task = serieSequence(createSuccessTask, createFailTask, createSuccessTask)(success, fail, message) + const task = serieSequence(createSuccessfulTask, createFailTask, createSuccessfulTask)(succeed, fail, send) expect(task.name).toBe('serie-sequence') task.run() - expect(success).not.toBeCalled() + expect(send).toBeCalledWith('will succeed', 'succeed(0)') + expect(send).toBeCalledWith('succeed', 'succeed(0)') + expect(send).toBeCalledWith('will fail', 'fail(1)') + expect(send).toBeCalledWith('fail', 'fail(1)') + expect(send).toHaveBeenCalledTimes(4) + + expect(succeed).not.toBeCalled() expect(fail).toBeCalled() - expect(counterSuccessChild).toBe(1) + expect(counterSucceedChild).toBe(1) expect(counterFailChild).toBe(1) }) it('should fail as soon as one failed with async', () => { - createSuccessTask = getCreateSuccessTask(true) + createSuccessfulTask = getCreateSuccessfulTask(true) createFailTask = getCreateFailTask(true) - const task = serieSequence(createSuccessTask, createFailTask, createSuccessTask)(success, fail, message) + const task = serieSequence(createSuccessfulTask, createFailTask, createSuccessfulTask)(succeed, fail, send) expect(task.name).toBe('serie-sequence') task.run() - expect(counterSuccessChild).toBe(0) + expect(counterSucceedChild).toBe(0) expect(counterFailChild).toBe(0) jest.runOnlyPendingTimers() expect(fail).not.toBeCalled() - expect(counterSuccessChild).toBe(1) + expect(counterSucceedChild).toBe(1) expect(counterFailChild).toBe(0) jest.runOnlyPendingTimers() - expect(success).not.toBeCalled() + expect(succeed).not.toBeCalled() expect(fail).toBeCalled() - expect(counterSuccessChild).toBe(1) + expect(counterSucceedChild).toBe(1) expect(counterFailChild).toBe(1) }) }) @@ -159,124 +168,134 @@ describe('composite.spec', () => { it('should fail when all task failed', () => { createFailTask = getCreateFailTask() - const task = serieSelector(createFailTask, createFailTask)(success, fail, message) + const task = serieSelector(createFailTask, createFailTask)(succeed, fail, send) expect(task.name).toBe('serie-selector') task.run() - expect(fail).toBeCalledWith('fail') - expect(success).not.toBeCalled() + expect(send).toBeCalledWith('will fail', 'fail(0)') + expect(send).toBeCalledWith('fail', 'fail(0)') + expect(send).toBeCalledWith('will fail', 'fail(1)') + expect(send).toBeCalledWith('fail', 'fail(1)') + expect(send).toHaveBeenCalledTimes(4) - expect(message).toBeCalledWith('will fail', 'fail') + expect(fail).toBeCalled() + expect(succeed).not.toBeCalled() expect(counterFailChild).toBe(2) - expect(counterSuccessChild).toBe(0) + expect(counterSucceedChild).toBe(0) }) - it('should success as soon as one succeed', () => { - createSuccessTask = getCreateSuccessTask() + it('should succeed as soon as one succeed', () => { + createSuccessfulTask = getCreateSuccessfulTask() createFailTask = getCreateFailTask() - const task = serieSelector(createFailTask, createSuccessTask, createFailTask)(success, fail, message) + const task = serieSelector(createFailTask, createSuccessfulTask, createFailTask)(succeed, fail, send) expect(task.name).toBe('serie-selector') task.run() + expect(send).toBeCalledWith('will fail', 'fail(0)') + expect(send).toBeCalledWith('fail', 'fail(0)') + expect(send).toBeCalledWith('will succeed', 'succeed(1)') + expect(send).toBeCalledWith('succeed', 'succeed(1)') + expect(send).toHaveBeenCalledTimes(4) + expect(fail).not.toBeCalled() - expect(success).toBeCalled() + expect(succeed).toBeCalled() expect(counterFailChild).toBe(1) - expect(counterSuccessChild).toBe(1) + expect(counterSucceedChild).toBe(1) }) it('should fail as soon as one succeed with async', () => { - createSuccessTask = getCreateSuccessTask(true) + createSuccessfulTask = getCreateSuccessfulTask(true) createFailTask = getCreateFailTask(true) - const task = serieSelector(createFailTask, createSuccessTask, createFailTask)(success, fail, message) + const task = serieSelector(createFailTask, createSuccessfulTask, createFailTask)(succeed, fail, send) expect(task.name).toBe('serie-selector') task.run() - expect(counterSuccessChild).toBe(0) + expect(counterSucceedChild).toBe(0) expect(counterFailChild).toBe(0) jest.runOnlyPendingTimers() - expect(success).not.toBeCalled() - expect(counterSuccessChild).toBe(0) + expect(succeed).not.toBeCalled() + expect(counterSucceedChild).toBe(0) expect(counterFailChild).toBe(1) jest.runOnlyPendingTimers() expect(fail).not.toBeCalled() - expect(success).toBeCalled() - expect(counterSuccessChild).toBe(1) + expect(succeed).toBeCalled() + expect(counterSucceedChild).toBe(1) expect(counterFailChild).toBe(1) }) }) describe('all', () => { - it('should success when all task succeed', () => { - createSuccessTask = getCreateSuccessTask() + it('should succeed when all task succeed', () => { + createSuccessfulTask = getCreateSuccessfulTask() - const task = serieAll(createSuccessTask, createSuccessTask)(success, fail, message) + const task = serieAll(createSuccessfulTask, createSuccessfulTask)(succeed, fail, send) expect(task.name).toBe('serie-all') task.run() - expect(success).toBeCalled() + expect(succeed).toBeCalled() expect(fail).not.toBeCalled() - expect(counterSuccessChild).toBe(2) + expect(counterSucceedChild).toBe(2) expect(counterFailChild).toBe(0) }) it('should fail if at least one failed', () => { - createSuccessTask = getCreateSuccessTask() + createSuccessfulTask = getCreateSuccessfulTask() createFailTask = getCreateFailTask() - const task = serieAll(createSuccessTask, createFailTask, createSuccessTask)(success, fail, message) + const task = serieAll(createSuccessfulTask, createFailTask, createSuccessfulTask)(succeed, fail, send) expect(task.name).toBe('serie-all') task.run() - expect(success).not.toBeCalled() + expect(succeed).not.toBeCalled() expect(fail).toBeCalled() - expect(counterSuccessChild).toBe(2) + expect(counterSucceedChild).toBe(2) expect(counterFailChild).toBe(1) }) it('should fail if at least one failed with async', () => { - createSuccessTask = getCreateSuccessTask(true) + createSuccessfulTask = getCreateSuccessfulTask(true) createFailTask = getCreateFailTask(true) - const task = serieAll(createSuccessTask, createFailTask, createSuccessTask)(success, fail, message) + const task = serieAll(createSuccessfulTask, createFailTask, createSuccessfulTask)(succeed, fail, send) expect(task.name).toBe('serie-all') task.run() - expect(counterSuccessChild).toBe(0) + expect(counterSucceedChild).toBe(0) expect(counterFailChild).toBe(0) jest.runOnlyPendingTimers() - expect(counterSuccessChild).toBe(1) + expect(counterSucceedChild).toBe(1) expect(counterFailChild).toBe(0) jest.runOnlyPendingTimers() - expect(success).not.toBeCalled() + expect(succeed).not.toBeCalled() expect(fail).not.toBeCalled() - expect(counterSuccessChild).toBe(1) + expect(counterSucceedChild).toBe(1) expect(counterFailChild).toBe(1) jest.runOnlyPendingTimers() - expect(success).not.toBeCalled() + expect(succeed).not.toBeCalled() expect(fail).toBeCalled() - expect(counterSuccessChild).toBe(2) + expect(counterSucceedChild).toBe(2) expect(counterFailChild).toBe(1) }) }) @@ -284,40 +303,54 @@ describe('composite.spec', () => { describe('parallel', () => { describe('sequence', () => { - it('should success when all task succeed', () => { - createSuccessTask = getCreateSuccessTask(true) + it('should succeed when all task succeed', () => { + createSuccessfulTask = getCreateSuccessfulTask(true) - const task = parallelSequence(createSuccessTask, createSuccessTask)(success, fail, message) + const task = parallelSequence(createSuccessfulTask, createSuccessfulTask)(succeed, fail, send) expect(task.name).toBe('parallel-sequence') task.run() - expect(success).not.toBeCalled() + expect(send).toHaveBeenCalledTimes(0) + expect(succeed).not.toBeCalled() jest.runOnlyPendingTimers() - expect(success).toBeCalled() + expect(send).toBeCalledWith('will succeed', 'succeed(0)') + expect(send).toBeCalledWith('succeed', 'succeed(0)') + expect(send).toBeCalledWith('will succeed', 'succeed(1)') + expect(send).toBeCalledWith('succeed', 'succeed(1)') + expect(send).toHaveBeenCalledTimes(4) + + expect(succeed).toBeCalled() expect(fail).not.toBeCalled() - expect(counterSuccessChild).toBe(2) + expect(counterSucceedChild).toBe(2) expect(counterFailChild).toBe(0) }) it('should fail as soon as one failed', () => { - createSuccessTask = getCreateSuccessTask(true) + createSuccessfulTask = getCreateSuccessfulTask(true) createFailTask = getCreateFailTask(true) - const task = parallelSequence(createSuccessTask, createFailTask, createSuccessTask)(success, fail, message) + const task = parallelSequence(createSuccessfulTask, createFailTask, createSuccessfulTask)(succeed, fail, send) expect(task.name).toBe('parallel-sequence') task.run() + expect(send).toHaveBeenCalledTimes(0) expect(fail).not.toBeCalled() jest.runOnlyPendingTimers() - expect(success).not.toBeCalled() + expect(send).toBeCalledWith('will succeed', 'succeed(0)') + expect(send).toBeCalledWith('succeed', 'succeed(0)') + expect(send).toBeCalledWith('will fail', 'fail(1)') + expect(send).toBeCalledWith('fail', 'fail(1)') + expect(send).toHaveBeenCalledTimes(4) + + expect(succeed).not.toBeCalled() expect(fail).toBeCalled() - expect(counterSuccessChild).toBe(1) + expect(counterSucceedChild).toBe(1) expect(counterFailChild).toBe(1) }) }) @@ -326,78 +359,108 @@ describe('composite.spec', () => { it('should fail when all task failed', () => { createFailTask = getCreateFailTask(true) - const task = parallelSelector(createFailTask, createFailTask)(success, fail, message) + const task = parallelSelector(createFailTask, createFailTask)(succeed, fail, send) expect(task.name).toBe('parallel-selector') task.run() + expect(send).toHaveBeenCalledTimes(0) expect(fail).not.toBeCalled() jest.runOnlyPendingTimers() + expect(send).toBeCalledWith('will fail', 'fail(0)') + expect(send).toBeCalledWith('fail', 'fail(0)') + expect(send).toBeCalledWith('will fail', 'fail(1)') + expect(send).toBeCalledWith('fail', 'fail(1)') + expect(send).toHaveBeenCalledTimes(4) + expect(fail).toBeCalled() - expect(success).not.toBeCalled() + expect(succeed).not.toBeCalled() expect(counterFailChild).toBe(2) - expect(counterSuccessChild).toBe(0) + expect(counterSucceedChild).toBe(0) }) - it('should success as soon as one succeed', () => { - createSuccessTask = getCreateSuccessTask(true) + it('should succeed as soon as one succeed', () => { + createSuccessfulTask = getCreateSuccessfulTask(true) createFailTask = getCreateFailTask(true) - const task = parallelSelector(createFailTask, createSuccessTask, createFailTask)(success, fail, message) + const task = parallelSelector(createFailTask, createSuccessfulTask, createFailTask)(succeed, fail, send) expect(task.name).toBe('parallel-selector') task.run() - expect(success).not.toBeCalled() + expect(send).toHaveBeenCalledTimes(0) + expect(succeed).not.toBeCalled() jest.runOnlyPendingTimers() + expect(send).toBeCalledWith('will fail', 'fail(0)') + expect(send).toBeCalledWith('fail', 'fail(0)') + expect(send).toBeCalledWith('will succeed', 'succeed(1)') + expect(send).toBeCalledWith('succeed', 'succeed(1)') + expect(send).toHaveBeenCalledTimes(4) + expect(fail).not.toBeCalled() - expect(success).toBeCalled() + expect(succeed).toBeCalled() expect(counterFailChild).toBe(1) - expect(counterSuccessChild).toBe(1) + expect(counterSucceedChild).toBe(1) }) }) describe('all', () => { - it('should success when all task succeed', () => { - createSuccessTask = getCreateSuccessTask(true) + it('should succeed when all task succeed', () => { + createSuccessfulTask = getCreateSuccessfulTask(true) - const task = parallelAll(createSuccessTask, createSuccessTask)(success, fail, message) + const task = parallelAll(createSuccessfulTask, createSuccessfulTask)(succeed, fail, send) expect(task.name).toBe('parallel-all') task.run() - expect(success).not.toBeCalled() + expect(send).toHaveBeenCalledTimes(0) + expect(succeed).not.toBeCalled() jest.runOnlyPendingTimers() - expect(success).toBeCalled() + expect(send).toBeCalledWith('will succeed', 'succeed(0)') + expect(send).toBeCalledWith('succeed', 'succeed(0)') + expect(send).toBeCalledWith('will succeed', 'succeed(1)') + expect(send).toBeCalledWith('succeed', 'succeed(1)') + expect(send).toHaveBeenCalledTimes(4) + + expect(succeed).toBeCalled() expect(fail).not.toBeCalled() - expect(counterSuccessChild).toBe(2) + expect(counterSucceedChild).toBe(2) expect(counterFailChild).toBe(0) }) it('should fail if at least one failed', () => { - createSuccessTask = getCreateSuccessTask(true) + createSuccessfulTask = getCreateSuccessfulTask(true) createFailTask = getCreateFailTask(true) - const task = parallelAll(createSuccessTask, createFailTask, createSuccessTask)(success, fail, message) + const task = parallelAll(createSuccessfulTask, createFailTask, createSuccessfulTask)(succeed, fail, send) expect(task.name).toBe('parallel-all') task.run() + expect(send).toHaveBeenCalledTimes(0) expect(fail).not.toBeCalled() jest.runOnlyPendingTimers() - expect(success).not.toBeCalled() + expect(send).toBeCalledWith('will succeed', 'succeed(0)') + expect(send).toBeCalledWith('succeed', 'succeed(0)') + expect(send).toBeCalledWith('will fail', 'fail(1)') + expect(send).toBeCalledWith('fail', 'fail(1)') + expect(send).toBeCalledWith('will succeed', 'succeed(2)') + expect(send).toBeCalledWith('succeed', 'succeed(2)') + expect(send).toHaveBeenCalledTimes(6) + + expect(succeed).not.toBeCalled() expect(fail).toBeCalled() - expect(counterSuccessChild).toBe(2) + expect(counterSucceedChild).toBe(2) expect(counterFailChild).toBe(1) }) }) diff --git a/src/__tests__/configArray.spec.js b/src/__tests__/configArray.spec.js index 1308739..1721606 100644 --- a/src/__tests__/configArray.spec.js +++ b/src/__tests__/configArray.spec.js @@ -23,45 +23,45 @@ describe('configArray.spec', () => { cases( 'invalid parsing, it should throw a parsing error', - ({ config, message }) => { + ({ config, send }) => { expect(() => { configArray(config) - }).toThrowError(message) + }).toThrowError(send) }, { - null: { config: null, message: errorElement }, - '[]': { config: [], message: errorCompositeName }, + null: { config: null, send: errorElement }, + '[]': { config: [], send: errorCompositeName }, '["serieSelector"]': { config: ['serieSelector'], - message: errorComposite, + send: errorComposite, }, '["unknown", () => {}]': { config: ['unknown', () => {}], - message: errorCompositeName, + send: errorCompositeName, }, '["serieSelector", null]': { config: ['serieSelector', null], - message: errorElement, + send: errorElement, }, '["serieSelector", []]': { config: ['serieSelector', []], - message: errorCompositeName, + send: errorCompositeName, }, '["serieSelector", ["parallelSequence"]]': { config: ['serieSelector', ['parallelSequence']], - message: errorComposite, + send: errorComposite, }, '["serieSelector", ["unknown", () => {}]]': { config: ['serieSelector', ['unknown', () => {}]], - message: errorCompositeName, + send: errorCompositeName, }, '["serieSelector", ["parallelSequence", null]]': { config: ['serieSelector', ['parallelSequence', null]], - message: errorElement, + send: errorElement, }, '["serieSelector", ["parallelSequence", []]]': { config: ['serieSelector', ['parallelSequence', []]], - message: errorCompositeName, + send: errorCompositeName, }, }, ) diff --git a/src/__tests__/decorator.spec.js b/src/__tests__/decorator.spec.js index 91d56f5..98b6d44 100644 --- a/src/__tests__/decorator.spec.js +++ b/src/__tests__/decorator.spec.js @@ -1,146 +1,146 @@ describe('decorator.spec', () => { jest.useFakeTimers() - const { alwaysSuccess, alwaysFail, invert, immediate } = require('../decorator') - const { createSuccessTask, createFailTask } = require('../task') + const { alwaysSucceed, alwaysFail, invert, immediate } = require('../decorator') + const { createSucceedfulTask, createFailureTask } = require('../task') const { noop } = require('../util') - let success = jest.fn() + let succeed = jest.fn() let fail = jest.fn() - let message = jest.fn() + let send = jest.fn() let run = jest.fn() let cancel = jest.fn() let enhanceTask beforeEach(() => { - success.mockClear() + succeed.mockClear() fail.mockClear() - message.mockClear() + send.mockClear() run.mockClear() cancel.mockClear() }) - describe('alwaysSuccess', () => { - it('should success with a success task', () => { - enhanceTask = alwaysSuccess(createSuccessTask)(success, fail, message) + describe('alwaysSucceed', () => { + it('should succeed with a succeed task', () => { + enhanceTask = alwaysSucceed(createSucceedfulTask)(succeed, fail, send) - expect(enhanceTask.name).toBe('@alwaysSuccess(success)') + expect(enhanceTask.name).toBe('@alwaysSucceed(succeed)') expect(enhanceTask.cancel).toBe(noop) enhanceTask.run('foo', 'bar') - expect(message).toHaveBeenCalledWith('will success with params: ["foo","bar"]') - expect(success).toBeCalled() + expect(send).toHaveBeenCalledWith('will succeed with params: ["foo","bar"]') + expect(succeed).toBeCalled() expect(fail).not.toBeCalled() }) - it('should success with a fail task', () => { - enhanceTask = alwaysSuccess(createFailTask)(success, fail, message) + it('should succeed with a fail task', () => { + enhanceTask = alwaysSucceed(createFailureTask)(succeed, fail, send) - expect(enhanceTask.name).toBe('@alwaysSuccess(fail)') + expect(enhanceTask.name).toBe('@alwaysSucceed(fail)') expect(enhanceTask.cancel).toBe(noop) enhanceTask.run('foo', 'bar') - expect(message).toHaveBeenCalledWith('will fail with params: ["foo","bar"]') - expect(success).toBeCalled() + expect(send).toHaveBeenCalledWith('will fail with params: ["foo","bar"]') + expect(succeed).toBeCalled() expect(fail).not.toBeCalled() }) }) describe('alwaysFailed', () => { - it('should fail with a success task', () => { - enhanceTask = alwaysFail(createSuccessTask)(success, fail, message) + it('should fail with a succeed task', () => { + enhanceTask = alwaysFail(createSucceedfulTask)(succeed, fail, send) - expect(enhanceTask.name).toBe('@alwaysFail(success)') + expect(enhanceTask.name).toBe('@alwaysFail(succeed)') expect(enhanceTask.cancel).toBe(noop) enhanceTask.run('foo', 'bar') - expect(message).toHaveBeenCalledWith('will success with params: ["foo","bar"]') + expect(send).toHaveBeenCalledWith('will succeed with params: ["foo","bar"]') expect(fail).toBeCalled() - expect(success).not.toBeCalled() + expect(succeed).not.toBeCalled() }) it('should fail with a fail task', () => { - enhanceTask = alwaysFail(createFailTask)(success, fail, message) + enhanceTask = alwaysFail(createFailureTask)(succeed, fail, send) expect(enhanceTask.name).toBe('@alwaysFail(fail)') expect(enhanceTask.cancel).toBe(noop) enhanceTask.run('foo', 'bar') - expect(message).toHaveBeenCalledWith('will fail with params: ["foo","bar"]') + expect(send).toHaveBeenCalledWith('will fail with params: ["foo","bar"]') expect(fail).toBeCalled() - expect(success).not.toBeCalled() + expect(succeed).not.toBeCalled() }) }) describe('invert', () => { - it('should fail with a success task', () => { - enhanceTask = invert(createSuccessTask)(success, fail, message) + it('should fail with a succeed task', () => { + enhanceTask = invert(createSucceedfulTask)(succeed, fail, send) - expect(enhanceTask.name).toBe('@invert(success)') + expect(enhanceTask.name).toBe('@invert(succeed)') expect(enhanceTask.cancel).toBe(noop) enhanceTask.run('foo', 'bar') - expect(message).toHaveBeenCalledWith('will success with params: ["foo","bar"]') + expect(send).toHaveBeenCalledWith('will succeed with params: ["foo","bar"]') expect(fail).toBeCalled() - expect(success).not.toBeCalled() + expect(succeed).not.toBeCalled() }) - it('should success with a fail task', () => { - enhanceTask = invert(createFailTask)(success, fail, message) + it('should succeed with a fail task', () => { + enhanceTask = invert(createFailureTask)(succeed, fail, send) expect(enhanceTask.name).toBe('@invert(fail)') expect(enhanceTask.cancel).toBe(noop) enhanceTask.run('foo', 'bar') - expect(message).toHaveBeenCalledWith('will fail with params: ["foo","bar"]') - expect(success).toBeCalled() + expect(send).toHaveBeenCalledWith('will fail with params: ["foo","bar"]') + expect(succeed).toBeCalled() expect(fail).not.toBeCalled() }) }) describe('immediate', () => { - it('should success with a success task', () => { - enhanceTask = immediate(createSuccessTask)(success, fail, message) + it('should succeed with a succeed task', () => { + enhanceTask = immediate(createSucceedfulTask)(succeed, fail, send) - expect(enhanceTask.name).toBe('@immediate(success)') + expect(enhanceTask.name).toBe('@immediate(succeed)') enhanceTask.run('foo', 'bar') - expect(message).not.toBeCalled() - expect(success).not.toBeCalled() + expect(send).not.toBeCalled() + expect(succeed).not.toBeCalled() jest.runAllImmediates() - expect(message).toHaveBeenCalledWith('will success with params: ["foo","bar"]') + expect(send).toHaveBeenCalledWith('will succeed with params: ["foo","bar"]') expect(fail).not.toBeCalled() - expect(success).toBeCalled() + expect(succeed).toBeCalled() }) - it('should cancel a success task', () => { - enhanceTask = immediate(createSuccessTask)(success, fail, message) + it('should cancel a succeed task', () => { + enhanceTask = immediate(createSucceedfulTask)(succeed, fail, send) - expect(enhanceTask.name).toBe('@immediate(success)') + expect(enhanceTask.name).toBe('@immediate(succeed)') enhanceTask.run('foo', 'bar') - expect(message).not.toBeCalled() - expect(success).not.toBeCalled() + expect(send).not.toBeCalled() + expect(succeed).not.toBeCalled() enhanceTask.cancel() jest.runAllImmediates() - expect(message).not.toBeCalled() + expect(send).not.toBeCalled() expect(fail).not.toBeCalled() - expect(success).not.toBeCalled() + expect(succeed).not.toBeCalled() }) }) }) diff --git a/src/__tests__/task.spec.js b/src/__tests__/task.spec.js index 11d8854..cf971c7 100644 --- a/src/__tests__/task.spec.js +++ b/src/__tests__/task.spec.js @@ -1,29 +1,29 @@ describe('task.spec', () => { - const { createSuccessTask, createFailTask } = require('../task') + const { createSucceedfulTask, createFailureTask } = require('../task') - it('should create a success task', () => { - const success = jest.fn() - const message = jest.fn() - const task = createSuccessTask(success, null, message) + it('should create a succeed task', () => { + const succeed = jest.fn() + const send = jest.fn() + const task = createSucceedfulTask(succeed, null, send) - expect(task.name).toBe('success') + expect(task.name).toBe('succeed') task.run({ config: 'foo' }) - expect(message).toHaveBeenCalledWith('will success with params: [{"config":"foo"}]') - expect(success).toHaveBeenCalledWith('success') + expect(send).toHaveBeenCalledWith('will succeed with params: [{"config":"foo"}]') + expect(succeed).toHaveBeenCalledWith('succeed') }) it('should create a fail task', () => { const fail = jest.fn() - const message = jest.fn() - const task = createFailTask(null, fail, message) + const send = jest.fn() + const task = createFailureTask(null, fail, send) expect(task.name).toBe('fail') task.run({ config: 'foo' }) - expect(message).toHaveBeenCalledWith('will fail with params: [{"config":"foo"}]') + expect(send).toHaveBeenCalledWith('will fail with params: [{"config":"foo"}]') expect(fail).toHaveBeenCalledWith('fail') }) }) diff --git a/src/composite.js b/src/composite.js index 818d705..affe6f3 100644 --- a/src/composite.js +++ b/src/composite.js @@ -1,16 +1,14 @@ import { noop } from './util' const cancelTask = task => { - if (task) { - task.cancel() - } + task.cancel() } const composite = (branch, mode) => (...createTasks) => { const nbTasks = createTasks.length if (!nbTasks) { - return success => ({ run: success }) + return succeed => ({ run: succeed }) } const name = `${BRANCH_NAME[branch]}-${MODE_NAME[mode]}` @@ -20,37 +18,43 @@ const composite = (branch, mode) => (...createTasks) => { let runNext let runAll - return (success, fail, message) => { - const successChild = i => content => { + return (succeed, fail, send) => { + const succeedChild = i => content => { + if (content) { + send(content, getTaskName(i)) + } + if (--remains === 0) { cancelTasks() if (failedOnce) { - fail(content) + fail() } else { - success(content) + succeed() } } else if (mode === SELECTOR) { cancelTasks() - success(content) + succeed() } else { runNext(i) } } const failChild = i => content => { + if (content) { + send(content, getTaskName(i)) + } + if (--remains === 0 || mode === SEQUENCE) { cancelTasks() - fail(content) + fail() } else { failedOnce = true runNext(i) } } - const messageChild = i => content => { - if (tasks) { - message(content, tasks[i].name) - } + const sendChild = i => content => { + send(content, getTaskName(i)) } if (branch === SERIE) { @@ -61,7 +65,11 @@ const composite = (branch, mode) => (...createTasks) => { runAll = (...params) => tasks.forEach(task => task.run(...params)) } - tasks = createTasks.map((createTask, i) => createTask(successChild(i), failChild(i), messageChild(i))) + tasks = createTasks.map((createTask, i) => createTask(succeedChild(i), failChild(i), sendChild(i))) + + function getTaskName(i) { + return `${tasks[i].name}(${i})` + } function cancelTasks() { tasks.forEach(cancelTask) diff --git a/src/decorator.js b/src/decorator.js index 9dab96a..a288ab0 100644 --- a/src/decorator.js +++ b/src/decorator.js @@ -2,8 +2,8 @@ import 'setimmediate' export const decorateName = (decoratorName, taskName) => `@${decoratorName}(${taskName})` -const simple = (name, mapCallback) => createTask => (success, fail, message) => { - const task = createTask(...mapCallback(success, fail), message) +const simple = (name, mapCallback) => createTask => (succeed, fail, send) => { + const task = createTask(...mapCallback(succeed, fail), send) return { ...task, @@ -11,14 +11,14 @@ const simple = (name, mapCallback) => createTask => (success, fail, message) => } } -export const alwaysSuccess = simple('alwaysSuccess', (success, _) => [success, success]) +export const alwaysSucceed = simple('alwaysSucceed', (succeed, _) => [succeed, succeed]) export const alwaysFail = simple('alwaysFail', (_, fail) => [fail, fail]) -export const invert = simple('invert', (success, fail) => [fail, success]) +export const invert = simple('invert', (succeed, fail) => [fail, succeed]) -export const immediate = createTask => (success, fail, message) => { - const { name, run, cancel } = createTask(success, fail, message) +export const immediate = createTask => (succeed, fail, send) => { + const { name, run, cancel } = createTask(succeed, fail, send) let id return { diff --git a/src/task.js b/src/task.js index 773e246..aeda8bb 100644 --- a/src/task.js +++ b/src/task.js @@ -1,18 +1,18 @@ import { noop } from './util' -export const createSuccessTask = (success, _, message) => ({ - name: 'success', +export const createSucceedfulTask = (succeed, _, send) => ({ + name: 'succeed', run(...params) { - message(`will success with params: ${JSON.stringify(params)}`) - success('success') + send(`will succeed with params: ${JSON.stringify(params)}`) + succeed('succeed') }, cancel: noop, }) -export const createFailTask = (_, fail, message) => ({ +export const createFailureTask = (_, fail, send) => ({ name: 'fail', run(...params) { - message(`will fail with params: ${JSON.stringify(params)}`) + send(`will fail with params: ${JSON.stringify(params)}`) fail('fail') }, cancel: noop,