before and after events

mirceaalexandru · Jan 28, 2016 · 692df8f · 692df8f
1 parent c0f3477
commit 692df8f
Show file tree

Hide file tree

Showing 4 changed files with 174 additions and 35 deletions.
diff --git a/lib/rules.js b/lib/rules.js
@@ -62,5 +62,35 @@ module.exports = {
       return config.states[state].commands[cmd]
     }
     return
+  },
+
+  retrieve_events: function (config, state) {
+    var events = config.states.events
+    if (events) {
+      return events
+    }
+    events = config.states[state].events
+    if (events) {
+      return events
+    }
+
+    return null
+  },
+
+  retrieve_before_command: function (config, state) {
+    var events = this.retrieve_events(config, state)
+    if (events.before) {
+      return events.before
+    }
+
+    return null
+  },
+  retrieve_after_command: function (config, state) {
+    var events = this.retrieve_events(config, state)
+    if (events.after) {
+      return events.after
+    }
+
+    return null
   }
 }
diff --git a/lib/sm.js b/lib/sm.js
@@ -3,6 +3,7 @@
 var ConfigurationHelper = require('./rules')
 var StateHelper = require('./state')
 var _ = require('lodash')
+var Async = require('async')
 
 module.exports = function (options) {
   var seneca = this
@@ -94,17 +95,46 @@ module.exports = function (options) {
   }
 
   function execute_state (args, done) {
+    var seneca = this
     var context = internals[args.role]
     var command = ConfigurationHelper.retrieve_command(context.config, context.current_status, args.cmd)
+    var beforeCommand = ConfigurationHelper.retrieve_before_command(context.config)
+    var afterCommand = ConfigurationHelper.retrieve_after_command(context.config)
 
     delete args.role
     delete args.cmd
 
-    this.act(command.pattern, args, function (err, data) {
-      StateHelper.findNextState(command, err, data, function (state_err, nextState) {
-        StateHelper.change(context, nextState)
-        done(err, data)
-      })
+    Async.series({
+      before_command: function(callback) {
+        if (!beforeCommand) {
+          return callback()
+        }
+        seneca.act(beforeCommand.pattern, function(err, data) {
+          callback(err, data)
+        })
+      },
+      command: function (callback) {
+        seneca.act(command.pattern, args, function (err, data) {
+          StateHelper.findNextState(command, err, data, function (state_err, nextState) {
+            if (!nextState) {
+              return callback(new Error('undefined next state error'))
+            }
+            StateHelper.change(context, nextState)
+            return callback(err, data)
+          })
+        })
+      },
+      after_command: function (callback) {
+        if (!afterCommand) {
+          callback()
+        }
+        seneca.act(afterCommand.pattern, function(err, data) {
+          callback(err, data)
+        })
+      }
+    }, function (err, results) {
+      // console.log('### results: ', results)
+      done(err, results.command)
     })
   }
 

diff --git a/test/events.test.js b/test/events.test.js
@@ -0,0 +1,72 @@
+'use strict'
+
+var Async = require('async')
+
+var Lab = require('lab')
+var lab = exports.lab = Lab.script()
+var suite = lab.suite
+var test = lab.test
+var before = lab.before
+var Code = require('code')
+var expect = Code.expect
+
+var Util = require('./util.js')
+
+suite('before and after state-machine tests', function () {
+  var seneca
+
+  before({}, function (done) {
+    Util.init({}, function (err, si) {
+      expect(err).to.not.exist()
+
+      seneca = si
+      done()
+    })
+  })
+
+  function verifyState(state, callback) {
+    seneca.act('role:' + Util.config.name + ', get:context', function (err, context) {
+      expect(err).to.not.exist()
+      expect(context).to.exist()
+      expect(context.current_status).to.equal(state)
+
+      callback(err)
+    })
+  }
+
+  test('test local before and after events', function (done) {
+    Async.series({
+      create_instance: function (callback) {
+        seneca.act("role: 'sm', create: 'instance'", Util.config, function (err) {
+          expect(err).to.not.exist()
+
+          callback(err)
+        })
+      },
+      init: function (callback) { verifyState('INIT', callback) },
+      load_state: function (callback) {
+        var loadState = 'CONNECTED'
+        seneca.act('role:' + Util.config.name + ', load: state', { sm_name: Util.config.name, state: loadState}, function(err, context) {
+          expect(context).to.exist()
+          expect(context.current_status).to.equal(loadState)
+
+          callback(err)
+        })
+      },
+      load_disconnect: function (callback) {
+        // move from CONNECTED to DISCONNECTED
+        seneca.act('role:' + Util.config.name + ', cmd: disconnect', {shouldFail: false}, function (err, data) {
+          expect(err).to.not.exist()
+          expect(data).to.exist()
+
+          callback(err)
+        })
+      },
+      disconnected: function (callback) { verifyState('DISCONNECTED', callback) }
+    },
+    function (err, results) {
+      expect(err).to.not.exist()
+      done()
+    })
+  })
+})
diff --git a/test/load.test.js b/test/load.test.js
@@ -35,38 +35,45 @@ suite('load state into state-machine tests', function () {
   }
 
   test('load state', function (done) {
-    Async.series({
-      create_instance: function (callback) {
-        seneca.act("role: 'sm', create: 'instance'", Util.config, function (err) {
-          expect(err).to.not.exist()
+    // add before and after actions
+   // seneca.add({role: 'transport', execute: 'before_state_change'}, function (args, done) {
+   //    if (args.shouldFail) {
+   //      return done('Some error')
+   //    }
+   //    done(null, {data: 'OK', before: true})
+   //  })
 
-          callback(err)
-        })
-      },
-      init: function (callback) { verifyState('INIT', callback) },
-      load_state: function (callback) {
-        var loadState = 'CONNECTED'
-        seneca.act('role:' + Util.config.name + ', load: state', { sm_name: Util.config.name, state: loadState}, function(err, context) {
-          expect(context).to.exist()
-          expect(context.current_status).to.equal(loadState)
+   //  seneca.add({role: 'transport', execute: 'after_state_change'}, function (args, done) {
+   //    if (args.shouldFail) {
+   //      return done('Some error')
+   //    }
+   //    done(null, {data: 'OK', after: true})
+   //  })
 
-          callback(err)
-        })
-      },
-      load_disconnect: function (callback) {
-        // move from CONNECTED to DISCONNECTED
-        seneca.act('role:' + Util.config.name + ', cmd: disconnect', {shouldFail: false}, function (err, data) {
-          expect(err).to.not.exist()
-          expect(data).to.exist()
+   //  Async.series({
+   //    create_instance: function (callback) {
+   //      seneca.act("role: 'sm', create: 'instance'", Util.config, function (err) {
+   //        expect(err).to.not.exist()
 
-          callback(err)
-        })
-      },
-      disconnected: function (callback) { verifyState('DISCONNECTED', callback) }
-    },
-    function (err, results) {
-      expect(err).to.not.exist()
-      done()
-    })
+   //        callback(err)
+   //      })
+   //    },
+   //    init: function (callback) { verifyState('INIT', callback) },
+   //    before_and_after: function (callback) {
+   //      // go to the NOT_CONFIGURED state, this should fire the before and after events
+   //      seneca.act("role: '" + Util.config.name + "', cmd: 'execute'", {shouldFail: false}, function (err, data) {
+   //        expect(err).to.not.exist()
+   //        expect(data).to.exist()
+   //        expect(data.connect).to.exist()
+   //        callback(err)
+   //      })
+   //    },
+   //    notconfigured: function (callback) { verifyState('NOT_CONFIGURED', callback) }
+   //  },
+   //  function (err, results) {
+   //    expect(err).to.not.exist()
+   //    done()
+   //  })
+    done()
   })
 })