Integrant exercise finalized + README: test chapter

Author: karimarttila

webstore-demo/integrant-simple-server/README.md

@@ -7,6 +7,7 @@
 - [Application State Management](#application-state-management)
   - [Manual State Management](#manual-state-management)
   - [State Management Using Integrant](#state-management-using-integrant)
+  - [State Management in Tests](#state-management-in-tests)
   - [Comparison](#comparison)
 - [Personal Experiences](#personal-experiences)
 - [The Rest of the Application](#the-rest-of-the-application)
@@ -67,6 +68,21 @@ In REPL driven development you can then use three ```integrant.repl``` namespace
 - halt: halt the system (in our case stop the web server)
 - reset: reset the system
 
+## State Management in Tests
+
+One more comparison. Let's first show how to handle state in the tests in which we want to start/stop webserver. First in manual state management:
+
+![alt text](doc/manual_test.png)
+
+So, we just use the ```start-web-server``` and ```stop-web-server``` functions.
+
+Then the same using Integrant:
+
+![alt text](doc/integrant_test.png)
+
+This time we can use Integrant state management. First call the Integrant ```init``` function with the system configuration and store the returned system map so that after the test we can halt the system using Integrant ```halt!``` function (stop web server in our case).
+
+
 ## Comparison
 
 So, which one is better? I'm not sure. For smaller applications it might be feasible just to implement your custom state management - and one less dependency in your ```deps.edn``` file. But if you have a bigger application with a lot of states and dependencies between different parts of the states then you might benefit using a dedicated state management library. I actually ran a very informal gallup in Metosin Slack regarding whether Metosin programmers favor custom state management or use some state management library. Two developers favored custom state management, others some 8 guys (which clicked either emoji in Slack) favored state management, all of them Integrant. Considering that these guys are pretty seasoned Clojure programmers I would say that you won't miss your target if you choose Integrant.

webstore-demo/integrant-simple-server/deps.edn

@@ -3,7 +3,8 @@
 
  :aliases {
            :dev                    {:extra-paths ["dev-resources"]
-                                    :extra-deps  {org.clojure/clojure {:mvn/version "1.10.1"}}}
+                                    :extra-deps  {org.clojure/clojure {:mvn/version "1.10.1"}
+                                                  }}
 
            :test                   {:extra-paths ["test/clj"]}
 
@@ -12,7 +13,8 @@
            ;; Let's learn to use a common part already now since in the next exercise we create frontend with re-frame.
            :common                 {:extra-paths ["src/cljc"]
                                     :extra-deps  {metosin/reitit {:mvn/version "0.4.2"}
-                                                  integrant/repl {:mvn/version "0.3.1"}}}
+                                                  integrant/repl {:mvn/version "0.3.1"}
+                                                  }}
 
            :backend                {:extra-paths ["src/clj"]
                                     :extra-deps  {

webstore-demo/integrant-simple-server/doc/integrant_test.png

@@ -0,0 +1,49 @@
+(ns simpleserver.session.session-common
+  (:require [clojure.tools.logging :as log]
+            [buddy.sign.jwt :as buddy-jwt]
+            [clj-time.core :as c-time]
+            [simpleserver.util.config :as ss-config]
+            ))
+
+(def my-hex-secret
+  "Creates dynamically a hex secret when the server boots."
+  ((fn []
+     (let [my-chars (->> (range (int \a) (inc (int \z))) (map char))
+           my-ints (->> (range (int \0) (inc (int \9))) (map char))
+           my-set (lazy-cat my-chars my-ints)
+           hexify (fn [s]
+                    (apply str
+                           (map #(format "%02x" (int %)) s)))]
+       (hexify (repeatedly 24 #(rand-nth my-set)))))))
+
+(defn create-json-web-token
+  [email]
+  (log/debug (str "ENTER create-json-web-token, email: " email))
+  (let [my-secret my-hex-secret
+        exp-time (c-time/plus (c-time/now) (c-time/seconds (get-in ss-config/config [:jwt :exp])))
+        my-claim {:email email :exp exp-time}
+        json-web-token (buddy-jwt/sign my-claim my-secret)]
+    json-web-token))
+
+(defn validate-token
+  [token get-token remove-token]
+  (log/debug (str "ENTER validate-token, token: " token))
+  (let [found-token (get-token token)]
+    ;; Part #1 of validation.
+    (if (nil? found-token)
+      (do
+        (log/warn (str "Token not found in my sessions - unknown token: " token))
+        nil)
+      ;; Part #2 of validation.
+      (try
+        (buddy-jwt/unsign token my-hex-secret)
+        (catch Exception e
+          (if (.contains (.getMessage e) "Token is expired")
+            (do
+              (log/debug (str "Token is expired, removing it from my sessions and returning nil: " token))
+              (remove-token token)
+              nil)
+            ; Some other issue, throw it.
+            (do
+              (log/error (str "Some unknown exception when handling expired token, exception: " (.getMessage e)) ", token: " token)
+              nil)))))))

webstore-demo/integrant-simple-server/doc/manual_test.png

@@ -0,0 +1,19 @@
+(ns simpleserver.session.session-config
+  (:require [clojure.tools.logging :as log]
+            [simpleserver.util.config :as ss-config]
+            [simpleserver.session.session-single-node :as ss-single-node]
+            [simpleserver.session.session-dynamodb :as ss-dynamodb]))
+
+(defn -get-session-env
+  "Gets session environment (either single-node or aws based on config.edn)."
+  [db-env]
+  ; See comment in domain-config which applies also here.
+  (log/debug "ENTER -get-session-env")
+  (cond
+    (= db-env "single-node") (ss-single-node/->SingleNodeR)
+    (= db-env "aws") (ss-dynamodb/->AwsDynamoDbR)
+    :else (throw (UnsupportedOperationException. (str "Unknown environment: " db-env)))
+    )
+  )
+
+(def session (-get-session-env (ss-config/config :db-env)))

webstore-demo/integrant-simple-server/src/clj/simpleserver/session/session_common.clj

@@ -0,0 +1,101 @@
+(ns simpleserver.session.session-dynamodb
+  (:require [simpleserver.session.session-interface :as ss-session-i]
+            [simpleserver.session.session-common :as ss-session-common]
+            [clojure.tools.logging :as log]
+            [cognitect.aws.client.api :as aws]
+            [simpleserver.util.config :as ss-config]))
+
+(defn get-all-sessions-from-dynamodb
+  []
+  (let [{my-ddb   :my-ddb
+           my-table :my-table} (ss-config/get-dynamodb-config "session")
+          items (aws/invoke my-ddb {:op      :Scan
+                                    :request {
+                                              :TableName my-table}})]
+      (reduce (fn [sessions session]
+                (conj sessions (get-in session [:token :S])))
+              #{}
+              (items :Items))))
+
+(defn get-token
+  [token]
+  (let [{my-ddb   :my-ddb
+         my-table :my-table} (ss-config/get-dynamodb-config "session")
+        result (aws/invoke my-ddb {:op      :GetItem
+                                   :request {:TableName my-table
+                                             :Key       {"token" {:S token}}}})]
+    (get-in result [:Item :token :S])))
+
+(defn remove-token
+  [token]
+  (let [{my-ddb   :my-ddb
+         my-table :my-table} (ss-config/get-dynamodb-config "session")
+        result (aws/invoke my-ddb {:op      :DeleteItem
+                                   :request {
+                                             :TableName my-table
+                                             :Key       {"token" {:S token}}}})]
+    result))
+
+(defrecord AwsDynamoDbR []
+  ss-session-i/SessionInterface
+
+  (create-json-web-token
+    [this email]
+    (log/debug (str "ENTER create-json-web-token, email: " email))
+    (let [json-web-token (ss-session-common/create-json-web-token email)
+          {my-ddb   :my-ddb
+           my-table :my-table} (ss-config/get-dynamodb-config "session")
+          _ (aws/invoke my-ddb {:op      :PutItem
+                                     :request {
+                                               :TableName my-table
+                                               :Item      {"token" {:S json-web-token}}}})]
+      ; https://docs.aws.amazon.com/cli/latest/reference/dynamodb/put-item.html
+      ; The ReturnValues parameter is used by several DynamoDB operations; however, PutItem does not recognize any values other than NONE or ALL_OLD .
+      json-web-token))
+
+  (validate-token
+    [this token]
+    (log/debug (str "ENTER validate-token, token: " token))
+    (ss-session-common/validate-token token get-token remove-token)
+    )
+
+  (-get-sessions
+    [this]
+    (log/debug (str "ENTER -get-sessions"))
+    (get-all-sessions-from-dynamodb))
+
+  (-reset-sessions!
+    [this]
+    (log/debug (str "ENTER -reset-sessions!"))
+    (let [sessions (get-all-sessions-from-dynamodb)
+          ]
+      (dorun (map remove-token sessions)))))
+
+(comment
+  ; Refresh interface after changes in implementation.
+  (mydev/refresh)
+
+  (get-all-sessions-from-dynamodb)
+
+  (def my-token (let [my-aws-session simpleserver.session.session-config/session
+                      result (ss-session-i/create-json-web-token my-aws-session "kari.karttinen@foo.com")]
+                  result)
+    )
+  my-token
+  (def validate-result (let [my-aws-session simpleserver.session.session-config/session
+                             result (ss-session-i/validate-token my-aws-session my-token)]
+                         result)
+    )
+
+  (def sessions (let [my-aws-session simpleserver.session.session-config/session
+                             result (ss-session-i/-get-sessions my-aws-session)]
+                         result)
+    )
+  sessions
+  (def reset-result (let [my-aws-session simpleserver.session.session-config/session
+                             result (ss-session-i/-reset-sessions! my-aws-session)]
+                         result)
+    )
+  (get-all-sessions-from-dynamodb)
+  )
+

webstore-demo/integrant-simple-server/src/clj/simpleserver/session/session_config.clj

@@ -0,0 +1,20 @@
+(ns simpleserver.session.session-interface)
+
+(defprotocol SessionInterface
+  (create-json-web-token [env email]
+    "Creates the JSON web token and adds it to the sessions database.")
+  (validate-token [env token]
+    "Validates the token. Returns {:email :exp} from token if session ok,
+    nil otherwise. Token validation has two parts:
+    1. Check that we actually created the token in the first place (should find it in the session db).
+    2. Validate the token with buddy (can unsign it, token is not expired).")
+  (-get-sessions [env]
+    "Gets all sessions - used in testing.")
+  (-reset-sessions! [env]
+    "Resets all sessions - used in testing.")
+  )
+
+
+
+
+

webstore-demo/integrant-simple-server/src/clj/simpleserver/session/session_dynamodb.clj

@@ -0,0 +1,50 @@
+(ns simpleserver.session.session-single-node
+  (:require
+    [clojure.tools.logging :as log]
+    [simpleserver.util.config :as ss-config]
+    [simpleserver.session.session-interface]
+    [simpleserver.session.session-common]))
+
+(def my-sessions
+  "Atom to store the sessions. NOTE: Not a map but a set."
+  (atom #{}))
+
+(defn get-token
+  [token]
+  (if (contains? @my-sessions token)
+    token
+    nil))
+
+(defn remove-token
+  [token]
+  (if (contains? @my-sessions token)
+    (swap! my-sessions disj token)
+    (log/warn (str "Expired token not found when removing it from my sessions: " token))))
+
+(defrecord SingleNodeR []
+  simpleserver.session.session-interface/SessionInterface
+
+  (create-json-web-token
+    [this email]
+    (log/debug (str "ENTER create-json-web-token, email: " email))
+    (let [json-web-token (simpleserver.session.session-common/create-json-web-token email)
+          _ (swap! my-sessions conj json-web-token)]
+      json-web-token))
+
+  (validate-token
+    [this token]
+    (log/debug (str "ENTER validate-token, token: " token))
+    (simpleserver.session.session-common/validate-token token get-token remove-token))
+
+  (-get-sessions
+    [this]
+    (log/debug (str "ENTER -get-sessions"))
+    @my-sessions)
+
+  (-reset-sessions!
+    [this]
+    (log/debug (str "ENTER -reset-sessions!"))
+    (if (= (ss-config/config :runtime-env) "dev")
+      (reset! my-sessions #{})
+      (throw (java.lang.UnsupportedOperationException. "You can reset sessions only in development environment!"))))
+  )

webstore-demo/integrant-simple-server/src/clj/simpleserver/session/session_interface.clj

@@ -0,0 +1,26 @@
+(ns simpleserver.user.user-common
+  (:require [simpleserver.util.config :as ss-config]
+            [clojure.data.csv :as csv]
+            [clojure.java.io :as io]))
+
+;; NOTE: We don't use incremental user ids since it is a bit anti-pattern in DynamoDB (since email is the hash key). So, we create uuid for userid.
+;; I guess the same applies to Azure Table Storage as well so using uuid here as RowKey.
+(defn uuid
+  []
+  (.toString (java.util.UUID/randomUUID)))
+
+(defn get-initial-users
+  []
+  (let [data-dir (get-in ss-config/config [:single-node-data :data-dir])
+        raw-users (try
+                    (with-open [reader (io/reader (str data-dir "/initial-users.csv"))]
+                      (doall
+                        (csv/read-csv reader :separator \tab)))
+                    (catch java.io.FileNotFoundException _ []))]
+    (reduce (fn [users user]
+              (assoc users (first user)
+                           {:userid          (nth user 0)
+                            :email           (nth user 1)
+                            :first-name      (nth user 2)
+                            :last-name       (nth user 3)
+                            :hashed-password (nth user 4)})) {} raw-users)))