From 1384c52d75dcf0ded83e82cb03b12b563c32f2e9 Mon Sep 17 00:00:00 2001
From: gered <gered@blarg.ca>
Date: Tue, 4 Jan 2022 19:19:43 -0500
Subject: [PATCH] on-expiry now also receives a "reason" parameter when called

---
 src/aging_session/core.clj       |  8 +++++---
 test/aging_session/core_test.clj | 16 +++++++++-------
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/aging_session/core.clj b/src/aging_session/core.clj
index d618483..60f48d8 100644
--- a/src/aging_session/core.clj
+++ b/src/aging_session/core.clj
@@ -91,7 +91,7 @@
               (get key)
               (get :value))
           (when on-expiry
-            (on-expiry key (:value existing-entry))
+            (on-expiry key (:value existing-entry) :expired)
             nil)))))
 
   (write-session [_ key data]
@@ -107,7 +107,7 @@
               expired?       (entry-expired? ttl existing-entry)]
           (swap! session-atom process-write-entry key data refresh-on-write)
           (if expired?
-            (on-expiry key (:value existing-entry))))
+            (on-expiry key (:value existing-entry) :expired)))
         ; if there's no on-expiry listener, we can simply process the write
         (swap! session-atom process-write-entry key data refresh-on-write))
       key))
@@ -134,7 +134,9 @@
           (when expired-keys
             (future
               (doseq [expired-key expired-keys]
-                (on-expiry expired-key (-> old (get expired-key) :value))))))))
+                (on-expiry expired-key
+                           (-> old (get expired-key) :value)
+                           :expired)))))))
     (Thread/sleep sweep-interval)
     (recur)))
 
diff --git a/test/aging_session/core_test.clj b/test/aging_session/core_test.clj
index 8c41447..79da89f 100644
--- a/test/aging_session/core_test.clj
+++ b/test/aging_session/core_test.clj
@@ -238,7 +238,7 @@
 
 (deftest expiry-listener-triggered-when-read-session-expires-entry
   (let [expired (atom nil)
-        as      (aging-memory-store 1 {:on-expiry #(reset! expired [%1 %2])})]
+        as      (aging-memory-store 1 {:on-expiry #(reset! expired [%1 %2 %3])})]
     (testing "before ttl elapses"
       (write-session as "foo" {:foo 1})
       (is (= (read-session as "foo") {:foo 1}))
@@ -247,11 +247,11 @@
     (testing "after ttl has elapsed"
       (is (nil? @expired))
       (is (nil? (read-session as "foo")))
-      (is (= ["foo" {:foo 1}] @expired)))))
+      (is (= ["foo" {:foo 1} :expired] @expired)))))
 
 (deftest expiry-listener-not-triggered-for-other-read-sessions-even-with-an-expired-entry
   (let [expired (atom nil)
-        as      (aging-memory-store 1 {:on-expiry #(reset! expired [%1 %2])})]
+        as      (aging-memory-store 1 {:on-expiry #(reset! expired [%1 %2 %3])})]
     (testing "before ttl elapses"
       (write-session as "foo" {:foo 1})
       (write-session as "bar" {:bar 1})
@@ -272,11 +272,11 @@
       (is (nil? @expired))
       (is (nil? (read-session as "foo")))
       (is (= (read-session as "bar") {:bar 1}))
-      (is (= ["foo" {:foo 1}] @expired)))))
+      (is (= ["foo" {:foo 1} :expired] @expired)))))
 
 (deftest expiry-listener-triggered-when-write-session-overwrites-expired-entry
   (let [expired (atom nil)
-        as      (aging-memory-store 1 {:on-expiry #(reset! expired [%1 %2])})]
+        as      (aging-memory-store 1 {:on-expiry #(reset! expired [%1 %2 %3])})]
     (testing "before ttl elapses"
       (write-session as "foo" {:foo 1})
       (is (= (read-session as "foo") {:foo 1}))
@@ -286,13 +286,14 @@
       (is (nil? @expired))
       (write-session as "foo" {:foo 2})
       (is (= (read-session as "foo") {:foo 2}))
-      (is (= ["foo" {:foo 1}] @expired)))))
+      (is (= ["foo" {:foo 1} :expired] @expired)))))
 
 (deftest sweeper-thread-triggers-expiry-listeners-for-all-expired-entries
   (let [expired (atom {})
         as      (aging-memory-store 1 {:sweep-interval 1
                                        :on-expiry      #(swap! expired assoc %1 {:timestamp (System/currentTimeMillis)
-                                                                                 :value     %2})})]
+                                                                                 :value     %2
+                                                                                 :reason    %3})})]
     (testing "before ttl elapses or sweeper thread runs"
       (write-session as "foo" {:foo 1})
       (write-session as "bar" {:bar 1})
@@ -309,6 +310,7 @@
       (Thread/sleep 3000))
     (testing "after ttl elapses and sweeper thread has had enough time to run at least twice"
       (is (= 3 (count @expired)))
+      (is (every? #(= :expired (:reason %)) (vals @expired)))
       (let [foo-bar-time-diff (Math/abs (- (:timestamp (get @expired "foo"))
                                            (:timestamp (get @expired "bar"))))
             keep-time-diff    (- (:timestamp (get @expired "keep"))