add mock clock

Author: Vadim Platonov

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.3.1
+
+### New Features
+
+* `clock?` predicate
+* `mock-clock` - returns a mocked instance of `java.time.Clock`.
+
 ## 0.3.0
 
 ### Breaking changes

README.md

@@ -426,6 +426,25 @@ the `with-clock` macro and the corresponding `with-clock-fn` function:
 => #<java.time.ZoneRegion UTC>
 ```
 
+In addition to the built-in `java.time` clocks, we provide a Mock clock which
+can be very handy in testing:
+
+```clojure
+(def clock (mock-clock 0 "UTC"))
+=> #'user/clock
+
+(with-clock clock
+  (j/instant))
+=> #object[java.time.Instant "1970-01-01T00:00:00Z"]
+
+(advance-clock! clock (plus (hours 5) (minutes 20)))
+=> nil
+
+(with-clock clock
+  (j/instant))
+=> #object[java.time.Instant "1970-01-01T05:20:00Z"]
+```
+
 Clock overrides works for all of the date-time types.
 
 #### Fields, Units and Properties

src/java_time.clj

@@ -3,7 +3,7 @@
   (:require [java-time.potemkin.namespaces :as potemkin]
             [java-time.util :as jt.u]
             [java-time core properties temporal amount zone single-field local chrono
-             convert sugar seqs adjuster interval format joda clock pre-java8]))
+             convert sugar seqs adjuster interval format joda clock pre-java8 mock]))
 
 (potemkin/import-vars
   [java-time.clock
@@ -39,10 +39,13 @@
   [java-time.zone
    available-zone-ids zone-id zone-offset
    offset-date-time offset-time zoned-date-time
-   system-clock fixed-clock offset-clock tick-clock
+   system-clock fixed-clock offset-clock tick-clock clock?
    zoned-date-time? offset-date-time? offset-time?
    with-zone-same-instant with-offset with-offset-same-instant]
 
+  [java-time.mock
+   mock-clock advance-clock!]
+
   [java-time.convert
    as-map convert-amount to-java-date to-sql-date to-sql-timestamp
    to-millis-from-epoch]

src/java_time/mock.clj

@@ -0,0 +1,57 @@
+(ns java-time.mock
+  (:require [java-time
+             [core :as core]
+             [temporal :as temporal]
+             [zone :as zone]])
+  (:import (java.time Clock)))
+
+(definterface IMockClock
+  (^void advanceClock [amount]))
+
+(defn ^Clock mock-clock
+  "Returns a mock implementation of the `java.time.Clock`. The mock supports
+  `advance-clock!` operation which allows to move the time in the clock, e.g.:
+
+  (let [clock (mock-clock 0 \"UTC\")]
+    (with-clock clock
+      (is (= (value clock) 0))
+      (is (= (instant) (instant 0)))
+      (advance-clock! clock (j/millis 1))
+      (is (= (value clock) 1))
+      (is (= (instant) (instant 1)))))
+
+  You can move the clock back via advancing by a negative temporal amount.
+
+  Creates a clock at epoch in the default timezone when called without arguments."
+  ([] (mock-clock 0))
+  ([instant] (mock-clock instant (zone/zone-id)))
+  ([instant zone]
+   (let [!instant (atom (temporal/instant instant))
+         zone (zone/zone-id zone)]
+     (proxy [Clock IMockClock] []
+       (advanceClock [amount]
+         (swap! !instant core/plus amount)
+         nil)
+
+       (getZone [] zone)
+       (withZone [zone']
+         (mock-clock @!instant zone'))
+       (instant [] @!instant)
+
+       (equals [other]
+         (if (and (instance? IMockClock other) (zone/clock? other))
+           (let [^Clock clock other]
+             (and (= zone (.getZone clock))
+                  (= @!instant (.instant clock))))
+           false))
+       (hashCode []
+         (bit-xor (hash @!instant) (hash zone)))
+       (toString []
+         (str "MockClock[" @!instant "," zone "]"))))))
+
+(defn advance-clock!
+  "Advances the `clock` by the given time `amount`.
+
+  This mutates the mock clock."
+  [^IMockClock clock amount]
+  (.advanceClock clock amount))

src/java_time/zone.clj

@@ -408,6 +408,10 @@
   ([d] (Clock/tick (system-clock) (jt.a/duration d)))
   ([^Clock c, d] (Clock/tick c (jt.a/duration d))))
 
+(defn clock?
+  "Returns true if `x` is an instance of `java.time.Clock`."
+  [x] (instance? Clock x))
+
 (extend-type Clock
   jt.c/ReadableProperty
   (value [c] (.millis c))

test/java_time_test.clj

@@ -441,6 +441,44 @@
     (is (j/after? (j/month-day 5 1) (j/month-day 4 1)))
     (is (j/before? (j/month-day 1 1) (j/month-day 4 1)))))
 
+(deftest mock-clock
+  (testing "constructors"
+    (is (= (j/mock-clock)
+           (j/mock-clock 0)
+           (j/mock-clock 0 (j/zone-id)))))
+
+  (let [utc-clock #(j/mock-clock % "UTC")]
+    (testing "accessors"
+      (let [clock (utc-clock 0)]
+        (is (= 0 (j/value clock)))
+        (is (= (j/zone-id "UTC") (j/zone-id clock)))))
+
+    (testing "equality"
+      (is (= (utc-clock 0) (utc-clock 0)))
+      (is (= (hash (utc-clock 0)) (hash (utc-clock 0))))
+      (is (not= (utc-clock 0) (utc-clock 1)))
+      (is (not= (utc-clock 0) (j/mock-clock 0 "GMT"))))
+
+    (testing "advance"
+      (let [clock (utc-clock 0)]
+        (testing "by positive amount"
+          (j/advance-clock! clock (j/millis 1))
+          (is (= 1 (j/value clock))))
+
+        (testing "by negative amount"
+          (j/advance-clock! clock (j/millis -1))
+          (is (= 0 (j/value clock))))
+
+        (testing "clone with a different zone"
+          (let [cloned-clock (j/with-zone clock "GMT")]
+            (is (not (identical? clock cloned-clock)))
+            (is (= (j/zone-id "GMT") (j/zone-id cloned-clock)))
+            (is (= (j/value cloned-clock) (j/value clock)))
+
+            (j/advance-clock! cloned-clock (j/seconds 1))
+            (is (= 1000 (j/value cloned-clock)))
+            (is (not= (j/value cloned-clock) (j/value clock)))))))))
+
 (deftest properties
   (testing "units"
     (is (= (j/unit :seconds)