71

.eslintrc.json

@@ -1,6 +1,7 @@
 {
     "extends": "standard",
     "rules": {
-      "no-useless-constructor": ["off", "always"]
+      "no-useless-constructor": ["off", "always"],
+      "standard/no-callback-literal": ["off", "always"]
     }
 }

build.js

@@ -11,7 +11,7 @@ new ExecutedLint(process, './src').after(
   new ExecutedLint(process, './test').after(
     new ExecutedTestCoverageCheck(
       new ExecutedTestCoverage(
-        process, './test/simple-test.js'
+        process, './test/test.js'
       ),
       { 'lines': 100, 'functions': 100, 'branches': 100 }
     )

index.js

@@ -2,7 +2,6 @@ module.exports = {
 
   AsyncObject: require('./src/AsyncObject'),
   Event: require('./src/Event'),
-  as: require('./src/As'),
-  NullError: require('./src/NullError')
+  as: require('./src/As')
 
 }

package.json

@@ -7,7 +7,7 @@
     "test": "test"
   },
   "scripts": {
-    "test": "node test/simple-test",
+    "test": "node test/test",
     "build": "node build"
   },
   "repository": {

src/AsyncTreeNode.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const TreeNode = require('./TreeNode')
-const NullError = require('./NullError')
 
 class AsyncTreeNode extends TreeNode {
   /*
@@ -28,7 +27,11 @@ class AsyncTreeNode extends TreeNode {
       }
     } catch (error) {
       if (error.message !== 'asyncCall or syncCall must be defined') {
-        this.field.onError(error)
+        if (this.field.continueAfterFail()) {
+          this.field.onErrorAndResult(error)
+        } else {
+          this.field.onError(error)
+        }
       } else {
         let syncCall = this.field.definedSyncCall()
         this.invokeSyncCall(syncCall, ...args)
@@ -82,22 +85,16 @@ class AsyncTreeNode extends TreeNode {
     let isProcessed = false
     // It's not possible to get rid of null here :(
     if (error != null) {
-      if (this.hasParent()) {
-        if (this.field.continueAfterFail()) {
-          let totalResult = this.field.onErrorAndResult(error, ...results)
-          this.field.saveValueIntoCacheIfNeeded(totalResult)
+      if (this.field.continueAfterFail()) {
+        let totalResult = this.field.onErrorAndResult(error, ...results)
+        this.field.saveValueIntoCacheIfNeeded(totalResult)
+        if (this.hasParent()) {
           super.callParent(totalResult)
         } else {
-          this.field.onError(error)
-        }
-      } else {
-        if (this.field.continueAfterFail()) {
-          let totalResult = this.field.onErrorAndResult(error, ...results)
-          this.field.saveValueIntoCacheIfNeeded(totalResult)
           this.field.callNextTreeIfExists()
-        } else {
-          this.field.onError(error)
         }
+      } else {
+        this.field.onError(error)
       }
       isProcessed = true
     }
@@ -107,7 +104,7 @@ class AsyncTreeNode extends TreeNode {
   processedResult (...results) {
     let totalResult
     if (this.field.continueAfterFail()) {
-      totalResult = this.field.onErrorAndResult(new NullError(), ...results)
+      totalResult = this.field.onErrorAndResult(null, ...results)
     } else {
       totalResult = this.field.onResult(...results)
     }

test/AsyncObjectWithArgs.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const AsyncObject = require('./../src/AsyncObject')
+
+class AsyncObjectWithArgs extends AsyncObject {
+  constructor (...args) {
+    super(...args)
+  }
+
+  definedAsyncCall () {
+    return (...args) => {
+      let callback = args[args.length - 1]
+      return callback(null, ...args.slice(0, args.length - 1))
+    }
+  }
+}
+
+module.exports = AsyncObjectWithArgs

test/AsyncObjectWithAssertedErrorInCallback.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const AsyncObject = require('./../src/AsyncObject')
+const assert = require('assert')
+
+class AsyncObjectWithAssertedErrorInCallback extends AsyncObject {
+  constructor () {
+    super()
+  }
+
+  definedAsyncCall () {
+    return (callback) => {
+      return callback(new Error('async error'))
+    }
+  }
+
+  onError (error) {
+    assert.deepStrictEqual(error, new Error('async error'))
+  }
+}
+
+module.exports = AsyncObjectWithAssertedErrorInCallback

test/AsyncObjectWithAssertedErrorInDefinedCall.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const AsyncObject = require('./../src/AsyncObject')
+const assert = require('assert')
+
+class AsyncObjectWithAssertedErrorInDefinedCall extends AsyncObject {
+  constructor () {
+    super()
+  }
+
+  definedAsyncCall () {
+    return () => {
+      throw new Error('async error')
+    }
+  }
+
+  onError (error) {
+    assert.deepStrictEqual(error, new Error('async error'))
+  }
+}
+
+module.exports = AsyncObjectWithAssertedErrorInDefinedCall

test/AsyncObjectWithAssertedResultInCallback.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const AsyncObject = require('./../src/AsyncObject')
+const assert = require('assert')
+
+class AsyncObjectWithAssertedResultInCallback extends AsyncObject {
+  constructor () {
+    super()
+  }
+
+  definedAsyncCall () {
+    return (callback) => {
+      return callback(null, 'result')
+    }
+  }
+
+  onResult (result) {
+    assert.strictEqual(result, 'result')
+    return result
+  }
+}
+
+module.exports = AsyncObjectWithAssertedResultInCallback

test/AsyncObjectWithAssertedSafeErrorAndResultInCallback.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const AsyncObject = require('./../src/AsyncObject')
+const assert = require('assert')
+
+class AsyncObjectWithAssertedSafeErrorAndResultInCallback extends AsyncObject {
+  constructor () {
+    super()
+  }
+
+  definedAsyncCall () {
+    return (callback) => {
+      return callback(null, 'result')
+    }
+  }
+
+  onErrorAndResult (error, result) {
+    assert.strictEqual(super.onErrorAndResult(error, result), 'result')
+    return result
+  }
+
+  continueAfterFail () {
+    return true
+  }
+}
+
+module.exports = AsyncObjectWithAssertedSafeErrorAndResultInCallback

test/AsyncObjectWithAssertedSafeErrorInCallback.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const AsyncObject = require('./../src/AsyncObject')
+const assert = require('assert')
+
+class AsyncObjectWithAssertedSafeErrorInCallback extends AsyncObject {
+  constructor () {
+    super()
+  }
+
+  definedAsyncCall () {
+    return (callback) => {
+      return callback(new Error('safe async error'), 'result')
+    }
+  }
+
+  onErrorAndResult (error, result) {
+    assert.deepStrictEqual(error, new Error('safe async error'))
+    assert.strictEqual(result, 'result')
+    return error
+  }
+
+  continueAfterFail () {
+    return true
+  }
+}
+
+module.exports = AsyncObjectWithAssertedSafeErrorInCallback

test/AsyncObjectWithAssertedSafeErrorInDefinedCall.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const AsyncObject = require('./../src/AsyncObject')
+const assert = require('assert')
+
+class AsyncObjectWithAssertedSafeErrorInDefinedCall extends AsyncObject {
+  constructor () {
+    super()
+  }
+
+  definedAsyncCall () {
+    return () => {
+      throw new Error('safe async error')
+    }
+  }
+
+  onErrorAndResult (error) {
+    assert.deepStrictEqual(error, new Error('safe async error'))
+  }
+
+  continueAfterFail () {
+    return true
+  }
+}
+
+module.exports = AsyncObjectWithAssertedSafeErrorInDefinedCall

test/AsyncObjectWithAssertedSafeResultInCallback.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const AsyncObject = require('./../src/AsyncObject')
+const assert = require('assert')
+
+class AsyncObjectWithAssertedSafeResultInCallback extends AsyncObject {
+  constructor () {
+    super()
+  }
+
+  definedAsyncCall () {
+    return (callback) => {
+      return callback(null, 'result')
+    }
+  }
+
+  onErrorAndResult (error, result) {
+    assert.strictEqual(error, null)
+    assert.strictEqual(result, 'result')
+    return result
+  }
+
+  continueAfterFail () {
+    return true
+  }
+}
+
+module.exports = AsyncObjectWithAssertedSafeResultInCallback

test/AsyncObjectWithoutError.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const AsyncObject = require('./../src/AsyncObject')
+
+class AsyncObjectWithoutError extends AsyncObject {
+  constructor () {
+    super()
+  }
+
+  definedAsyncCall () {
+    return (callback) => {
+      callback('value')
+    }
+  }
+
+  callbackWithError () {
+    return false
+  }
+}
+
+module.exports = AsyncObjectWithoutError

test/BrokenEvent.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const Event = require('./../src/Event')
+
+class BrokenEvent extends Event {
+  constructor () {
+    super()
+  }
+}
+
+module.exports = BrokenEvent

test/BrokenTreeNode.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const TreeNode = require('./../src/TreeNode')
+
+class BrokenTreeNode extends TreeNode {
+  /*
+    field: simple argument (not AsyncObject, can be Event)
+    parent: AsyncTreeNode or NotDefinedAsyncTree
+    position: int
+  */
+  constructor (field, parent, position) {
+    super(field, parent, position)
+  }
+}
+
+module.exports = BrokenTreeNode

test/DeepStrictEqualAssertion.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const AsyncObject = require('./../src/AsyncObject')
+const assert = require('assert')
+
+class DeepStrictEqualAssertion extends AsyncObject {
+  constructor (actual, expected) {
+    super(actual, expected)
+  }
+
+  definedSyncCall () {
+    return (actual, expected) => {
+      assert.deepStrictEqual(actual, expected)
+      return actual
+    }
+  }
+}
+
+module.exports = DeepStrictEqualAssertion