Unit tests improvements + code fmt

Author: fbeline

doc/documentation.md

@@ -81,7 +81,7 @@ For example, let's say that when a coin transition is triggered we should pass t
 
 #### Guard
 
-Guard is a function responsible to determine if a state should change or not.
+Guard is responsible to determine if a state should change or not.
 
 Supposing that the minimum coin value to unlock the turnstile should be 50.
 
@@ -90,7 +90,7 @@ Supposing that the minimum coin value to unlock the turnstile should be 50.
 (defn inc-amount [acc amount] (+ acc amount))
 
 (defn guard-handler [_state amount]
-  (when (>= amount 50)))
+  (>= amount 50))
 
 (defsm turnstile
   [[:locked -> :unlocked when :coin action `inc-amount guard `guard-handler]
@@ -101,5 +101,5 @@ Supposing that the minimum coin value to unlock the turnstile should be 50.
     :state) ;; => :lock
 ```
 
-The guard handler must be a function with two parameters, being the first the current state and the second the message
+The guard handler must be a function with two parameters, being the first the accumulator and the second the message
 sent by `send-event`.

src/fsm_clj/core.clj

@@ -5,13 +5,13 @@
 (s/def ::action (s/cat :_ #{'action} :handler any?))
 (s/def ::guard (s/cat :_ #{'guard} :handler any?))
 (s/def ::transition
- (s/cat
-  :state keyword?
-  :_-> #{'->}
-  :target keyword?
-  :_when #{'when}
-  :event keyword?
-  :opts (s/* (s/alt :action ::action :guard ::guard))))
+  (s/cat
+   :state keyword?
+   :_-> #{'->}
+   :target keyword?
+   :_when #{'when}
+   :event keyword?
+   :opts (s/* (s/alt :action ::action :guard ::guard))))
 
 (defn- set-state [fsm state]
   (if ((->> fsm :transitions keys (into #{})) state)
@@ -25,8 +25,8 @@
 
 (defmacro eval-fn [opts attr]
   `(if (-> ~opts ~attr nil?)
-    (fn [acc# _#] (if (= ~attr :guard) true acc#))
-    @(-> ~opts ~attr :handler eval resolve)))
+     (fn [acc# _#] (if (= ~attr :guard) true acc#))
+     @(-> ~opts ~attr :handler eval resolve)))
 
 (defn- parse-fsm-transition [transition]
   (let [parsed (s/conform ::transition transition)

test/fsm_clj/core_test.clj

@@ -1,14 +1,70 @@
 (ns fsm-clj.core-test
   (:require [clojure.test :refer :all]
-            [fsm-clj.core :as fsm]))
+            [fsm-clj.core :refer :all]))
+
+(defsm simple-turnstile
+  [[:locked -> :unlocked when :coin]
+   [:unlocked -> :locked when :push]])
+(deftest simple-transitions
+  (testing "Basic state transition"
+    (is (-> (simple-turnstile)
+            (send-event :coin)
+            :state
+            (= :unlocked)))))
+
+(defn inc-amount [acc _] (inc acc))
+(defsm turnstile-with-accumulator
+  [[:locked -> :unlocked when :coin action `inc-amount]
+   [:unlocked -> :locked when :push]])
+(deftest accumulators+actions
+  (testing "The accumulator is properly calculated"
+    (is (-> (turnstile-with-accumulator 0)
+            (send-event :coin)
+            (send-event :push)
+            (send-event :coin)
+            :value
+            (= 2)))))
+
+(defn add-amount [acc amount] (+ acc amount))
+(defsm turnstile-with-accumulator2
+  [[:locked -> :unlocked when :coin action `add-amount]
+   [:unlocked -> :locked when :push]])
+(deftest events-with-payload
+  (testing ""
+    (is (-> (turnstile-with-accumulator2 0)
+            (send-event :coin 50)
+            (send-event :push)
+            (send-event :coin 100)
+            :value
+            (= 150)))))
+
+(defn guard-handler [_state amount]
+  (>= amount 50))
+(defsm turnstile-with-guard
+  [[:locked -> :unlocked when :coin action `add-amount guard `guard-handler]
+   [:unlocked -> :locked when :push]])
+
+(deftest guard
+  (testing "An amount < than 50 should not unlock the turnstile"
+    (is (-> (turnstile-with-guard 0)
+            (send-event :coin 25)
+            :state
+            (= :locked))))
+  (testing "An Amount greater or equal 50 should unlock the turnstile"
+    (is (-> (turnstile-with-guard 0)
+            (send-event :coin 50)
+            :state
+            (= :unlocked)))))
+
+
+;; generic traffic light fsm tests
+
 
 (defn inc-handler [acc message]
   (or message (inc acc)))
-
 (defn foo-guard [_ message]
   (>= message 10))
-
-(fsm/defsm traffic-light
+(defsm traffic-light
   [[:green -> :yellow when :to-yellow action `inc-handler]
    [:yellow -> :red when :to-red action `inc-handler]
    [:red -> :green when :to-green guard `foo-guard]])
@@ -32,30 +88,30 @@
       (is (-> fsm :state (= :green)))))
 
   (testing "A valid transition should change the state"
-    (is (-> traffic-light-fsm (fsm/send-event :to-yellow) :state (= :yellow))))
+    (is (-> traffic-light-fsm (send-event :to-yellow) :state (= :yellow))))
 
   (testing "An invalid transition should not change the state"
-    (is (-> traffic-light-fsm (fsm/send-event :to-red) :state (= :green))))
+    (is (-> traffic-light-fsm (send-event :to-red) :state (= :green))))
 
   (testing "The transition action should be executed"
     (is (-> traffic-light-fsm
-            (fsm/send-event :to-yellow)
-            (fsm/send-event :to-red)
+            (send-event :to-yellow)
+            (send-event :to-red)
             :value
             (= 2))))
 
   (testing "We can pass message to transition in send-event"
     (is (-> traffic-light-fsm
-            (fsm/send-event :to-yellow)
-            (fsm/send-event :to-red -1)
+            (send-event :to-yellow)
+            (send-event :to-red -1)
             :value
             (= -1))))
 
   (testing "Guard is executed before action and prevent the state to change"
     (is (-> traffic-light-fsm
-            (fsm/send-event :to-yellow)
-            (fsm/send-event :to-red)
-            (fsm/send-event :to-green 8)
+            (send-event :to-yellow)
+            (send-event :to-red)
+            (send-event :to-green 8)
             :state
             (= :red)))))